lmms-fork/fstring_8h_source.html

//------------------------------------------------------------------------

// Project     : SDK Base

// Version     : 1.0

//

// Category    : Helpers

// Filename    : base/source/fstring.h

// Created by  : Steinberg, 2008

// Description : String class

//

//-----------------------------------------------------------------------------

// LICENSE

// (c) 2021, Steinberg Media Technologies GmbH, All Rights Reserved

//-----------------------------------------------------------------------------

// Redistribution and use in source and binary forms, with or without modification,

// are permitted provided that the following conditions are met:

//

//   * Redistributions of source code must retain the above copyright notice,

//     this list of conditions and the following disclaimer.

//   * Redistributions in binary form must reproduce the above copyright notice,

//     this list of conditions and the following disclaimer in the documentation

//     and/or other materials provided with the distribution.

//   * Neither the name of the Steinberg Media Technologies nor the names of its

//     contributors may be used to endorse or promote products derived from this

//     software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

// IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE

// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  OF THIS SOFTWARE, EVEN IF ADVISED

// OF THE POSSIBILITY OF SUCH DAMAGE.

//-----------------------------------------------------------------------------


#pragma once


#include "pluginterfaces/base/ftypes.h"

#include "pluginterfaces/base/fstrdefs.h"

#include "pluginterfaces/base/istringresult.h"

#include "pluginterfaces/base/ipersistent.h"


#include "base/source/fobject.h"


#include <cstdarg>


namespace Steinberg {


class FVariant;

class String;


#ifdef UNICODE

static const bool kWideStringDefault = true;

#else

static const bool kWideStringDefault = false;

#endif


static const uint16 kBomUtf16 = 0xFEFF;

static const char8* const kBomUtf8 = "\xEF\xBB\xBF";

static const int32 kBomUtf8Length = 3;


enum MBCodePage

{

        kCP_ANSI = 0,

        kCP_MAC_ROMAN = 2,


        kCP_ANSI_WEL = 1252,

        kCP_MAC_CEE = 10029,

        kCP_Utf8 = 65001,

        kCP_ShiftJIS = 932,

        kCP_US_ASCII = 20127,


        kCP_Default = kCP_ANSI

};


enum UnicodeNormalization

{

        kUnicodeNormC,

        kUnicodeNormD,

        kUnicodeNormKC,

        kUnicodeNormKD

};


//------------------------------------------------------------------------

// Helper functions to create hash codes from string data.

//------------------------------------------------------------------------

extern uint32 hashString8 (const char8* s, uint32 m);

extern uint32 hashString16 (const char16* s, uint32 m);


inline uint32 hashString (const tchar* s, uint32 m)

{

#ifdef UNICODE

        return hashString16 (s, m);

#else

        return hashString8 (s, m);

#endif

}


//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------


class ConstString

{

public:

//-----------------------------------------------------------------------------

        ConstString (const char8* str, int32 length = -1);

        ConstString (const char16* str, int32 length = -1);

        ConstString (const ConstString& str, int32 offset = 0, int32 length = -1);

        ConstString (const FVariant& var);

        ConstString ();

        virtual ~ConstString () {}


        // access -----------------------------------------------------------------


        virtual int32 length () const {return static_cast<int32> (len);}


        inline bool isEmpty () const {return buffer == nullptr || len == 0;}


        operator const char8* () const {return text8 ();}


        operator const char16* () const {return text16 ();}


        inline tchar operator[] (short idx) const {return getChar (static_cast<uint32> (idx));}

        inline tchar operator[] (long idx) const {return getChar (static_cast<uint32> (idx));}

        inline tchar operator[] (int idx) const {return getChar (static_cast<uint32> (idx));}

        inline tchar operator[] (unsigned short idx) const {return getChar (idx);}

        inline tchar operator[] (unsigned long idx) const {return getChar (static_cast<uint32> (idx));}

        inline tchar operator[] (unsigned int idx) const {return getChar (idx);}


        inline virtual const char8* text8 () const;

        inline virtual const char16* text16 () const;

        inline virtual const tchar* text () const;

        inline virtual const void* ptr () const {return buffer;}


        inline virtual char8 getChar8 (uint32 index) const;

        inline virtual char16 getChar16 (uint32 index) const;

        inline tchar getChar (uint32 index) const;

        inline tchar getCharAt (uint32 index) const;


        bool testChar8 (uint32 index, char8 c) const;

        bool testChar16 (uint32 index, char16 c) const;

        inline bool testChar (uint32 index, char8 c) const {return testChar8 (index, c);}

        inline bool testChar (uint32 index, char16 c) const {return testChar16 (index, c);}


        bool extract (String& result, uint32 idx, int32 n = -1) const;

        int32 copyTo8 (char8* str, uint32 idx = 0, int32 n = -1) const;

        int32 copyTo16 (char16* str, uint32 idx = 0, int32 n = -1) const;

        int32 copyTo (tchar* str, uint32 idx = 0, int32 n = -1) const;

        void copyTo (IStringResult* result) const;

        void copyTo (IString& string) const;


        inline uint32 hash (uint32 tsize) const

        {

                return isWide ? hashString16 (buffer16, tsize) : hashString8 (buffer8, tsize) ;

        }


        //-------------------------------------------------------------------------


        // compare ----------------------------------------------------------------


        enum CompareMode

        {

                kCaseSensitive,

                kCaseInsensitive

        };


        int32 compareAt (uint32 index, const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const;

        int32 compare (const ConstString& str, int32 n, CompareMode m = kCaseSensitive) const;

        int32 compare (const ConstString& str, CompareMode m = kCaseSensitive) const;


        int32 naturalCompare (const ConstString& str, CompareMode mode = kCaseSensitive) const;


        bool startsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;

        bool endsWith (const ConstString& str, CompareMode m = kCaseSensitive) const;

        bool contains (const ConstString& str, CompareMode m = kCaseSensitive) const;


        // static methods

        static bool isCharSpace (char8 character);

        static bool isCharSpace (char16 character);

        static bool isCharAlpha (char8 character);

        static bool isCharAlpha (char16 character);

        static bool isCharAlphaNum (char8 character);

        static bool isCharAlphaNum (char16 character);

        static bool isCharDigit (char8 character);

        static bool isCharDigit (char16 character);

        static bool isCharAscii (char8 character);

        static bool isCharAscii (char16 character);

        static bool isCharUpper (char8 character);

        static bool isCharUpper (char16 character);

        static bool isCharLower (char8 character);

        static bool isCharLower (char16 character);

        //-------------------------------------------------------------------------


        inline int32 findFirst (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, str, n, m, endIndex);}

        inline int32 findFirst (char8 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}

        inline int32 findFirst (char16 c, CompareMode m = kCaseSensitive, int32 endIndex = -1) const {return findNext (0, c, m, endIndex);}


        int32 findNext (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive, int32 endIndex = -1) const;

