iceoryx_hoofs 2.0.5
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Friends | List of all members
iox::cxx::string< Capacity > Class Template Reference

string implementation with some adjustments in the API, because we are not allowed to throw exceptions or use heap. More...

#include <iceoryx_hoofs/cxx/string.hpp>

Public Member Functions

constexpr string () noexcept=default
 creates an empty string with size 0
 
 string (const string &other) noexcept
 copy constructor
 
 string (string &&other) noexcept
 move constructor
 
stringoperator= (const string &rhs) noexcept
 copy assignment
 
stringoperator= (string &&rhs) noexcept
 move assignment
 
template<uint64_t N>
 string (const string< N > &other) noexcept
 creates a new string of given capacity as a copy of other with compile time check whether the capacity of other is less than or equal to this' capacity
 
template<uint64_t N>
 string (string< N > &&other) noexcept
 moves other to this with compile time check whether the capacity of other is less than or equal to this' capacity
 
template<uint64_t N>
stringoperator= (const string< N > &rhs) noexcept
 assigns rhs fixed string to this with compile time check whether the capacity of rhs is less than or equal to this' capacity
 
template<uint64_t N>
stringoperator= (string< N > &&rhs) noexcept
 moves rhs fixed string to this with compile time check whether the capacity of rhs is less than or equal to this' capacity
 
template<uint64_t N>
 string (const char(&other)[N]) noexcept
 conversion constructor for char array with compile time check if the array size is less than or equal to the string capacity
 
 string (TruncateToCapacity_t, const char *const other) noexcept
 conversion constructor for cstring to string which truncates characters if the size is greater than the string capacity
 
 string (TruncateToCapacity_t, const std::string &other) noexcept
 conversion constructor for std::string to string which truncates characters if the std::string size is greater than the string capacity
 
 string (TruncateToCapacity_t, const char *const other, const uint64_t count) noexcept
 constructor from cstring to string. Constructs the string with the first count characters of the cstring including null characters. If count is greater than the string capacity the remainder of the characters are truncated.
 
template<uint64_t N>
stringoperator= (const char(&rhs)[N]) noexcept
 assigns a char array to string with compile time check if the array size is less than or equal to the string capacity
 
template<uint64_t N>
stringassign (const string< N > &str) noexcept
 fixed string assignment with compile time check if capacity of str is less than or equal to this' capacity
 
template<uint64_t N>
stringassign (const char(&str)[N]) noexcept
 assigns a char array to string with compile time check if the array size is less than or equal to the string capacity
 
bool unsafe_assign (const char *const str) noexcept
 assigns a cstring to string. The assignment fails if the cstring size is greater than the string capacity.
 
bool unsafe_assign (const std::string &str) noexcept
 assigns a std::string to string. The assignment fails if the std::string size is greater than the string capacity.
 
template<uint64_t N>
int64_t compare (const string< N > &other) const noexcept
 compares two strings
 
template<uint64_t N>
bool operator== (const string< N > &rhs) const noexcept
 checks if self is equal to rhs
 
template<uint64_t N>
bool operator!= (const string< N > &rhs) const noexcept
 checks if self is not equal to rhs
 
template<uint64_t N>
bool operator< (const string< N > &rhs) const noexcept
 checks if self is less than rhs, in lexicographical order
 
template<uint64_t N>
bool operator<= (const string< N > &rhs) const noexcept
 checks if self is less than or equal to rhs, in lexicographical order
 
template<uint64_t N>
bool operator> (const string< N > &rhs) const noexcept
 checks if self is greater than rhs, in lexicographical order
 
template<uint64_t N>
bool operator>= (const string< N > &rhs) const noexcept
 checks if self is greater than or equal to rhs, in lexicographical order
 
bool operator== (const char *const rhs) const noexcept
 The equality operator for fixed string and char pointer is disabled via a static_assert, because it may lead to undefined behavior if the char array is not null-terminated. Please convert the char array to a fixed string with string(TruncateToCapacity_t, const char* const other, const uint64_t count) before compare it to a fixed string.
 
