CascadeString.h

Go to the documentation of this file.

//
// CascadeString.h - header file for class CascadeString
//
// Copyright (c) 2002, Roku, LLC.  All rights reserved.
//

#ifndef _ROKU_INCLUDE_CASCADE_UTIL_CASCADESTRING_H
#define _ROKU_INCLUDE_CASCADE_UTIL_CASCADESTRING_H

#include <cascade/CascadeObject.h>

class CascadeString : public CascadeObject
{
public:
        CascadeString();
    CascadeString(const CascadeString & string);
    CascadeString(const char * pString);
    virtual ~CascadeString();
public:
    static bool SetSystemLanguage (const char * pLanguage);
    static bool GetSystemLanguage (char * pLanguageToSet, u32 nBuffLen);
    typedef bool (* LanguageEnumProc)(const CascadeString & lang, const CascadeString & friendlyLang, void * pClientData);
    static bool EnumerateStringResourceLanguages(class CascadeStream & stream, LanguageEnumProc callback, void * pClientData);
    static bool LoadStringResources(class CascadeStream & stream, const char * pLang = NULL, bool bClearFirst = true);
    static void ClearStringResources();
    static bool AddStringResource(const CascadeString & resourceID, const CascadeString & string);
    static bool RemoveStringResource(const CascadeString & resourceID);
    bool LoadString(const char * pResourceID);
public:
    inline u32 GetLength() const { return m_nLength; }
    inline u32 GetTerminatedLength() const { return m_nLength + 1; }
    u32 CountChars() const;
    CascadeUnicodeChar ReadOneUnicodeChar( u32 &ioToken ) const;
    CascadeUnicodeChar ReadNthUnicodeChar( u32 inIdx ) const;
    void AppendUnicodeChar( CascadeUnicodeChar inCh );
    static CascadeUnicodeChar UnicodeCharToUpper( CascadeUnicodeChar inChar );
    static CascadeUnicodeChar UnicodeCharToLower( CascadeUnicodeChar inChar );
    static CascadeUnicodeChar UnicodeCharStripDiacritical( CascadeUnicodeChar inChar );
    static bool UnicodeCharIsAlpha( CascadeUnicodeChar inChar );
    static bool UnicodeCharIsDigit( CascadeUnicodeChar inChar );
    inline bool IsEmpty() const { return (0 == m_nLength); }
        void Empty();
        bool TrimAllocation();
    void Truncate(u32 nNewLength);
    u32 TruncateToByteLen(u32 nNewByteLength, bool bBreakOnChar = true);
    
    inline bool IsEqual(const char * pString, bool bCaseSensitive = true) const { return (0 == Compare(pString, bCaseSensitive)); }
    s32 Compare( const char * pString, 
                 bool bCaseSensitive = true,
                 bool bIgnoreDiacritical = false,
                 u32 nLen = 0xFFFFFFFF ) const;
    s32 CompareNBytes(const char * pString, 
                      u32 nBytes) const;
    
    bool Contains(const char * pString, 
                  bool bCaseSensitive = true,
                  bool bIgnoreDiacriticals = false) const;
    bool ContainsBytes( const char * pString ) const;
    void ToLower( bool bStripDiacriticals = false );
    void ToUpper( bool bStripDiacriticals = false );
    void StripDiacriticals();
    inline operator const char * () const { return ((NULL == m_pString) ? "" : m_pString); }
    const CascadeString & operator = (const char * pString);
    inline const CascadeString & operator = (const CascadeString & string) { return operator = (((const char *)string)); }
    const CascadeString & operator += (const char * pString);
    const CascadeString & operator += (char ch);
    inline char operator [] (u32 nIndex) { return ((nIndex < m_nLength) ? (*(m_pString + nIndex)) : 0); }
private:
    operator const void * () const;
        // This private const void * casting operator (which is unimplemented)
        // exists to prevent the compiler from allowing this:
        // CascadeString string; delete string;
        // which it would otherwise allow due to the const char * casting operator.
private:
    // Length of the string (excluding the NULL, like strlen)
    u32 m_nLength;
    // Size of the internal buffer, in bytes (used when appending, to
    // see if we need to allocate more memory).
    u32 m_nBuffSize;
    // The string data
    char * m_pString;
};


//  global operators dealing with class CascadeString
//  NOTE: These operators are provided to remove ambiguity with the const char *
//        casting operator which can lead to nasty results if the compiler auto-casts
//        your CascadeString to a const char *