        int32 findNext (int32 startIndex, char8 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;

        int32 findNext (int32 startIndex, char16 c, CompareMode = kCaseSensitive, int32 endIndex = -1) const;


        int32 findPrev (int32 startIndex, const ConstString& str, int32 n = -1, CompareMode = kCaseSensitive) const;

        int32 findPrev (int32 startIndex, char8 c, CompareMode = kCaseSensitive) const;

        int32 findPrev (int32 startIndex, char16 c, CompareMode = kCaseSensitive) const;


        inline int32 findLast (const ConstString& str, int32 n = -1, CompareMode m = kCaseSensitive) const {return findPrev (-1, str, n, m);}

        inline int32 findLast (char8 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}

        inline int32 findLast (char16 c, CompareMode m = kCaseSensitive) const {return findPrev (-1, c, m);}


        int32 countOccurences (char8 c, uint32 startIndex, CompareMode = kCaseSensitive) const;

        int32 countOccurences (char16 c, uint32 startIndex, CompareMode = kCaseSensitive) const;

        int32 getFirstDifferent (const ConstString& str, CompareMode = kCaseSensitive) const;

        //-------------------------------------------------------------------------


        // numbers ----------------------------------------------------------------

        bool isDigit (uint32 index) const;

        bool scanFloat (double& value, uint32 offset = 0, bool scanToEnd = true) const;

        bool scanInt64 (int64& value, uint32 offset = 0, bool scanToEnd = true) const;

        bool scanUInt64 (uint64& value, uint32 offset = 0, bool scanToEnd = true) const;

        bool scanInt32 (int32& value, uint32 offset = 0, bool scanToEnd = true) const;

        bool scanUInt32 (uint32& value, uint32 offset = 0, bool scanToEnd = true) const;

        bool scanHex (uint8& value, uint32 offset = 0, bool scanToEnd = true) const;


        int32 getTrailingNumberIndex (uint32 width = 0) const;

        int64 getTrailingNumber (int64 fallback = 0) const;

        int64 getNumber () const;


        // static methods

        static bool scanInt64_8 (const char8* text, int64& value, bool scanToEnd = true);

        static bool scanInt64_16 (const char16* text, int64& value, bool scanToEnd = true);

        static bool scanInt64 (const tchar* text, int64& value, bool scanToEnd = true);


        static bool scanUInt64_8 (const char8* text, uint64& value, bool scanToEnd = true);

        static bool scanUInt64_16 (const char16* text, uint64& value, bool scanToEnd = true);

        static bool scanUInt64 (const tchar* text, uint64& value, bool scanToEnd = true);


        static bool scanInt32_8 (const char8* text, int32& value, bool scanToEnd = true);

        static bool scanInt32_16 (const char16* text, int32& value, bool scanToEnd = true);

        static bool scanInt32 (const tchar* text, int32& value, bool scanToEnd = true);


        static bool scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd = true);

        static bool scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd = true);

        static bool scanUInt32 (const tchar* text, uint32& value, bool scanToEnd = true);


        static bool scanHex_8 (const char8* text, uint8& value, bool scanToEnd = true);

        static bool scanHex_16 (const char16* text, uint8& value, bool scanToEnd = true);

        static bool scanHex (const tchar* text, uint8& value, bool scanToEnd = true);

        //-------------------------------------------------------------------------


        // conversion -------------------------------------------------------------

        void toVariant (FVariant& var) const;


        static char8 toLower (char8 c);

        static char8 toUpper (char8 c);

        static char16 toLower (char16 c);

        static char16 toUpper (char16 c);


        static int32 multiByteToWideString (char16* dest, const char8* source, int32 wcharCount, uint32 sourceCodePage = kCP_Default);

        static int32 wideStringToMultiByte (char8* dest, const char16* source, int32 char8Count, uint32 destCodePage = kCP_Default);


        bool isWideString () const {return isWide != 0;}

        bool isAsciiString () const;


        bool isNormalized (UnicodeNormalization = kUnicodeNormC);


#if SMTG_OS_MACOS

        virtual void* toCFStringRef (uint32 encoding = 0xFFFF, bool mutableCFString = false) const;

#endif

//-------------------------------------------------------------------------


//-----------------------------------------------------------------------------

protected:


        union

        {

                void* buffer;

                char8* buffer8;

                char16* buffer16;

        };

        uint32 len : 30;

        uint32 isWide : 1;

};


//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------


class String : public ConstString

{

public:


//-----------------------------------------------------------------------------

        String ();

        String (const char8* str, MBCodePage codepage, int32 n = -1, bool isTerminated = true);

        String (const char8* str, int32 n = -1, bool isTerminated = true);

        String (const char16* str, int32 n = -1, bool isTerminated = true);

        String (const String& str, int32 n = -1);

        String (const ConstString& str, int32 n = -1);

        String (const FVariant& var);

        String (IString* str);

        ~String ();


#if SMTG_CPP11_STDLIBSUPPORT

        String (String&& str);

        String& operator= (String&& str);

#endif


        // access------------------------------------------------------------------

        void updateLength ();

        const char8* text8 () const SMTG_OVERRIDE;

        const char16* text16 () const SMTG_OVERRIDE;

        char8 getChar8 (uint32 index) const SMTG_OVERRIDE;

        char16 getChar16 (uint32 index) const SMTG_OVERRIDE;


        bool setChar8 (uint32 index, char8 c);

        bool setChar16 (uint32 index, char16 c);

        inline bool setChar (uint32 index, char8 c) {return setChar8 (index, c);}

        inline bool setChar (uint32 index, char16 c) {return setChar16 (index, c);}

        //-------------------------------------------------------------------------


        // assignment--------------------------------------------------------------

        String& operator= (const char8* str) {return assign (str);}

        String& operator= (const char16* str) {return assign (str);}

        String& operator= (const ConstString& str) {return assign (str);}

        String& operator= (const String& str) {return assign (str);}

        String& operator= (char8 c) {return assign (c);}

        String& operator= (char16 c) {return assign (c);}


        String& assign (const ConstString& str, int32 n = -1);

        String& assign (const char8* str, int32 n = -1, bool isTerminated = true);

        String& assign (const char16* str, int32 n = -1, bool isTerminated = true);

        String& assign (char8 c, int32 n = 1);

        String& assign (char16 c, int32 n = 1);

        //-------------------------------------------------------------------------


        // concat------------------------------------------------------------------

        String& append (const ConstString& str, int32 n = -1);

        String& append (const char8* str, int32 n = -1);

        String& append (const char16* str, int32 n = -1);

        String& append (const char8 c, int32 n = 1);

        String& append (const char16 c, int32 n = 1);


        String& insertAt (uint32 idx, const ConstString& str, int32 n = -1);

        String& insertAt (uint32 idx, const char8* str, int32 n = -1);

        String& insertAt (uint32 idx, const char16* str, int32 n = -1);

        String& insertAt (uint32 idx, char8 c) {char8 str[] = {c, 0}; return insertAt (idx, str, 1);}

        String& insertAt (uint32 idx, char16 c) {char16 str[] = {c, 0}; return insertAt (idx, str, 1);}


        String& operator+= (const String& str) {return append (str);}

        String& operator+= (const ConstString& str) {return append (str);}

        String& operator+= (const char8* str) {return append (str);}

        String& operator+= (const char16* str) {return append (str);}

        String& operator+= (const char8 c) {return append (c);}

        String& operator+= (const char16 c) {return append (c);}

        //-------------------------------------------------------------------------


        // replace-----------------------------------------------------------------

        String& replace (uint32 idx, int32 n1, const ConstString& str, int32 n2 = -1);

        String& replace (uint32 idx, int32 n1, const char8* str, int32 n2 = -1);