bool operator!= (const char *const rhs) const noexcept
 The inequality operator for fixed string and char pointer is disabled via a static_assert, because it may lead to undefined behavior if the char array is not null-terminated. Please convert the char array to a fixed string with string(TruncateToCapacity_t, const char* const other, const uint64_t count) before compare it to a fixed string.
 
const char * c_str () const noexcept
 returns a pointer to the char array of self
 
constexpr uint64_t size () const noexcept
 returns the number of characters stored in the string
 
constexpr bool empty () const noexcept
 returns if the string is empty or not
 
 operator std::string () const noexcept
 converts the string to a std::string
 
template<typename T >
stringoperator+= (const T &) noexcept
 since there are two valid options for what should happen when appending a string larger than this' capacity (failing or truncating), the fixed string does not support operator+=; use append for truncating or unsafe_append for failing in that case
 
template<typename T >
std::enable_if< internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, string & >::type append (TruncateToCapacity_t, const T &t) noexcept
 appends a fixed string or string literal to the end of this. If this' capacity is too small for appending the whole string (literal) the remainder of the characters are truncated.
 
template<typename T >
std::enable_if< internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, bool >::type unsafe_append (const T &t) noexcept
 appends a fixed string or string literal to the end of this. The appending fails if the sum of both sizes is greater than this' capacity.
 
iox::cxx::optional< string< Capacity > > substr (const uint64_t pos, const uint64_t count) const noexcept
 creates a substring containing the characters from pos until count; if pos+count is greater than the size of the original string the returned substring only contains the characters from pos until size(); iox::cxx::nullopt is returned if pos is greater than the size of the original string;
 
iox::cxx::optional< string< Capacity > > substr (const uint64_t pos=0U) const noexcept
 creates a substring containing the characters from pos until size(); iox::cxx::nullopt is returned if pos is greater than the size of the original string
 
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type find (const T &t, const uint64_t pos=0U) const noexcept
 finds the first occurence of the given character sequence; returns the position of the first character of the found substring, returns iox::cxx::nullopt if no substring is found or if pos is greater than this' size
 
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type find_first_of (const T &t, const uint64_t pos=0U) const noexcept
 finds the first occurence of a character equal to one of the characters of the given character sequence and returns its position; returns iox::cxx::nullopt if no character is found or if pos is greater than this' size
 
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type find_last_of (const T &t, const uint64_t pos=Capacity) const noexcept
 finds the last occurence of a character equal to one of the characters of the given character sequence and returns its position; returns iox::cxx::nullopt if no character is found
 

Static Public Member Functions

static constexpr uint64_t capacity () noexcept
 returns the maximum number of characters that can be stored in the string
 

Friends

template<typename T1 , typename T2 >
std::enable_if<(internal::IsCharArray< T1 >::value||internal::IsCxxString< T1 >::value)&&(internal::IsCharArray< T2 >::value||internal::IsCxxString< T2 >::value), string< internal::GetCapa< T1 >::capa+internal::GetCapa< T2 >::capa > >::type concatenate (const T1 &t1, const T2 &t2) noexcept
 concatenates two fixed strings/string literals
 

Detailed Description

template<uint64_t Capacity>
class iox::cxx::string< Capacity >

string implementation with some adjustments in the API, because we are not allowed to throw exceptions or use heap.

Constructor & Destructor Documentation

◆ string() [1/8]

template<uint64_t Capacity>
iox::cxx::string< Capacity >::string ( const string< Capacity > &  other)
noexcept

copy constructor

Parameters
[in]otheris the copy origin

◆ string() [2/8]

template<uint64_t Capacity>
iox::cxx::string< Capacity >::string ( string< Capacity > &&  other)
noexcept

move constructor

Parameters
[in]otheris the move origin

◆ string() [3/8]