CascadeString operator + (const CascadeString & string1, const CascadeString & string2);

CascadeString operator + (const CascadeString & string, const char * pString);
CascadeString operator + (const char * pString, const CascadeString & string);

inline bool
operator == (const CascadeString & string1, const CascadeString & string2)
{
    return (0 == string1.Compare(string2));
}

inline bool
operator == (const CascadeString & string, const char * pString)
{
    return (0 == string.Compare(pString));
}

inline bool
operator == (const char * pString, const CascadeString & string)
{
    return (0 == string.Compare(pString));
}

inline bool
operator != (const CascadeString & string1, const CascadeString & string2)
{
    return (0 != string1.Compare(string2));
}

inline bool
operator != (const CascadeString & string, const char * pString)
{
    return (0 != string.Compare(pString));
}

inline bool
operator != (const char * pString, const CascadeString & string)
{
    return (0 != string.Compare(pString));
}

inline bool
operator < (const CascadeString & string1, const CascadeString & string2)
{
    return (string1.Compare(string2) < 0);
}

inline bool
operator < (const CascadeString & string, const char * pString)
{
    return (string.Compare(pString) < 0);
}

inline bool
operator < (const char * pString, const CascadeString & string)
{
    return (string.Compare(pString) > 0); // note intended reversed direction
}

inline bool
operator > (const CascadeString & string1, const CascadeString & string2)
{
    return (string1.Compare(string2) > 0);
}

inline bool
operator > (const CascadeString & string, const char * pString)
{
    return (string.Compare(pString) > 0);
}

inline bool
operator > (const char * pString, const CascadeString & string)
{
    return (string.Compare(pString) < 0); // note intended reversed direction
}

inline bool
operator <= (const CascadeString & string1, const CascadeString & string2)
{
    return (string1.Compare(string2) <= 0);
}

inline bool
operator <= (const CascadeString & string, const char * pString)
{
    return (string.Compare(pString) <= 0);
}

inline bool
operator <= (const char * pString, const CascadeString & string)
{
    return (string.Compare(pString) >= 0); // note intended reversed direction
}

inline bool
operator >= (const CascadeString & string1, const CascadeString & string2)
{
    return (string1.Compare(string2) >= 0);
}

inline bool
operator >= (const CascadeString & string, const char * pString)
{
    return (string.Compare(pString) >= 0);
}

inline bool
operator >= (const char * pString, const CascadeString & string)
{
    return (string.Compare(pString) <= 0); // note intended reversed direction
}

#endif // #ifndef _ROKU_INCLUDE_CASCADE_UTIL_CASCADESTRING_H

// LOG
//  20-Dec-02   dwoodward   created
//  20-Jan-03   dwoodward       1.0 STATUS: 10% complete - GO MIKE!
//  26-Jan-03   dwoodward   added GetLength() and const char * casting operator
//  04-Feb-03   mjkobb      Added GetTerminatedLength(), Append(), Truncate(),
//                          Copy(), char* copy constructor, = operator, and 
//                          populated existing stubbed functions.  I will add
//                          more functions as I find that I need them.  Please
//                          ask if you want specific functionality.
//                          1.0 STATUS: 60% complete.
//  28-Apr-03   pellis      added operator== and IsEquals()
//      28-May-03       pellis          added < <= > >=
//  08-Jun-03   mjkobb      Doxygen
//  25-Jun-03   dwoodward   added != operators
//  20-Aug-03   dwoodward   revamped operators - made all comparison operators global
//                          to avoid ambiguity with const char * casting operator
//      19-Feb-04       dwoodward       added += operator for characters
//      22-Feb-04       dwoodward       added string resource functions
//  25-Feb-04   dwoodward   added AddStringResource() and RemoveStringResource()
//  30-Mar-04   dwuertele   added CountChars(), SetSystemLanguage() and GetSystemLanguage()
//  28-Sep-04   mjkobb      Added Contains, ToUpper, ToLower
//  07-Oct-04   mjkobb      Added CompareFirstN
//  10-Dec-04   dsletten    added EnumerateStringResourceLanguages()
//  16-Mar-05   mjkobb      Added Unicode-aware Compare function, added Unicode
//                          character utilities, added CompareNBytes, removed
//                          CompareFirstN
//  23-Mar-05   mjkobb      More UTF-8 savvy functions
//  04-Apr-05   mjkobb      Clarify a comment
//  13-May-05   dwoodward   don't include CascadeStream.h

---