        String& replace (uint32 idx, int32 n1, const char16* str, int32 n2 = -1);


        int32 replace (const char8* toReplace, const char8* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);

        int32 replace (const char16* toReplace, const char16* toReplaceWith, bool all = false, CompareMode m = kCaseSensitive);


        bool replaceChars8 (const char8* toReplace, char8 toReplaceBy);

        bool replaceChars16 (const char16* toReplace, char16 toReplaceBy);

        inline bool replaceChars8 (char8 toReplace, char8 toReplaceBy)  {char8 str[] = {toReplace, 0}; return replaceChars8 (str, toReplaceBy);}

        inline bool replaceChars16 (char16 toReplace, char16 toReplaceBy)  {char16 str[] = {toReplace, 0}; return replaceChars16 (str, toReplaceBy);}

        inline bool replaceChars (char8 toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}

        inline bool replaceChars (char16 toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}

        inline bool replaceChars (const char8* toReplace, char8 toReplaceBy) {return replaceChars8 (toReplace, toReplaceBy);}

        inline bool replaceChars (const char16* toReplace, char16 toReplaceBy) {return replaceChars16 (toReplace, toReplaceBy);}

        //-------------------------------------------------------------------------


        // remove------------------------------------------------------------------

        String& remove (uint32 index = 0, int32 n = -1);

        enum CharGroup {kSpace, kNotAlphaNum, kNotAlpha};

        bool trim (CharGroup mode = kSpace);

        void removeChars (CharGroup mode = kSpace);

        bool removeChars8 (const char8* which);

        bool removeChars16 (const char16* which);

        inline bool removeChars8 (const char8 which) {char8 str[] = {which, 0}; return removeChars8 (str); }

        inline bool removeChars16 (const char16 which) {char16 str[] = {which, 0}; return removeChars16 (str); }

        inline bool removeChars (const char8* which) {return removeChars8 (which);}

        inline bool removeChars (const char16* which) {return removeChars16 (which);}

        inline bool removeChars (const char8 which) {return removeChars8 (which);}

        inline bool removeChars (const char16 which) {return removeChars16 (which);}

        bool removeSubString (const ConstString& subString, bool allOccurences = true);

        //-------------------------------------------------------------------------


        // print-------------------------------------------------------------------

        String& printf (const char8* format, ...);

        String& printf (const char16* format, ...);

        String& vprintf (const char8* format, va_list args);

        String& vprintf (const char16* format, va_list args);

        //-------------------------------------------------------------------------


        // numbers-----------------------------------------------------------------

        String& printInt64 (int64 value);

        String& printFloat (double value);

        bool incrementTrailingNumber (uint32 width = 2, tchar separator = STR (' '), uint32 minNumber = 1, bool applyOnlyFormat = false);

        //-------------------------------------------------------------------------


        // conversion--------------------------------------------------------------

        bool fromVariant (const FVariant& var);

        void toVariant (FVariant& var) const;

        bool fromAttributes (IAttributes* a, IAttrID attrID);

        bool toAttributes (IAttributes* a, IAttrID attrID);


        void swapContent (String& s);

        void take (String& str);

        void take (void* _buffer, bool wide);

        void* pass ();

        void passToVariant (FVariant& var);


        void toLower (uint32 index);

        void toLower ();

        void toUpper (uint32 index);

        void toUpper ();


        unsigned char* toPascalString (unsigned char* buf);

        const String& fromPascalString (const unsigned char* buf);


        bool toWideString (uint32 sourceCodePage = kCP_Default);

        bool toMultiByte (uint32 destCodePage = kCP_Default);


        void fromUTF8 (const char8* utf8String);

        bool normalize (UnicodeNormalization = kUnicodeNormC);


#if SMTG_OS_MACOS

        virtual bool fromCFStringRef (const void*, uint32 encoding = 0xFFFF);

#endif

        //-------------------------------------------------------------------------


        //-----------------------------------------------------------------------------

protected:

        bool resize (uint32 newSize, bool wide, bool fill = false);


private:

        void tryFreeBuffer ();

        bool checkToMultiByte (uint32 destCodePage = kCP_Default) const; // to remove debug code from inline - const_cast inside!!!

};


// String concatenation functions.

inline String operator+ (const ConstString& s1, const ConstString& s2) {return String (s1).append (s2);}

inline String operator+ (const ConstString& s1, const char8* s2) {return String (s1).append (s2);}

inline String operator+ (const ConstString& s1, const char16* s2) {return String (s1).append (s2);}

inline String operator+ (const char8* s1, const ConstString& s2) {return String (s1).append (s2);}

inline String operator+ (const char16* s1, const ConstString& s2) {return String (s1).append (s2);}

inline String operator+ (const ConstString& s1, const String& s2) {return String (s1).append (s2);}

inline String operator+ (const String& s1, const ConstString& s2) {return String (s1).append (s2);}

inline String operator+ (const String& s1, const String& s2) {return String (s1).append (s2);}

inline String operator+ (const String& s1, const char8* s2) {return String (s1).append (s2);}

inline String operator+ (const String& s1, const char16* s2) {return String (s1).append (s2);}

inline String operator+ (const char8* s1, const String& s2) {return String (s1).append (s2);}

inline String operator+ (const char16* s1, const String& s2) {return String (s1).append (s2);}


//-----------------------------------------------------------------------------

// ConstString

//-----------------------------------------------------------------------------


inline const tchar* ConstString::text () const

{

#ifdef UNICODE

        return text16 ();

#else

        return text8 ();

#endif

}


//-----------------------------------------------------------------------------


inline const char8* ConstString::text8 () const

{

        return (!isWide && buffer8) ? buffer8: kEmptyString8;

}


//-----------------------------------------------------------------------------


inline const char16* ConstString::text16 () const

{

        return (isWide && buffer16) ? buffer16 : kEmptyString16;

}


//-----------------------------------------------------------------------------


inline char8 ConstString::getChar8 (uint32 index) const

{

        if (index < len && buffer8 && !isWide)

                return buffer8[index];

        return 0;

}


//-----------------------------------------------------------------------------


inline char16 ConstString::getChar16 (uint32 index) const

{

        if (index < len && buffer16 && isWide)

                return buffer16[index];

        return 0;

}


//-----------------------------------------------------------------------------


inline tchar ConstString::getChar (uint32 index) const

{

#ifdef UNICODE

        return getChar16 (index);

#else

        return getChar8 (index);

#endif

}


//-----------------------------------------------------------------------------


inline tchar ConstString::getCharAt (uint32 index) const

{

#ifdef UNICODE

        if (isWide)

                return getChar16 (index);

#endif


        return static_cast<tchar> (getChar8 (index));

}


//-----------------------------------------------------------------------------


inline int64 ConstString::getNumber () const

