ascstring.h

Go to the documentation of this file.

#ifndef ascstringH
#define ascstringH

#include "ASCStringHelpers.h"
#include <stdexcept>      // for range_error
#include <stdarg.h>

using std::range_error;


class ASCString : public ASCCharTString
{

public:

    typedef ASCStringHelpers::charT     charT;

#ifndef _UNICODE_BROKEN_

    typedef ASCStringHelpers::NoncharT        NoncharT;

#endif // _UNICODE_BROKEN_

    // Constructors
    ASCString ( );
    ASCString ( const charT* pS );
    ASCString ( const charT* pS, size_type n );
    ASCString ( size_type n, charT c );
    ASCString ( const_iterator first, const_iterator last );

    // Constructors for ASCCharTString type
    ASCString ( const ASCCharTString& s );
    ASCString ( const ASCCharTString& s, size_type pos, size_type n );

#ifndef _UNICODE_BROKEN_

    // Constructors for ASCAdaptatorString type
    explicit ASCString ( const ASCAdaptatorString& s );
    explicit ASCString ( const ASCAdaptatorString& s, size_type pos, size_type n );

    // Copy Operators for ASCAdaptatorString type
    ASCString& operator=( const ASCAdaptatorString& s );

#endif // _UNICODE_BROKEN_

    // Copy Operators for ASCCharTString type
    ASCString& operator= ( const ASCCharTString& s );

    // Copy Operators for charT*  type
    ASCString& operator= ( const charT* pS );

    // Case-insensitive comparisons
    int compare_ci ( const ASCCharTString& s ) const;
    int compare_ci ( size_type p0, size_type n0, const ASCCharTString& s );
    int compare_ci ( size_type p0, size_type n0, const ASCCharTString& s, size_type pos, size_type n );
    int compare_ci ( const charT* pS ) const;
    int compare_ci ( size_type p0, size_type n0, const charT* pS, size_type pos ) const;

    static ASCString toString( int i );
    
   #ifdef SIZE_T_not_identical_to_INT
    static ASCString toString( size_t i );
   #endif 
    
    // static ASCString toString(int i, int radix );
    static ASCString toString( double d );

    ASCString& replaceAll( const ASCString& old, const ASCString& newString);

    ASCString& replaceAll_ci( const ASCString& old, const ASCString& newString);
    
    // Case-manipulation helpers
    ASCString&  toLower    ();
    ASCString&  toUpper    ();

    // Printing and formating helpers.
    ASCString&  format     ( const charT* pFormat, ... );
    ASCString&  vaformat     ( const charT* pFormat, va_list ap );
    void        printf     ();
    
    // convenience functions
    bool endswith( const ASCString& s ) const;
};

// CONSTRUCTORS
inline ASCString::ASCString ( )
: ASCCharTString ( )
{
}

inline ASCString::ASCString ( const charT* pS )
: ASCCharTString ( pS )
{
}

inline ASCString::ASCString ( const charT* pS, size_type n )
: ASCCharTString ( pS, n )
{
}

inline ASCString::ASCString ( size_type n, charT c )
: ASCCharTString ( n, c )
{
}

inline ASCString::ASCString ( const_iterator first, const_iterator last )
: ASCCharTString ( first, last )
{
}

// Constructors for ASCCharTString type
inline ASCString::ASCString ( const ASCCharTString& s )
: ASCCharTString ( s )
{
}

inline ASCString::ASCString ( const ASCCharTString& s, size_type pos, size_type n )
: ASCCharTString ( s, pos, n )
{
}


#ifndef _UNICODE_BROKEN_

// Constructors for ASCAdaptatorString type

inline ASCString::ASCString ( const ASCAdaptatorString& s )
: ASCCharTString ()
{
    // auto_ptr will release memory if an exception is raised
    auto_ptr< charT > pE ( new charT [ s.length () + sizeof ( charT ) ] );

    size_t stNumCharConverted = ASCStringHelpers::_ConvertToCharT ( pE.get (), s.c_str(), s.length() );
    if ( stNumCharConverted != s.length() )
    {
        throw range_error ( "ASCString::ASCString( const ASCAdaptatorString& s ) ==> unable to convert all characters from ASCAdaptatorString to ASCCharTString type." );
    }

    assign ( pE.get(), stNumCharConverted );
}

inline ASCString::ASCString ( const ASCAdaptatorString& s, size_type pos, size_type n )
: ASCCharTString ()
{
    size_t stLen = n - pos;

    // auto_ptr will release memory if an exception is raised
    auto_ptr< charT > pE ( new charT [ stLen + sizeof ( charT ) ] );

    const NoncharT* pCE = s.c_str ();
    size_t stNumCharConverted = ASCStringHelpers::_ConvertToCharT ( pE.get (), &pCE[ pos ], stLen );
    if ( stNumCharConverted != stLen )
    {
        throw range_error ( "ASCString::ASCString( const ASCAdaptatorString& s, size_type pos, size_type n ) ==> unable to convert all characters from ASCAdaptatorString to ASCCharTString type." );
    }

    assign ( pE.get(), stLen );
}

// Copy Operators for ASCAdaptatorString type

inline ASCString& ASCString::operator= ( const ASCAdaptatorString& s )
{
    ASCString str ( s );
    assign ( str );
    return *this;
}

#endif // _UNICODE_BROKEN_


// Copy Operators

inline ASCString& ASCString::operator= ( const ASCCharTString& s )
{
    assign ( s );
    return *this;
}


inline ASCString& ASCString::operator= ( const charT* pS )
{
    ASCString str ( pS );
    assign ( str );
    return *this;
}

// COMPARE_CI

inline int ASCString::compare_ci ( const ASCCharTString& s ) const
{
    return ASCStringHelpers::_Stricmp ( c_str (), s.c_str () );
}

inline int ASCString::compare_ci ( size_type p0, size_type n0, const ASCCharTString& s )
{
    ASCString l_TempString ( *this, p0, n0 );
    return ASCStringHelpers::_Stricmp ( l_TempString.c_str () , s.c_str () );
}

inline int ASCString::compare_ci ( size_type p0, size_type n0,const ASCCharTString& s, size_type pos, size_type n )
{
    ASCString l_TempStr1 ( *this, p0, n0 );
    ASCString l_TempStr2 ( s, pos, n );
    return ASCStringHelpers::_Stricmp ( l_TempStr1.c_str (), l_TempStr2.c_str () );
}

inline int ASCString::compare_ci ( const charT* pS ) const
{
    return ASCStringHelpers::_Stricmp ( c_str (), pS );
}

inline int ASCString::compare_ci ( size_type p0, size_type n0, const charT* pS, size_type pos ) const
{
    ASCString l_TempStr1 ( *this, p0, n0 );
    ASCString l_TempStr2 ( pS, pos  );
    return ASCStringHelpers::_Stricmp ( l_TempStr1.c_str (), l_TempStr2.c_str () );
}

// GLOBALS
ASCString copytoLower ( const ASCString& s );
ASCString copytoUpper ( const ASCString& s );

// extern const ASCString operator+ ( const ASCString& s1, const ASCString& s2 );
extern const ASCString operator+ ( const char* s1, const ASCString& s2 );

#endif // _ASC_STRING_H_INCLUDED_

---