Str.h

Go to the documentation of this file.

#if !defined(__STR_H__)
#define __STR_H__

#include <string.h>

class Str
{
public:

    static const size_t NO_POS;
    static const size_t MAX_LEN;
    static const Str EMPTY_STR;
    static char NoChars_[1];

    Str( const char* str = NULL, size_t length = NO_POS );

    Str( const Str& str, const size_t offset = 0, size_t count = NO_POS );

    Str( const bool var );

    Str( const double var, unsigned int precision = 6 )
        : length_( 0 ),
          chars_( NoChars_ )
    {
        intoString( var, precision );
    }

    Str( const int var, unsigned int radix = 10, unsigned int radixOffset = 0 )
        : length_( 0 ),
          chars_( NoChars_ )
    {
        intoString( var, radix, radixOffset );
    }

    Str( const size_t var, unsigned int radix = 16 )
        : length_( 0 ),
          chars_( NoChars_ )
    {
        intoString( ( int )var, radix, 0 );
    }

    virtual ~Str();

    // operator overloading helper
    friend Str operator +( const char* var, const Str& str );
    friend Str operator +( const Str& var, const Str& str );

    // set the value
    Str& set( const char* str = NULL, size_t length = NO_POS );

    // operator overloading
    Str& operator =( const char* str );
    Str& operator =( const Str& str );
    Str& operator =( const double var )
    {
        intoString( var );
        return *this;
    }
    Str substr( const size_t offset, size_t count = NO_POS ) const;
    char operator[]( const size_t index ) const;

    Str& operator +=( const bool str )
    {
        return * this += ( Str ) str;
    }
    Str& operator +=( const unsigned char str )
    {
        return * this += Str( ( const char* ) & str, ( size_t )1 );
    }
    Str& operator +=( const double str )
    {
        return * this += ( Str ) str;
    }
    Str& operator +=( const int str )
    {
        return * this += ( Str ) str;
    }
    Str& operator +=( const size_t str )
    {
        return * this += ( Str ) str;
    }
    Str& operator +=( const char* str )
    {
        return * this += ( Str ) str;
    }
    Str& operator +=( const Str& str );
    Str& append( const Str& str )
    {
        return * this += ( Str ) str;
    }
    Str& append( const char* str, size_t length )
    {
        return * this += Str( str, length );
    }
    Str& pushBack( const unsigned char str )
    {
        return * this += str;
    }

    Str& operator << ( const bool str )
    {
        return * this += str;
    }
    Str& operator << ( const unsigned char str )
    {
        return * this += str;
    }
    Str& operator << ( const double str )
    {
        return * this += str;
    }
    Str& operator << ( const int str )
    {
        return * this += str;
    }
    Str& operator << ( const size_t str )
    {
        return * this += str;
    }
    Str& operator << ( const char* str )
    {
        return * this += str;
    }
    Str& operator << ( const Str& str )
    {
        return * this += str;
    }


    // add more logic comparison operators as following, for example, although not efficient
    bool operator !=( const Str& str ) const
    {
        return compare( str ) != 0;
    }

    bool operator !=( const char* str ) const
    {
        return compare( str ) != 0;
    }

    int compare( const Str& str ) const;
    int compare( const char* str ) const;

    bool operator ==( const Str& str ) const
    {
        return compare( str ) == 0;
    }

    bool operator ==( const char* str ) const
    {
        return compare( str ) == 0;
    }

    bool operator<( const Str& str ) const
    {
        return compare( str ) < 0;
    }

    // c type string conversion
    //operator char*()
    //{
    //    return chars_;
    //}
    //operator const char*() const
    //{
    //    return chars_;
    //}
    const char* cStr() const
    {
        return chars_;
    }
    const char* data() const
    {
        return chars_;
    }
    size_t length() const
    {
        return length_;
    }
    size_t size() const
    {
        return length_;
    }

    size_t findLastOf( const unsigned char str ) const;

    size_t findLastOf( const char* str ) const;

    size_t find( const unsigned char str, size_t offset = 0 ) const;

    size_t find( const char* str, size_t offset = 0 ) const;

    size_t find( const Str& str, size_t offset = 0 ) const;

    static size_t FindLastOf( const char* str, const unsigned char theChar, size_t length = NO_POS );

    static size_t Find( const char* str, const unsigned char theChar, size_t length = NO_POS );

    bool startsWith( const char* str, size_t length = NO_POS ) const;

    bool startsWith( const Str& str ) const
    {
        return startsWith( str.cStr(), str.length() );
    }

    bool endsWith( const Str& str ) const
    {
        return length_ >= str.length_ && find( str ) == length_ - str.length_;
    }

    bool setChar( size_t index, const unsigned char theChar );

    void replaceChar( const char replace, const char replaceWith );

    Str* split( int& num, const char* splitSpec, size_t length = NO_POS ) const;

    Str* split( int& num, const Str str ) const
    {
        return split( num, str.chars_, str.length_ );
    }

    Str asHex() const;

    static unsigned int IntToAscii( int value, char* str, unsigned int base, unsigned int bufSize, unsigned int baseOffset = 0 );

protected:

    // have any good conversion method ?
    virtual void intoString( const double var, unsigned int precision = 10 );
    virtual void intoString( int var, unsigned int radix, unsigned int radixOffset = 0 );

    // data block
    size_t length_;
    char* chars_;

};

#endif