{

        int64 tmp = 0;

        scanInt64 (tmp);

        return tmp;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanInt32_8 (const char8* text, int32& value, bool scanToEnd)

{

        int64 tmp;

        if (scanInt64_8 (text, tmp, scanToEnd))

        {

                value = (int32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanInt32_16 (const char16* text, int32& value, bool scanToEnd)

{

        int64 tmp;

        if (scanInt64_16 (text, tmp, scanToEnd))

        {

                value = (int32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanInt32 (const tchar* text, int32& value, bool scanToEnd)

{

        int64 tmp;

        if (scanInt64 (text, tmp, scanToEnd))

        {

                value = (int32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanUInt32_8 (const char8* text, uint32& value, bool scanToEnd)

{

        uint64 tmp;

        if (scanUInt64_8 (text, tmp, scanToEnd))

        {

                value = (uint32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanUInt32_16 (const char16* text, uint32& value, bool scanToEnd)

{

        uint64 tmp;

        if (scanUInt64_16 (text, tmp, scanToEnd))

        {

                value = (uint32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline bool ConstString::scanUInt32 (const tchar* text, uint32& value, bool scanToEnd)

{

        uint64 tmp;

        if (scanUInt64 (text, tmp, scanToEnd))

        {

                value = (uint32)tmp;

                return true;

        }

        return false;

}


//-----------------------------------------------------------------------------


inline const char8* String::text8 () const

{

        if (isWide && !isEmpty ())

                checkToMultiByte (); // this should be avoided, since it can lead to information loss


        return ConstString::text8 ();

}


//-----------------------------------------------------------------------------


inline const char16* String::text16 () const

{

        if (!isWide && !isEmpty ())

        {

                const_cast<String&> (*this).toWideString ();

        }

        return ConstString::text16 ();

}


//-----------------------------------------------------------------------------


inline char8 String::getChar8 (uint32 index) const

{

        if (isWide && !isEmpty ())

                checkToMultiByte (); // this should be avoided, since it can lead to information loss


        return ConstString::getChar8 (index);

}


//-----------------------------------------------------------------------------


inline char16 String::getChar16 (uint32 index) const

{

        if (!isWide && !isEmpty ())

        {

                const_cast<String&> (*this).toWideString ();

        }

        return ConstString::getChar16 (index);

}


//-----------------------------------------------------------------------------


inline bool operator<  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) < 0) ? true : false;}

inline bool operator<= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) <= 0) ? true : false;}

inline bool operator>  (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) > 0) ? true : false;}

inline bool operator>= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) >= 0) ? true : false;}

inline bool operator== (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) == 0) ? true : false;}

inline bool operator!= (const ConstString& s1, const ConstString& s2) {return (s1.compare (s2) != 0) ? true : false;}


inline bool operator<  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) < 0) ? true : false;}

inline bool operator<= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) <= 0) ? true : false;}

inline bool operator>  (const ConstString& s1, const char8* s2) {return (s1.compare (s2) > 0) ? true : false;}

inline bool operator>= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) >= 0) ? true : false;}

inline bool operator== (const ConstString& s1, const char8* s2) {return (s1.compare (s2) == 0) ? true : false;}

inline bool operator!= (const ConstString& s1, const char8* s2) {return (s1.compare (s2) != 0) ? true : false;}

inline bool operator<  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}

inline bool operator<= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}

inline bool operator>  (const char8* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}

inline bool operator>= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}

inline bool operator== (const char8* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}

inline bool operator!= (const char8* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}


inline bool operator<  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) < 0) ? true : false;}

inline bool operator<= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) <= 0) ? true : false;}

inline bool operator>  (const ConstString& s1, const char16* s2) {return (s1.compare (s2) > 0) ? true : false;}

inline bool operator>= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) >= 0) ? true : false;}

inline bool operator== (const ConstString& s1, const char16* s2) {return (s1.compare (s2) == 0) ? true : false;}

inline bool operator!= (const ConstString& s1, const char16* s2) {return (s1.compare (s2) != 0) ? true : false;}

inline bool operator<  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) > 0) ? true : false;}

inline bool operator<= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) >= 0) ? true : false;}

inline bool operator>  (const char16* s1, const ConstString& s2) {return (s2.compare (s1) < 0) ? true : false;}

inline bool operator>= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) <= 0) ? true : false;}

inline bool operator== (const char16* s1, const ConstString& s2) {return (s2.compare (s1) == 0) ? true : false;}

inline bool operator!= (const char16* s1, const ConstString& s2) {return (s2.compare (s1) != 0) ? true : false;}


// The following functions will only work with European Numbers!

// (e.g. Arabic, Tibetan, and Khmer digits are not supported)

extern int32 strnatcmp8 (const char8* s1, const char8* s2, bool caseSensitive = true);

extern int32 strnatcmp16 (const char16* s1, const char16* s2, bool caseSensitive = true);


inline int32 strnatcmp (const tchar* s1, const tchar* s2, bool caseSensitive = true)

{

#ifdef UNICODE

        return strnatcmp16 (s1, s2, caseSensitive);

#else

        return strnatcmp8 (s1, s2, caseSensitive);

#endif

}


//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------


class StringObject : public FObject, public String, public IStringResult, public IString

{

public:

//-----------------------------------------------------------------------------

        StringObject () {}

        StringObject (const char16* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}

        StringObject (const char8* str, int32 n = -1, bool isTerminated = true) : String (str, n, isTerminated) {}

        StringObject (const StringObject& str, int32 n = -1) : String (str, n) {}

        StringObject (const String& str, int32 n = -1) : String (str, n) {}

        StringObject (const FVariant& var) : String (var) {}


        using String::operator=;


        // IStringResult ----------------------------------------------------------

        void PLUGIN_API setText (const char8* text) SMTG_OVERRIDE;

        //-------------------------------------------------------------------------


        // IString-----------------------------------------------------------------

        void PLUGIN_API setText8 (const char8* text) SMTG_OVERRIDE;

        void PLUGIN_API setText16 (const char16* text) SMTG_OVERRIDE;


        const char8* PLUGIN_API getText8 () SMTG_OVERRIDE;

        const char16* PLUGIN_API getText16 () SMTG_OVERRIDE;


        void PLUGIN_API take (void* s, bool _isWide) SMTG_OVERRIDE;

        bool PLUGIN_API isWideString () const SMTG_OVERRIDE;

        //-------------------------------------------------------------------------


        OBJ_METHODS (StringObject, FObject)

        FUNKNOWN_METHODS2 (IStringResult, IString, FObject)

};


//------------------------------------------------------------------------

} // namespace Steinberg


a
uint8_t a
Definition Spc_Cpu.h:141

int32
int32_t int32
Definition basics.h:89

uint32
uint32_t uint32
Definition basics.h:90

Steinberg::ConstString
Definition fstring.h:117

Steinberg::ConstString::isCharLower
static bool isCharLower(char8 character)
Definition fstring.cpp:1743

Steinberg::ConstString::text8
virtual const char8 * text8() const
Returns pointer to string of type char8.
Definition fstring.h:492

Steinberg::ConstString::getFirstDifferent
int32 getFirstDifferent(const ConstString &str, CompareMode=kCaseSensitive) const
Returns position of first different character.
Definition fstring.cpp:1297

Steinberg::ConstString::getTrailingNumber
int64 getTrailingNumber(int64 fallback=0) const
Returns result of scanInt64 or the fallback.
Definition fstring.cpp:1790

Steinberg::ConstString::testChar16
bool testChar16(uint32 index, char16 c) const
Definition fstring.cpp:517

Steinberg::ConstString::isAsciiString
bool isAsciiString() const
Checks if all characters in string are in ascii range.
Definition fstring.cpp:1819

Steinberg::ConstString::text
virtual const tchar * text() const
Returns pointer to string of type tchar.
Definition fstring.h:482

