std::fixed_substring< E, N > Template-Klassenreferenz

#include <fixed_substring.hpp>

Klassendiagramm für std::fixed_substring< E, N >:

Zusammengehörigkeiten von std::fixed_substring< E, N >:

Öffentliche Typen
using	value_type = E
using	size_type = size_t

Öffentliche Methoden
	fixed_substring ()
	fixed_substring (const value_type *str)
template<size_t M>
	fixed_substring (const fixed_substring< E, M > &rhs)
template<size_t M>
fixed_substring &	operator= (const fixed_substring< E, M > &rhs)
fixed_substring &	operator= (const value_type *str)
const char *	c_str () const
void	assign (const value_type *str)
void	assign (const fixed_substring &rhs)
void	append (const value_type *str)
void	append (const fixed_substring &rhs)
size_type	find_index_of (value_type ch) const
size_type	find_index_of_last (value_type ch) const
void	trim_end (size_type index)
bool	empty () const
size_type	length () const
bool	operator== (const fixed_substring &rhs) const
bool	operator!= (const fixed_substring &rhs) const

Private Methoden
void	assign (const E &value)

Ausführliche Beschreibung

template<typename E, size_t N>
class std::fixed_substring< E, N >

Dokumentation der benutzerdefinierten Datentypen

size_type

template<typename E , size_t N>

using std::fixed_substring< E, N >::size_type = size_t

value_type

template<typename E , size_t N>

using std::fixed_substring< E, N >::value_type = E

Beschreibung der Konstruktoren und Destruktoren

fixed_substring() [1/3]

template<typename E , size_t N>

std::fixed_substring< E, N >::fixed_substring ( )

inline

        {
            data()[0] = value_type(0);
        }

fixed_substring() [2/3]

template<typename E , size_t N>

std::fixed_substring< E, N >::fixed_substring ( const value_type *  str )

inlineexplicit

        {
            assign(str);
        }

fixed_substring() [3/3]

template<typename E , size_t N>

template<size_t M>

std::fixed_substring< E, N >::fixed_substring ( const fixed_substring< E, M > &  rhs )

inline

        {
            assign(rhs.data());
        }

Dokumentation der Elementfunktionen

append() [1/2]

template<typename E , size_t N>

void std::fixed_substring< E, N >::append ( const value_type *  str )

inline

        {
            const size_type strLen = (size_type)std::strlen(str);
            const size_type ourLen = (size_type)std::strlen(data());
            size_type toAppend = strLen;
            if (ourLen + toAppend > N)
                    toAppend = N - ourLen;
            Sys::MemCpy(data() + ourLen, str, toAppend * sizeof(value_type));
            data()[ourLen + toAppend] = value_type(0);
        }

append() [2/2]

template<typename E , size_t N>

void std::fixed_substring< E, N >::append ( const fixed_substring< E, N > &  rhs )

inline

        {
            append(rhs.data());
        }

assign() [1/2]

template<typename E , size_t N>

void std::fixed_substring< E, N >::assign ( const value_type *  str )

inline

        {
            assert(str != data());
            const size_type len = (size_type)std::strlen(str);
            const size_type toCopy = len < N ? len : N;
            Sys::MemCpy(data(), str, toCopy * sizeof(value_type));
            data()[toCopy] = value_type(0);
        }

assign() [2/2]

template<typename E , size_t N>

void std::fixed_substring< E, N >::assign ( const fixed_substring< E, N > &  rhs )

inline

        {
            assign(rhs.data());
        }

c_str()

template<typename E , size_t N>

const char* std::fixed_substring< E, N >::c_str ( ) const

inline

        {
            return data();
        }

empty()

template<typename E , size_t N>

bool std::fixed_substring< E, N >::empty ( ) const

inline

        {
            return length() == 0;
        }

find_index_of()

template<typename E , size_t N>

size_type std::fixed_substring< E, N >::find_index_of ( value_type  ch ) const

inline

        {
            size_type retIndex(-1);
            const E* ptr = data();
            size_type currentIndex(0);
            while (*ptr != value_type(0))
            {
                if (*ptr == ch)
                {
                    retIndex = currentIndex;
                    break;
                }
                ++ptr;
                ++currentIndex;
            }
            return retIndex;
        }

find_index_of_last()

template<typename E , size_t N>

size_type std::fixed_substring< E, N >::find_index_of_last ( value_type  ch ) const

inline

        {
            size_type retIndex(-1);
            const value_type* ptr = data();
            size_type currentIndex(0);
            while (*ptr != value_type(0))
            {
                if (*ptr == ch)
                    retIndex = currentIndex;
                ++ptr;
                ++currentIndex;
            }
            return retIndex;
        }

length()

template<typename E , size_t N>

size_type std::fixed_substring< E, N >::length ( ) const

inline

        {
            return std::strlen(data());
        }

operator!=()

template<typename E , size_t N>

bool std::fixed_substring< E, N >::operator!= ( const fixed_substring< E, N > &  rhs ) const

inline

        {
            return !(*this == rhs);
        }

operator=() [1/2]

template<typename E , size_t N>

template<size_t M>

fixed_substring& std::fixed_substring< E, N >::operator= ( const fixed_substring< E, M > &  rhs )

inline

        {
            assign(rhs.data());
            return *this;
        }

operator=() [2/2]

template<typename E , size_t N>

fixed_substring& std::fixed_substring< E, N >::operator= ( const value_type *  str )

inline

        {
            assign(str);
            return *this;
        }

operator==()

template<typename E , size_t N>

bool std::fixed_substring< E, N >::operator== ( const fixed_substring< E, N > &  rhs ) const

inline

        {
            return std::strcompare(data(), rhs.data()) == 0;
        }

trim_end()

template<typename E , size_t N>

void std::fixed_substring< E, N >::trim_end ( size_type  index )

inline

        {
            if (index >= 0)
            {
                assert(index < (size_type)std::strlen(data()));
                data()[index] = value_type(0);
            }
        }

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/fixed_substring.hpp