template<uint64_t Capacity>
template<uint64_t N>
iox::cxx::string< Capacity >::string ( const string< N > &  other)
noexcept

creates a new string of given capacity as a copy of other with compile time check whether the capacity of other is less than or equal to this' capacity

Parameters
[in]otheris the copy origin

◆ string() [4/8]

template<uint64_t Capacity>
template<uint64_t N>
iox::cxx::string< Capacity >::string ( string< N > &&  other)
noexcept

moves other to this with compile time check whether the capacity of other is less than or equal to this' capacity

Parameters
[in]otheris the move origin

◆ string() [5/8]

template<uint64_t Capacity>
template<uint64_t N>
iox::cxx::string< Capacity >::string ( const char(&)  other[N])
noexcept

conversion constructor for char array with compile time check if the array size is less than or equal to the string capacity

Template Parameters
Nis the implicit template parameter for the char array size
Parameters
[in]otheris the char array
Note
if the array is not zero-terminated, the last value will be overwritten with 0
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
string<4> fuu("abcd");
}
string implementation with some adjustments in the API, because we are not allowed to throw exception...
Definition string.hpp:90

◆ string() [6/8]

template<uint64_t Capacity>
iox::cxx::string< Capacity >::string ( TruncateToCapacity_t  ,
const char *const  other 
)
noexcept

conversion constructor for cstring to string which truncates characters if the size is greater than the string capacity

Parameters
[in]TruncateToCapacity_tis a compile time variable which is used to distinguish between constructors with certain behavior
[in]otheris the cstring to convert
Attention
truncates characters if the size is greater than the string capacity
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
string<4> fuu(TruncateToCapacity, "abcd");
}

◆ string() [7/8]

template<uint64_t Capacity>
iox::cxx::string< Capacity >::string ( TruncateToCapacity_t  ,
const std::string< Capacity > &  other 
)
noexcept

conversion constructor for std::string to string which truncates characters if the std::string size is greater than the string capacity

Parameters
[in]TruncateToCapacity_tis a compile time variable which is used to distinguish between constructors with certain behavior
[in]otheris the std::string to convert
Attention
truncates characters if the std::string size is greater than the string capacity
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
std::string bar = "bar";
string<4> fuu(TruncateToCapacity, bar);
}

◆ string() [8/8]

template<uint64_t Capacity>
iox::cxx::string< Capacity >::string ( TruncateToCapacity_t  ,
const char *const  other,
const uint64_t  count 
)
noexcept

constructor from cstring to string. Constructs the string with the first count characters of the cstring including null characters. If count is greater than the string capacity the remainder of the characters are truncated.

Parameters
[in]TruncateToCapacity_tis a compile time variable which is used to distinguish between constructors with certain behavior
[in]otheris the cstring to convert
[in]countis the number of characters for constructing the string
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
string<4> fuu(TruncateToCapacity, "abcd", 2);
}

Member Function Documentation

◆ append()

template<uint64_t Capacity>
template<typename T >
std::enable_if< internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, string & >::type iox::cxx::string< Capacity >::append ( TruncateToCapacity_t  ,
const T &  t 
)
noexcept

appends a fixed string or string literal to the end of this. If this' capacity is too small for appending the whole string (literal) the remainder of the characters are truncated.

Parameters
[in]TruncateToCapacity_tis a compile time variable which is used to make the user aware of the possible truncation
[in]tis the fixed string/string literal to append
Returns
reference to self
string<5> fuu("cde");
fuu.append(TruncateToCapacity, "fgahc");

◆ assign() [1/2]

template<uint64_t Capacity>
template<uint64_t N>
string & iox::cxx::string< Capacity >::assign ( const char(&)  str[N])
noexcept

assigns a char array to string with compile time check if the array size is less than or equal to the string capacity