Steinberg::ConstString::getChar8
virtual char8 getChar8(uint32 index) const
Returns character of type char16 at 'index'.
Definition fstring.h:504

Steinberg::ConstString::scanUInt32_16
static bool scanUInt32_16(const char16 *text, uint32 &value, bool scanToEnd=true)
Converts string of type char16 to int32 value.
Definition fstring.h:597

Steinberg::ConstString::findFirst
int32 findFirst(char8 c, CompareMode m=kCaseSensitive, int32 endIndex=-1) const
Definition fstring.h:205

Steinberg::ConstString::scanInt32_8
static bool scanInt32_8(const char8 *text, int32 &value, bool scanToEnd=true)
Converts string of type char8 to int32 value.
Definition fstring.h:549

Steinberg::ConstString::isCharSpace
static bool isCharSpace(char8 character)
Returns true if character is a space.
Definition fstring.cpp:1652

Steinberg::ConstString::scanUInt64_16
static bool scanUInt64_16(const char16 *text, uint64 &value, bool scanToEnd=true)
Converts string of type char16 to uint64 value.
Definition fstring.cpp:1463

Steinberg::ConstString::wideStringToMultiByte
static int32 wideStringToMultiByte(char8 *dest, const char16 *source, int32 char8Count, uint32 destCodePage=kCP_Default)
If dest is zero, this returns the maximum number of bytes needed to convert source.
Definition fstring.cpp:1924

Steinberg::ConstString::CompareMode
CompareMode
Definition fstring.h:170

Steinberg::ConstString::kCaseSensitive
@ kCaseSensitive
Comparison is done with regard to character's case.
Definition fstring.h:171

Steinberg::ConstString::kCaseInsensitive
@ kCaseInsensitive
Comparison is done without regard to character's case.
Definition fstring.h:172

Steinberg::ConstString::findLast
int32 findLast(const ConstString &str, int32 n=-1, CompareMode m=kCaseSensitive) const
Find last occurrence of n characters of str in this (n=-1: all).
Definition fstring.h:221

Steinberg::ConstString::getCharAt
tchar getCharAt(uint32 index) const
Returns character of type tchar at 'index', no conversion!
Definition fstring.h:530

Steinberg::ConstString::endsWith
bool endsWith(const ConstString &str, CompareMode m=kCaseSensitive) const
Check if this ends with str.
Definition fstring.cpp:883

Steinberg::ConstString::naturalCompare
int32 naturalCompare(const ConstString &str, CompareMode mode=kCaseSensitive) const
Definition fstring.cpp:801

Steinberg::ConstString::isDigit
bool isDigit(uint32 index) const
Returns true if character at position is a digit.
Definition fstring.cpp:1755

Steinberg::ConstString::len
uint32 len
Definition fstring.h:295

Steinberg::ConstString::scanHex_16
static bool scanHex_16(const char16 *text, uint8 &value, bool scanToEnd=true)
Converts string of type char16 to hex/unit8 value.
Definition fstring.cpp:1513

Steinberg::ConstString::hash
uint32 hash(uint32 tsize) const
Definition fstring.h:162

Steinberg::ConstString::findFirst
int32 findFirst(char16 c, CompareMode m=kCaseSensitive, int32 endIndex=-1) const
Definition fstring.h:206

Steinberg::ConstString::operator[]
tchar operator[](short idx) const
Returns character at 'idx'.
Definition fstring.h:133

Steinberg::ConstString::testChar8
bool testChar8(uint32 index, char8 c) const
Returns true if character is equal at position 'index'.
Definition fstring.cpp:500

Steinberg::ConstString::scanInt32
bool scanInt32(int32 &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to int32 value starting at offset.
Definition fstring.cpp:1399

Steinberg::ConstString::scanHex_8
static bool scanHex_8(const char8 *text, uint8 &value, bool scanToEnd=true)
Converts string of type char8 to hex/unit8 value.
Definition fstring.cpp:1495

Steinberg::ConstString::testChar
bool testChar(uint32 index, char16 c) const
Definition fstring.h:153

Steinberg::ConstString::scanHex
bool scanHex(uint8 &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to hex/uint8 value starting at offset.
Definition fstring.cpp:1387

Steinberg::ConstString::isCharUpper
static bool isCharUpper(char8 character)
Definition fstring.cpp:1731

Steinberg::ConstString::scanUInt32
bool scanUInt32(uint32 &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to uint32 value starting at offset.
Definition fstring.cpp:1411

Steinberg::ConstString::extract
bool extract(String &result, uint32 idx, int32 n=-1) const
Get n characters long substring starting at index (n=-1: until end).
Definition fstring.cpp:534

Steinberg::ConstString::toLower
static char8 toLower(char8 c)
Converts to lower case.
Definition fstring.cpp:1624

Steinberg::ConstString::isCharAlphaNum
static bool isCharAlphaNum(char8 character)
Returns true if character is an alphanumeric character.
Definition fstring.cpp:1695

Steinberg::ConstString::copyTo8
int32 copyTo8(char8 *str, uint32 idx=0, int32 n=-1) const
Definition fstring.cpp:551

Steinberg::ConstString::countOccurences
int32 countOccurences(char8 c, uint32 startIndex, CompareMode=kCaseSensitive) const
Counts occurences of c within this starting at index.
Definition fstring.cpp:1241

Steinberg::ConstString::isWideString
bool isWideString() const
Returns true if string is wide.
Definition fstring.h:276

Steinberg::ConstString::startsWith
bool startsWith(const ConstString &str, CompareMode m=kCaseSensitive) const
Check if this starts with str.
Definition fstring.cpp:834

Steinberg::ConstString::buffer8
char8 * buffer8
Definition fstring.h:292

Steinberg::ConstString::getTrailingNumberIndex
int32 getTrailingNumberIndex(uint32 width=0) const
Returns start index of trailing number.
Definition fstring.cpp:1767

Steinberg::ConstString::copyTo
int32 copyTo(tchar *str, uint32 idx=0, int32 n=-1) const
Definition fstring.cpp:607

Steinberg::ConstString::scanUInt64
bool scanUInt64(uint64 &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to uint64 value starting at offset.
Definition fstring.cpp:1375

Steinberg::ConstString::findLast
int32 findLast(char16 c, CompareMode m=kCaseSensitive) const
Definition fstring.h:223

Steinberg::ConstString::ConstString
ConstString(const char8 *str, int32 length=-1)
Assign from string of type char8 (length=-1: all).
Definition fstring.cpp:439

Steinberg::ConstString::ConstString
ConstString()
Definition fstring.cpp:492

Steinberg::ConstString::isEmpty
bool isEmpty() const
Return true if string is empty.
Definition fstring.h:129

Steinberg::ConstString::getChar
tchar getChar(uint32 index) const
Returns character of type tchar at 'index'.
Definition fstring.h:520

Steinberg::ConstString::getNumber
int64 getNumber() const
Returns result of scanInt64.
Definition fstring.h:541

Steinberg::ConstString::multiByteToWideString
static int32 multiByteToWideString(char16 *dest, const char8 *source, int32 wcharCount, uint32 sourceCodePage=kCP_Default)
If dest is zero, this returns the maximum number of bytes needed to convert source.
Definition fstring.cpp:1858

Steinberg::ConstString::findLast
int32 findLast(char8 c, CompareMode m=kCaseSensitive) const
Definition fstring.h:222

Steinberg::ConstString::contains
bool contains(const ConstString &str, CompareMode m=kCaseSensitive) const
Check if this contains str.
Definition fstring.cpp:932

Steinberg::ConstString::testChar
bool testChar(uint32 index, char8 c) const
Definition fstring.h:152

Steinberg::ConstString::toVariant
void toVariant(FVariant &var) const
Definition fstring.cpp:1806

Steinberg::ConstString::~ConstString
virtual ~ConstString()
Destructor.
Definition fstring.h:125

Steinberg::ConstString::scanInt64_8
static bool scanInt64_8(const char8 *text, int64 &value, bool scanToEnd=true)
Converts string of type char8 to int64 value.
Definition fstring.cpp:1423

Steinberg::ConstString::isCharAscii
static bool isCharAscii(char8 character)
Returns true if character is in ASCII range.
Definition fstring.cpp:1719

Steinberg::ConstString::findNext
int32 findNext(int32 startIndex, const ConstString &str, int32 n=-1, CompareMode=kCaseSensitive, int32 endIndex=-1) const
Definition fstring.cpp:938

Steinberg::ConstString::findFirst
int32 findFirst(const ConstString &str, int32 n=-1, CompareMode m=kCaseSensitive, int32 endIndex=-1) const
Definition fstring.h:204

Steinberg::ConstString::scanInt64_16
static bool scanInt64_16(const char16 *text, int64 &value, bool scanToEnd=true)
Converts string of type char16 to int64 value.
Definition fstring.cpp:1437

Steinberg::ConstString::isCharDigit
static bool isCharDigit(char8 character)
Returns true if character is a number.
Definition fstring.cpp:1707

Steinberg::ConstString::isCharAlpha
static bool isCharAlpha(char8 character)
Returns true if character is an alphabetic character.
Definition fstring.cpp:1683

Steinberg::ConstString::isNormalized
bool isNormalized(UnicodeNormalization=kUnicodeNormC)
On PC only kUnicodeNormC is working.
Definition fstring.cpp:2007

Steinberg::ConstString::findPrev
int32 findPrev(int32 startIndex, const ConstString &str, int32 n=-1, CompareMode=kCaseSensitive) const
Definition fstring.cpp:1173

Steinberg::ConstString::scanFloat
bool scanFloat(double &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to double value starting at offset.
Definition fstring.cpp:1535

Steinberg::ConstString::scanInt64
bool scanInt64(int64 &value, uint32 offset=0, bool scanToEnd=true) const
Converts string to int64 value starting at offset.
Definition fstring.cpp:1363

Steinberg::ConstString::copyTo16
int32 copyTo16(char16 *str, uint32 idx=0, int32 n=-1) const
Definition fstring.cpp:579

Steinberg::ConstString::getChar16
virtual char16 getChar16(uint32 index) const
Returns character of type char8 at 'index'.
Definition fstring.h:512

Steinberg::ConstString::scanUInt64_8
static bool scanUInt64_8(const char8 *text, uint64 &value, bool scanToEnd=true)
Converts string of type char8 to uint64 value.
Definition fstring.cpp:1449

Steinberg::ConstString::compareAt
int32 compareAt(uint32 index, const ConstString &str, int32 n=-1, CompareMode m=kCaseSensitive) const
Compare n characters of str with n characters of this starting at index (return: see above).
Definition fstring.cpp:709

Steinberg::ConstString::compare
int32 compare(const ConstString &str, int32 n, CompareMode m=kCaseSensitive) const
Compare n characters of str with n characters of this (return: see above).
Definition fstring.cpp:651

Steinberg::ConstString::scanUInt32_8
static bool scanUInt32_8(const char8 *text, uint32 &value, bool scanToEnd=true)
Converts string of type char8 to int32 value.
Definition fstring.h:585

Steinberg::ConstString::ptr
virtual const void * ptr() const
Returns pointer to string of type void.
Definition fstring.h:143

Steinberg::ConstString::text16
virtual const char16 * text16() const
Returns pointer to string of type char16.
Definition fstring.h:498

Steinberg::ConstString::length
virtual int32 length() const
Return length of string.
Definition fstring.h:128

Steinberg::ConstString::buffer16
char16 * buffer16
Definition fstring.h:293

Steinberg::ConstString::toUpper
static char8 toUpper(char8 c)
Converts to upper case.
Definition fstring.cpp:1638

Steinberg::ConstString::buffer
void * buffer
Definition fstring.h:291

Steinberg::ConstString::isWide
uint32 isWide
Definition fstring.h:296

Steinberg::ConstString::scanInt32_16
static bool scanInt32_16(const char16 *text, int32 &value, bool scanToEnd=true)
Converts string of type char16 to int32 value.
Definition fstring.h:561

Steinberg::FObject
Definition fobject.h:82

Steinberg::FObject::FObject
FObject()
default constructor...
Definition fobject.h:85

Steinberg::FVariant
Definition fvariant.h:34

Steinberg::IAttributes
Definition ipersistent.h:80

Steinberg::IString
Definition istringresult.h:50

Steinberg::IStringResult
Definition istringresult.h:32

Steinberg::String
Definition fstring.h:308

Steinberg::String::printf
String & printf(const char8 *format,...)
Print formatted data into string.
Definition fstring.cpp:3314

Steinberg::String::getChar8
char8 getChar8(uint32 index) const SMTG_OVERRIDE
Returns character of type char16 at 'index'.
Definition fstring.h:640

Steinberg::String::assign
String & assign(const ConstString &str, int32 n=-1)
Assign n characters of str (-1: all).
Definition fstring.cpp:2500

Steinberg::String::CharGroup
CharGroup
Definition fstring.h:396

Steinberg::String::kNotAlphaNum
@ kNotAlphaNum
Definition fstring.h:396

Steinberg::String::kNotAlpha
@ kNotAlpha
Definition fstring.h:396

Steinberg::String::kSpace
@ kSpace
Definition fstring.h:396

Steinberg::String::checkToMultiByte
bool checkToMultiByte(uint32 destCodePage=kCP_Default) const
Definition fstring.cpp:2181

Steinberg::String::replaceChars8
bool replaceChars8(const char8 *toReplace, char8 toReplaceBy)
Returns true when any replacement was done.
Definition fstring.cpp:2992

Steinberg::String::text8
const char8 * text8() const SMTG_OVERRIDE
Returns pointer to string of type char8.
Definition fstring.h:621

Steinberg::String::swapContent
void swapContent(String &s)
Swaps ownership of the strings pointed to.
Definition fstring.cpp:3633

Steinberg::String::toUpper
void toUpper()
Upper case the string.
Definition fstring.cpp:3540

Steinberg::String::normalize
bool normalize(UnicodeNormalization=kUnicodeNormC)
On PC only kUnicodeNormC is working.
Definition fstring.cpp:2262

Steinberg::String::fromAttributes
bool fromAttributes(IAttributes *a, IAttrID attrID)
Assigns string from FAttributes.
Definition fstring.cpp:3613

Steinberg::String::fromVariant
bool fromVariant(const FVariant &var)
Assigns string from FVariant.
Definition fstring.cpp:3573

Steinberg::String::~String
~String()
Definition fstring.cpp:2103

Steinberg::String::operator+=
String & operator+=(const String &str)
Definition fstring.h:368

Steinberg::String::replaceChars
bool replaceChars(const char16 *toReplace, char16 toReplaceBy)
Definition fstring.h:391

Steinberg::String::vprintf
String & vprintf(const char8 *format, va_list args)
Definition fstring.cpp:3339

Steinberg::String::removeChars8
bool removeChars8(const char8 *which)
Remove all occurrences of each char in 'which'.
Definition fstring.cpp:3266

Steinberg::String::toAttributes
bool toAttributes(IAttributes *a, IAttrID attrID)
Definition fstring.cpp:3622

Steinberg::String::String
String()
Definition fstring.cpp:2038

Steinberg::String::replaceChars16
bool replaceChars16(char16 toReplace, char16 toReplaceBy)
Definition fstring.h:387

Steinberg::String::removeChars
bool removeChars(const char16 which)
Definition fstring.h:406

Steinberg::String::insertAt
String & insertAt(uint32 idx, const ConstString &str, int32 n=-1)
Insert n characters of str at position idx (n=-1: all).
Definition fstring.cpp:2745

Steinberg::String::removeChars16
bool removeChars16(const char16 *which)
Remove all occurrences of each char in 'which'.
Definition fstring.cpp:3290

Steinberg::String::fromPascalString
const String & fromPascalString(const unsigned char *buf)
Pascal string conversion.
Definition fstring.cpp:3734

Steinberg::String::pass
void * pass()
Definition fstring.cpp:3667

Steinberg::String::setChar16
bool setChar16(uint32 index, char16 c)
Definition fstring.cpp:2451

Steinberg::String::toWideString
bool toWideString(uint32 sourceCodePage=kCP_Default)
Converts to wide string according to sourceCodePage.
Definition fstring.cpp:2141

Steinberg::String::toMultiByte
bool toMultiByte(uint32 destCodePage=kCP_Default)
Definition fstring.cpp:2225

Steinberg::String::removeChars8
bool removeChars8(const char8 which)
Definition fstring.h:401

Steinberg::String::take
void take(String &str)
Take ownership of the string of 'str'.
Definition fstring.cpp:3647

Steinberg::String::printFloat
String & printFloat(double value)
Definition fstring.cpp:3372

Steinberg::String::replaceChars
bool replaceChars(const char8 *toReplace, char8 toReplaceBy)
Definition fstring.h:390

Steinberg::String::getChar16
char16 getChar16(uint32 index) const SMTG_OVERRIDE
Returns character of type char8 at 'index'.
Definition fstring.h:649

Steinberg::String::toPascalString
unsigned char * toPascalString(unsigned char *buf)
Pascal string conversion.
Definition fstring.cpp:3704

Steinberg::String::replaceChars8
bool replaceChars8(char8 toReplace, char8 toReplaceBy)
Definition fstring.h:386

Steinberg::String::printInt64
String & printInt64(int64 value)
Definition fstring.cpp:3357

Steinberg::String::replaceChars
bool replaceChars(char16 toReplace, char16 toReplaceBy)
Definition fstring.h:389

Steinberg::String::append
String & append(const ConstString &str, int32 n=-1)
Append n characters of str to this (n=-1: all).
Definition fstring.cpp:2597

Steinberg::String::removeChars
bool removeChars(const char16 *which)
Definition fstring.h:404

Steinberg::String::operator=
String & operator=(const char8 *str)
Assign from a string of type char8.
Definition fstring.h:341

Steinberg::String::text16
const char16 * text16() const SMTG_OVERRIDE
Returns pointer to string of type char16.
Definition fstring.h:630

Steinberg::String::removeChars
bool removeChars(const char8 which)
Definition fstring.h:405

Steinberg::String::incrementTrailingNumber
bool incrementTrailingNumber(uint32 width=2, tchar separator=STR(' '), uint32 minNumber=1, bool applyOnlyFormat=false)
Definition fstring.cpp:3424

Steinberg::String::removeChars
bool removeChars(const char8 *which)
Definition fstring.h:403

Steinberg::String::resize
bool resize(uint32 newSize, bool wide, bool fill=false)
Definition fstring.cpp:2329

Steinberg::String::toVariant
void toVariant(FVariant &var) const
Definition fstring.cpp:3600

Steinberg::String::replaceChars
bool replaceChars(char8 toReplace, char8 toReplaceBy)
Definition fstring.h:388

Steinberg::String::remove
String & remove(uint32 index=0, int32 n=-1)
Remove n characters from string starting at index (n=-1: until end).
Definition fstring.cpp:3053

Steinberg::String::setChar8
bool setChar8(uint32 index, char8 c)
Definition fstring.cpp:2399

Steinberg::String::fromUTF8
void fromUTF8(const char8 *utf8String)
Assigns from UTF8 string.
Definition fstring.cpp:2255

Steinberg::String::passToVariant
void passToVariant(FVariant &var)
Pass ownership of buffer to Variant - sets Variant ownership.
Definition fstring.cpp:3676

Steinberg::String::trim
bool trim(CharGroup mode=kSpace)
Trim lead/trail.
Definition fstring.cpp:3129

Steinberg::String::tryFreeBuffer
void tryFreeBuffer()
Definition fstring.cpp:2319

Steinberg::String::insertAt
String & insertAt(uint32 idx, char8 c)
Definition fstring.h:365

Steinberg::String::removeSubString
bool removeSubString(const ConstString &subString, bool allOccurences=true)
Definition fstring.cpp:3079

Steinberg::String::replaceChars16
bool replaceChars16(const char16 *toReplace, char16 toReplaceBy)
Definition fstring.cpp:3019

Steinberg::String::insertAt
String & insertAt(uint32 idx, char16 c)
Definition fstring.h:366

Steinberg::String::updateLength
void updateLength()
Call this when the string is truncated outside (not recommended though).
Definition fstring.cpp:2132

Steinberg::String::setChar
bool setChar(uint32 index, char16 c)
Definition fstring.h:337

Steinberg::String::toLower
void toLower()
Lower case the string.
Definition fstring.cpp:3495

Steinberg::String::replace
String & replace(uint32 idx, int32 n1, const ConstString &str, int32 n2=-1)
Replace n1 characters of this (starting at idx) with n2 characters of str (n1,n2=-1: until end).
Definition fstring.cpp:2824

Steinberg::String::removeChars16
bool removeChars16(const char16 which)
Definition fstring.h:402

Steinberg::String::setChar
bool setChar(uint32 index, char8 c)
Definition fstring.h:336

Steinberg::String::removeChars
void removeChars(CharGroup mode=kSpace)
Removes all of group.
Definition fstring.cpp:3192

Steinberg::StringObject
Definition fstring.h:716

Steinberg::StringObject::getText8
const char8 *PLUGIN_API getText8() SMTG_OVERRIDE
Definition fstring.cpp:3967

Steinberg::StringObject::take
void PLUGIN_API take(void *s, bool _isWide) SMTG_OVERRIDE
Definition fstring.cpp:3979

Steinberg::StringObject::StringObject
StringObject(const FVariant &var)
Definition fstring.h:724

Steinberg::StringObject::setText8
void PLUGIN_API setText8(const char8 *text) SMTG_OVERRIDE
Definition fstring.cpp:3955

Steinberg::StringObject::StringObject
StringObject(const StringObject &str, int32 n=-1)
Definition fstring.h:722

Steinberg::StringObject::StringObject
StringObject(const char16 *str, int32 n=-1, bool isTerminated=true)
Definition fstring.h:720

Steinberg::StringObject::getText16
const char16 *PLUGIN_API getText16() SMTG_OVERRIDE
Definition fstring.cpp:3973

Steinberg::StringObject::setText
void PLUGIN_API setText(const char8 *text) SMTG_OVERRIDE
Definition fstring.cpp:3949

Steinberg::StringObject::StringObject
StringObject()
Definition fstring.h:719

Steinberg::StringObject::StringObject
StringObject(const String &str, int32 n=-1)
Definition fstring.h:723

Steinberg::StringObject::setText16
void PLUGIN_API setText16(const char16 *text) SMTG_OVERRIDE
Definition fstring.cpp:3961

Steinberg::StringObject::isWideString
bool PLUGIN_API isWideString() const SMTG_OVERRIDE
Definition fstring.cpp:3985

Steinberg::StringObject::StringObject
StringObject(const char8 *str, int32 n=-1, bool isTerminated=true)
Definition fstring.h:721

m
unsigned * m
Definition inflate.c:1559

s
unsigned s
Definition inflate.c:1555

fobject.h

OBJ_METHODS
#define OBJ_METHODS(className, baseClass)
Definition fobject.h:339

FUNKNOWN_METHODS2
#define FUNKNOWN_METHODS2(InterfaceName1, InterfaceName2, BaseClass)
Definition fobject.h:458

SMTG_OVERRIDE
#define SMTG_OVERRIDE
Definition fplatform.h:241

fstrdefs.h

STR
#define STR(x)
Definition fstrdefs.h:39

ftypes.h

value
static PuglViewHint int value
Definition pugl.h:1708

width
static int width
Definition pugl.h:1593

ipersistent.h

istringresult.h

Steinberg
Definition baseiids.cpp:43

Steinberg::uint64
unsigned long long uint64
Definition ftypes.h:67

Steinberg::char16
int16 char16
Definition ftypes.h:101

Steinberg::int32
int int32
Definition ftypes.h:50

Steinberg::IAttrID
FIDString IAttrID
Definition ipersistent.h:62

Steinberg::kEmptyString16
static const char16 kEmptyString16[]
Definition fstrdefs.h:104

Steinberg::char8
char char8
Definition ftypes.h:93

Steinberg::kWideStringDefault
static const bool kWideStringDefault
Definition fstring.h:57

Steinberg::uint16
unsigned short uint16
Definition ftypes.h:44

Steinberg::strnatcmp
int32 strnatcmp(const tchar *s1, const tchar *s2, bool caseSensitive=true)
Definition fstring.h:698

Steinberg::kEmptyString8
static const char8 kEmptyString8[]
Definition fstrdefs.h:103

Steinberg::int64
long long int64
Definition ftypes.h:66

Steinberg::kBomUtf16
static const uint16 kBomUtf16
UTF16 Byte Order Mark.
Definition fstring.h:60

Steinberg::operator>=
bool operator>=(const ConstString &s1, const ConstString &s2)
Definition fstring.h:664

Steinberg::strnatcmp16
int32 strnatcmp16(const char16 *s1, const char16 *s2, bool caseSensitive)
Definition fstring.cpp:3941

Steinberg::tchar
char16 tchar
Definition ftypes.h:105

Steinberg::operator!=
bool operator!=(const ConstString &s1, const ConstString &s2)
Definition fstring.h:666

Steinberg::hashString8
uint32 hashString8(const char8 *s, uint32 m)
Definition fstring.cpp:3835

Steinberg::MBCodePage
MBCodePage
Definition fstring.h:66

Steinberg::kCP_MAC_ROMAN
@ kCP_MAC_ROMAN
Default Mac codepage.
Definition fstring.h:68

Steinberg::kCP_ShiftJIS
@ kCP_ShiftJIS
Shifted Japan Industrial Standard Encoding.
Definition fstring.h:73

Steinberg::kCP_US_ASCII
@ kCP_US_ASCII
US-ASCII (7-bit).
Definition fstring.h:74

Steinberg::kCP_Default
@ kCP_Default
Default ANSI codepage.
Definition fstring.h:76

Steinberg::kCP_MAC_CEE
@ kCP_MAC_CEE
Mac Central European Encoding.
Definition fstring.h:71

Steinberg::kCP_ANSI_WEL
@ kCP_ANSI_WEL
West European Latin Encoding.
Definition fstring.h:70

Steinberg::kCP_ANSI
@ kCP_ANSI
Default ANSI codepage.
Definition fstring.h:67

Steinberg::kCP_Utf8
@ kCP_Utf8
UTF8 Encoding.
Definition fstring.h:72

Steinberg::uint8
unsigned char uint8
Definition ftypes.h:40

Steinberg::operator>
bool operator>(const ConstString &s1, const ConstString &s2)
Definition fstring.h:663

Steinberg::hashString
uint32 hashString(const tchar *s, uint32 m)
Definition fstring.h:92

Steinberg::UnicodeNormalization
UnicodeNormalization
Definition fstring.h:80

Steinberg::kUnicodeNormKD
@ kUnicodeNormKD
Unicode normalization form KD, compatibility decomposition.
Definition fstring.h:84

Steinberg::kUnicodeNormKC
@ kUnicodeNormKC
Unicode normalization form KC, compatibility composition.
Definition fstring.h:83

Steinberg::kUnicodeNormD
@ kUnicodeNormD
Unicode normalization Form D, canonical decomposition.
Definition fstring.h:82

Steinberg::kUnicodeNormC
@ kUnicodeNormC
Unicode normalization Form C, canonical composition.
Definition fstring.h:81

Steinberg::kBomUtf8
static const char8 *const kBomUtf8
UTF8 Byte Order Mark.
Definition fstring.h:61

Steinberg::hashString16
uint32 hashString16(const char16 *s, uint32 m)
Definition fstring.cpp:3847

Steinberg::operator<
bool operator<(const ConstString &s1, const ConstString &s2)
Definition fstring.h:661

Steinberg::operator+
String operator+(const ConstString &s1, const ConstString &s2)
Definition fstring.h:466

Steinberg::kBomUtf8Length
static const int32 kBomUtf8Length
Definition fstring.h:62

Steinberg::strnatcmp8
int32 strnatcmp8(const char8 *s1, const char8 *s2, bool caseSensitive)
Definition fstring.cpp:3935

Steinberg::uint32
unsigned int uint32
Definition ftypes.h:51

Steinberg::operator==
bool operator==(const ConstString &s1, const ConstString &s2)
Definition fstring.h:665

Steinberg::operator<=
bool operator<=(const ConstString &s1, const ConstString &s2)
Definition fstring.h:662

true
#define true
Definition ordinals.h:82

mode
png_structrp int mode
Definition png.h:1139

text
const char * text
Definition swell-functions.h:167

n
int n
Definition crypt.c:458

c
return c
Definition crypt.c:175

result
int result
Definition process.c:1455

format
_WDL_CSTRING_PREFIX void INT_PTR const char * format
Definition wdlcstring.h:263

const
#define const
Definition zconf.h:137