Template Parameters
[in]N is the implicit template parameter for the char array size
Parameters
[in]stris the char array
Returns
reference to self
Note
if the array is not zero-terminated, the last value will be overwritten with 0
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
string<4> fuu;
char bar[] = "abcd";
fuu.assign(bar);
}
string & assign(const string< N > &str) noexcept
fixed string assignment with compile time check if capacity of str is less than or equal to this' cap...

◆ assign() [2/2]

template<uint64_t Capacity>
template<uint64_t N>
string & iox::cxx::string< Capacity >::assign ( const string< N > &  str)
noexcept

fixed string assignment with compile time check if capacity of str is less than or equal to this' capacity

Parameters
[in]stris the fixed string object to assign
Returns
reference to self

◆ c_str()

template<uint64_t Capacity>
const char * iox::cxx::string< Capacity >::c_str ( ) const
noexcept

returns a pointer to the char array of self

Returns
a pointer to the char array of self

◆ capacity()

template<uint64_t Capacity>
static constexpr uint64_t iox::cxx::string< Capacity >::capacity ( )
staticconstexprnoexcept

returns the maximum number of characters that can be stored in the string

Returns
the maximum number of characters that can be stored in the string

◆ compare()

template<uint64_t Capacity>
template<uint64_t N>
int64_t iox::cxx::string< Capacity >::compare ( const string< N > &  other) const
noexcept

compares two strings

Parameters
[in]otheris the string to compare with self
Returns
an integer < 0 if the first character that does not match has a lower value in self than in other, 0 if the contents of both strings are equal, an integer > 0 if the first character that does not match has a greater value in self than in other

◆ empty()

template<uint64_t Capacity>
constexpr bool iox::cxx::string< Capacity >::empty ( ) const
constexprnoexcept

returns if the string is empty or not

Returns
true if size() == 0 otherwise false

◆ find()

template<uint64_t Capacity>
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type iox::cxx::string< Capacity >::find ( const T &  t,
const uint64_t  pos = 0U 
) const
noexcept

finds the first occurence of the given character sequence; returns the position of the first character of the found substring, returns iox::cxx::nullopt if no substring is found or if pos is greater than this' size

Parameters
[in]tis the character sequence to search for; must be a cxx::string, string literal or std::string
[in]posis the position at which to start the search
Returns
an optional containing the position of the first character of the found substring, iox::cxx::nullopt if no substring is found

◆ find_first_of()

template<uint64_t Capacity>
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type iox::cxx::string< Capacity >::find_first_of ( const T &  t,
const uint64_t  pos = 0U 
) const
noexcept

finds the first occurence of a character equal to one of the characters of the given character sequence and returns its position; returns iox::cxx::nullopt if no character is found or if pos is greater than this' size

Parameters
[in]tis the character sequence to search for; must be a cxx::string, string literal or std::string
[in]posis the position at which to start the search
Returns
an optional containing the position of the first character equal to one of the characters of the given character sequence, iox::cxx::nullopt if no character is found

◆ find_last_of()

template<uint64_t Capacity>
template<typename T >
std::enable_if< std::is_same< T, std::string >::value||internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, iox::cxx::optional< uint64_t > >::type iox::cxx::string< Capacity >::find_last_of ( const T &  t,
const uint64_t  pos = Capacity 
) const
noexcept

finds the last occurence of a character equal to one of the characters of the given character sequence and returns its position; returns iox::cxx::nullopt if no character is found

Parameters
[in]tis the character sequence to search for; must be a cxx::string, string literal or std::string
[in]posis the position at which to finish the search
Returns
an optional containing the position of the last character equal to one of the characters of the given character sequence, iox::cxx::nullopt if no character is found

◆ operator std::string()

template<uint64_t Capacity>
iox::cxx::string< Capacity >::operator std::string ( ) const
noexcept

converts the string to a std::string

Returns
a std::string with data equivalent to those stored in the string

◆ operator!=() [1/2]

template<uint64_t Capacity>
bool iox::cxx::string< Capacity >::operator!= ( const char *const  rhs) const
noexcept

The inequality operator for fixed string and char pointer is disabled via a static_assert, because it may lead to undefined behavior if the char array is not null-terminated. Please convert the char array to a fixed string with string(TruncateToCapacity_t, const char* const other, const uint64_t count) before compare it to a fixed string.

Parameters
[in]rhsis the char pointer to the array to compare
Returns
false
Todo:
consider implementing the inequality operator for a char array for which the size is known at compile time; it could have the following signature template <int N> bool operator!=(const char (&rhs)[N]) const noexcept

◆ operator!=() [2/2]

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator!= ( const string< N > &  rhs) const
noexcept

checks if self is not equal to rhs

Parameters
[in]rhsis the string to compare with self
Returns
true if both strings are not equal, otherwise false

◆ operator<()

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator< ( const string< N > &  rhs) const
noexcept

checks if self is less than rhs, in lexicographical order

Parameters
[in]rhsis the string to compare with self
Returns
true if self is less than rhs, otherwise false

◆ operator<=()

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator<= ( const string< N > &  rhs) const
noexcept

checks if self is less than or equal to rhs, in lexicographical order

Parameters
[in]rhsis the string to compare with self
Returns
true if self is less than or equal to rhs, otherwise false

◆ operator=() [1/5]

template<uint64_t Capacity>
template<uint64_t N>
string & iox::cxx::string< Capacity >::operator= ( const char(&)  rhs[N])
noexcept

assigns a char array to string with compile time check if the array size is less than or equal to the string capacity

Template Parameters
[in]N is the implicit template parameter for the char array size
Parameters
[in]rhsis the char array
Returns
reference to self
Note
if the array is not zero-terminated, the last value will be overwritten with 0
#include "iceoryx_hoofs/cxx/string.hpp"
using namespace iox::cxx;
int main()
{
string<4> fuu = "abcd";
}

◆ operator=() [2/5]

template<uint64_t Capacity>
string & iox::cxx::string< Capacity >::operator= ( const string< Capacity > &  rhs)
noexcept

copy assignment

Parameters
[in]rhsis the copy origin
Returns
reference to self

◆ operator=() [3/5]

template<uint64_t Capacity>
template<uint64_t N>
string & iox::cxx::string< Capacity >::operator= ( const string< N > &  rhs)
noexcept

assigns rhs fixed string to this with compile time check whether the capacity of rhs is less than or equal to this' capacity

Parameters
[in]rhsis the copy origin
Returns
reference to self

◆ operator=() [4/5]

template<uint64_t Capacity>
string & iox::cxx::string< Capacity >::operator= ( string< Capacity > &&  rhs)
noexcept

move assignment

Parameters
[in]rhsis the move origin
Returns
reference to self

◆ operator=() [5/5]

template<uint64_t Capacity>
template<uint64_t N>
string & iox::cxx::string< Capacity >::operator= ( string< N > &&  rhs)
noexcept

moves rhs fixed string to this with compile time check whether the capacity of rhs is less than or equal to this' capacity

Parameters
[in]rhsis the move origin
Returns
reference to self

◆ operator==() [1/2]

template<uint64_t Capacity>
bool iox::cxx::string< Capacity >::operator== ( const char *const  rhs) const
noexcept

The equality operator for fixed string and char pointer is disabled via a static_assert, because it may lead to undefined behavior if the char array is not null-terminated. Please convert the char array to a fixed string with string(TruncateToCapacity_t, const char* const other, const uint64_t count) before compare it to a fixed string.

Parameters
[in]rhsis the char pointer to the array to compare
Returns
false
Todo:
consider implementing the equality operator for a char array for which the size is known at compile time; it could have the following signature template <int N> bool operator==(const char (&rhs)[N]) const noexcept

◆ operator==() [2/2]

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator== ( const string< N > &  rhs) const
noexcept

checks if self is equal to rhs

Parameters
[in]rhsis the string to compare with self
Returns
true if both strings are equal, otherwise false

◆ operator>()

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator> ( const string< N > &  rhs) const
noexcept

checks if self is greater than rhs, in lexicographical order

Parameters
[in]rhsis the string to compare with self
Returns
true if self is greater than rhs, otherwise false

◆ operator>=()

template<uint64_t Capacity>
template<uint64_t N>
bool iox::cxx::string< Capacity >::operator>= ( const string< N > &  rhs) const
noexcept

checks if self is greater than or equal to rhs, in lexicographical order

Parameters
[in]rhsis the string to compare with self
Returns
true if self is greater than or equal to rhs, otherwise false

◆ size()

template<uint64_t Capacity>
constexpr uint64_t iox::cxx::string< Capacity >::size ( ) const
constexprnoexcept

returns the number of characters stored in the string

Returns
the number of characters stored in the string

◆ substr() [1/2]

template<uint64_t Capacity>
iox::cxx::optional< string< Capacity > > iox::cxx::string< Capacity >::substr ( const uint64_t  pos,
const uint64_t  count 
) const
noexcept

creates a substring containing the characters from pos until count; if pos+count is greater than the size of the original string the returned substring only contains the characters from pos until size(); iox::cxx::nullopt is returned if pos is greater than the size of the original string;

Parameters
[in]posis the position of the first character used for the substring
[in]countis the requested length of the substring
Returns
an optional containing the substring, iox::cxx::nullopt if pos is greater than the size of the original string

◆ substr() [2/2]

template<uint64_t Capacity>
iox::cxx::optional< string< Capacity > > iox::cxx::string< Capacity >::substr ( const uint64_t  pos = 0U) const
noexcept

creates a substring containing the characters from pos until size(); iox::cxx::nullopt is returned if pos is greater than the size of the original string

Parameters
[in]posis the position of the first character used for the substring
Returns
an optional containing the substring, iox::cxx::nullopt if pos is greater than the size of the original string

◆ unsafe_append()

template<uint64_t Capacity>
template<typename T >
std::enable_if< internal::IsCharArray< T >::value||internal::IsCxxString< T >::value, bool >::type iox::cxx::string< Capacity >::unsafe_append ( const T &  t)
noexcept

appends a fixed string or string literal to the end of this. The appending fails if the sum of both sizes is greater than this' capacity.

Parameters
[in]fixedstring/string literal to append
Returns
true if the appending succeeds, otherwise false

◆ unsafe_assign() [1/2]

template<uint64_t Capacity>
bool iox::cxx::string< Capacity >::unsafe_assign ( const char *const  str)
noexcept

assigns a cstring to string. The assignment fails if the cstring size is greater than the string capacity.

Parameters
[in]stris the cstring to assign
Returns
true if the assignment succeeds, otherwise false

◆ unsafe_assign() [2/2]

template<uint64_t Capacity>
bool iox::cxx::string< Capacity >::unsafe_assign ( const std::string< Capacity > &  str)
noexcept

assigns a std::string to string. The assignment fails if the std::string size is greater than the string capacity.

Parameters
[in]stris the std::string to assign
Returns
true if the assignment succeeds, otherwise false

Friends And Related Symbol Documentation

◆ concatenate

template<uint64_t Capacity>
template<typename T1 , typename T2 >
std::enable_if<(internal::IsCharArray< T1 >::value||internal::IsCxxString< T1 >::value)&&(internal::IsCharArray< T2 >::value||internal::IsCxxString< T2 >::value), string< internal::GetCapa< T1 >::capa+internal::GetCapa< T2 >::capa > >::type concatenate ( const T1 &  t1,
const T2 &  t2 
)
friend

concatenates two fixed strings/string literals

Parameters
[in]fixedstrings/string literals to concatenate
Returns
a new fixed string with capacity equal to the sum of the capacities of the concatenated strings
string<5> fuu("cdefg");
auto bar = iox::cxx::concatenate(fuu, "ahc");

The documentation for this class was generated from the following files: