FLString.h

#pragma once
 
#include "FLBase.h"
 
#include <xstring>
#include <xmemory>
 
namespace FLImaging
{
    namespace Base
    {
        template<typename T>
        class CFLArray;
 
        template <typename T>
        class FL_EXPORT CFLString : public Base::CFLBase
        {
            SupportToDuplicateObject(CFLString<T>,*this);
 
        public:
            CFLString();
 
            CFLString(const CFLString<T>& flString, int64_t i64Length = -1);
 
            CFLString(const CFLString<T>* pFlString, int64_t i64Length = -1);
 
            CFLString(const char i8Value);
 
            CFLString(const wchar_t i16Value);
 
            CFLString(const char* pI8String, int64_t i64Length = -1);
 
            CFLString(const wchar_t* pI16String, int64_t i64Length = -1);
 
            virtual ~CFLString();
 
        public:
 
            virtual void Clear();
 
            virtual bool IsEmpty() const;
 
            virtual int64_t GetLength() const;
 
            virtual T& GetAt(int64_t i64Index) const;
 
            virtual void SetAt(int64_t i64Index, T tValue);
 
            virtual T& Front() const;
 
            virtual T& Back() const;
 
            virtual const T* GetString() const;
 
            virtual T* GetString();
 
            virtual const T* GetBuffer() const;
 
            virtual T* GetBuffer();
 
            virtual const CFLString<T>& Assign(const CFLString<char>& flString, int64_t i64Length = -1);
 
            virtual const CFLString<T>& Assign(const CFLString<wchar_t>& flString, int64_t i64Length = -1);
 
            virtual const CFLString<T>& Assign(const CFLString<char>* pFlString, int64_t i64Length = -1);
 
            virtual const CFLString<T>& Assign(const CFLString<wchar_t>* pFlString, int64_t i64Length = -1);
 
 
            virtual const CFLString<T>& Assign(const char i8Value);
 
            virtual const CFLString<T>& Assign(const wchar_t i16Value);
 
 
            virtual const CFLString<T>& Assign(const char* pI8String, int64_t i64Length = -1);
 
            virtual const CFLString<T>& Assign(const wchar_t* pI16String, int64_t i64Length = -1);
 
            virtual void PushBack(const char i8Value);
 
            virtual void PushBack(const wchar_t i16Value);
 
            virtual void PushBack(const char* pI8String);
 
            virtual void PushBack(const wchar_t* pI16String);
 
            virtual void PushBack(const CFLString<char>& strString);
 
            virtual void PushBack(const CFLString<wchar_t>& strString);
 
            virtual void PushBack(const CFLString<char>* pStrString);
 
            virtual void PushBack(const CFLString<wchar_t>* pStrString);
 
            virtual void PushFront(const char i8Value);
 
            virtual void PushFront(const wchar_t i16Value);
 
            virtual void PushFront(const char* pI8String);
 
            virtual void PushFront(const wchar_t* pI16String);
 
            virtual void PushFront(const CFLString<char>& strString);
 
            virtual void PushFront(const CFLString<wchar_t>& strString);
 
            virtual void PushFront(const CFLString<char>* pStrString);
 
            virtual void PushFront(const CFLString<wchar_t>* pStrString);
 
            virtual void PopBack();
 
            virtual void PopFront();
 
            virtual void Append(const char i8Value);
 
            virtual void Append(const wchar_t i16Value);
 
            virtual void Append(const char* pI8String);
 
            virtual void Append(const wchar_t* pI16String);
 
            virtual void Append(const CFLString<char>& strString);
 
            virtual void Append(const CFLString<wchar_t>& strString);
 
            virtual void Append(const CFLString<char>* pStrString);
 
            virtual void Append(const CFLString<wchar_t>* pStrString);
 
            virtual void InsertAt(int64_t i64Index, const char i8Value);
 
            virtual void InsertAt(int64_t i64Index, const wchar_t i16Value);
 
            virtual void RemoveAt(int64_t i64Index);
 
            virtual void Delete(int64_t i64Offset, int64_t i64Count = -1);
 
            virtual int64_t Find(const CFLString<T>& flsString, int64_t i64Offset = 0) const;
 
            virtual int64_t Find(CFLString<T>* pFlsString, int64_t i64Offset = 0) const;
 
            virtual int64_t Find(T tChar, int64_t i64Offset = 0) const;
 
            virtual int64_t Find(const T* pTString, int64_t i64Offset = 0) const;
 
            virtual int64_t ReverseFind(const CFLString<T>& flsString, int64_t i64Offset = -1) const;
 
            virtual int64_t ReverseFind(CFLString<T>* pFlsString, int64_t i64Offset = -1) const;
 
            virtual int64_t ReverseFind(T tChar, int64_t i64Offset = -1) const;
 
            virtual int64_t ReverseFind(const T* pTString, int64_t i64Offset = -1) const;
 
            virtual int64_t Compare(const CFLString<T>& flsString) const;
 
            virtual int64_t Compare(CFLString<T>* pFlsString) const;
 
            virtual int64_t Compare(const T* pTString) const;
 
 
            virtual int64_t CompareNoCase(const CFLString<T>& flsString) const;
 
            virtual int64_t CompareNoCase(CFLString<T>* pFlsString) const;
 
            virtual int64_t CompareNoCase(const T* pTString) const;
 
 
            virtual const CFLString<T>& Replace(T tOrgValue, T tReplaceValue);
 
            virtual const CFLString<T>& Replace(const T* pTOrgString, const T* pTReplaceString);
 
            virtual const CFLString<T>& Replace(const CFLString<T>& flsOrgString, const T* pTReplaceString);
 
            virtual const CFLString<T>& Replace(const T* pTOrgString, const CFLString<T>& flsReplaceString);
 
            virtual const CFLString<T>& Replace(const CFLString<T>& flsOrgString, const CFLString<T>& flsReplaceString);
 
            virtual CFLString<T> Left(int64_t i64Length) const;
 
            virtual CFLString<T> Mid(int64_t i64Offset, int64_t i64Length = -1) const;
 
            virtual CFLString<T> Right(int64_t i64Length) const;
 
            virtual CFLString<T> SubStr(int64_t i64Offset, int64_t i64Length = -1) const;
 
            virtual const CFLString<T>& MakeUpper();
 
            virtual const CFLString<T>& MakeLower();
 
            virtual const CResult SetFormatBufferSize(int64_t i64BufferSize = 131072);
 
            virtual int64_t GetFormatBufferSize();
 
            virtual const CFLString<T>& __stdcall Format(const T* pTFormat, ...);
 
            virtual const CFLString<T>& __stdcall AppendFormat(const T* pTFormat, ...);
 
            virtual const CFLString<T>& Trim();
 
            virtual const CFLString<T>& Trim(T tValue);
 
            virtual const CFLString<T>& Trim(const T* pTString);
 
            virtual const CFLString<T>& TrimLeft();
 
            virtual const CFLString<T>& TrimLeft(T tValue);
 
            virtual const CFLString<T>& TrimLeft(const T* pTString);
 
            virtual const CFLString<T>& TrimRight();
 
            virtual const CFLString<T>& TrimRight(T tValue);
 
            virtual const CFLString<T>& TrimRight(const T* pTString);
 
            virtual CFLString<T> Tokenize(const CFLString<T>& strToken, int64_t& i64Index) const;
 
            virtual CFLString<T> Tokenize(T tToken, int64_t& i64Index) const;
 
            virtual CFLString<T> Concatenate(const CFLArray<CFLString<T>>& flArray) const;
 
            virtual CFLString<T> Concatenate(const CFLArray<CFLString<T>>* pFlArray) const;
 
 
            virtual CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>& flArray) const;
 
            virtual CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>* pFlArray) const;
 
 
            static CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>& flArray, const CFLString<T>& flsDelimiter);
 
            static CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>& flArray, const CFLString<T>* pFlsDelimiter);
 
            static CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>* pFlArray, const CFLString<T>& flsDelimiter);
 
            static CFLString<T> ConcatenateWithDelimiter(const CFLArray<CFLString<T>>* pFlArray, const CFLString<T>* pFlsDelimiter);
 
 
            virtual int32_t ToInt32(int32_t i32Base = 10) const;
 
            virtual uint32_t ToUint32(int32_t i32Base = 10) const;
 
            virtual int64_t ToInt64(int32_t i32Base = 10) const;
 
            virtual uint64_t ToUint64(int32_t i32Base = 10) const;
 
            virtual float ToFloat() const;
 
            virtual double ToDouble() const;
 
            virtual void Reserve(int64_t i64Length);
 
            virtual const T* Resize(int64_t i64Length);
 
            virtual void ShrinkToFit();
 
            operator T* () const;
 
            operator const T* () const;
 
            const CFLString<T>& operator=(const CFLString<T>& flString);
 
            const CFLString<T>& operator=(const T* pTString);
 
            T& operator[](int32_t i32Index) const;
 
            T& operator[](int64_t i64Index) const;
 
            T& operator[](uint32_t u32Index) const;
 
            T& operator[](uint64_t u64Index) const;
 
            const CFLString<T>& operator+=(const CFLString<T>& flString);
 
            const CFLString<T>& operator+=(const T* pStringPtr);
 
            const CFLString<T>& operator+=(T tValue);
 
            friend bool operator==(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return !flStr1.Compare(flStr2);
            }
 
            friend bool operator==(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return !flStr1.Compare(pStringPtr2);
            }
 
            friend bool operator==(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return !flStr2.Compare(pStringPtr1);
            }
 
            friend bool operator!=(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return !!flStr1.Compare(flStr2);
            }
 
            friend bool operator!=(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return !!flStr1.Compare(pStringPtr2);
            }
 
            friend bool operator!=(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return !!flStr2.Compare(pStringPtr1);
            }
 
            friend bool operator<(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return flStr1.Compare(flStr2) < 0;
            }
 
            friend bool operator<(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return flStr1.Compare(pStringPtr2) < 0;
            }
 
            friend bool operator<(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return flStr2.Compare(pStringPtr1) < 0;
            }
 
 
            friend bool operator>(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return flStr1.Compare(flStr2) > 0;
            }
 
            friend bool operator>(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return flStr1.Compare(pStringPtr2) > 0;
            }
 
            friend bool operator>(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return flStr2.Compare(pStringPtr1) > 0;
            }
 
            friend bool operator<=(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return flStr1.Compare(flStr2) <= 0;
            }
 
            friend bool operator<=(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return flStr1.Compare(pStringPtr2) <= 0;
            }
 
            friend bool operator<=(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return flStr2.Compare(pStringPtr1) <= 0;
            }
 
            friend bool operator>=(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                return flStr1.Compare(flStr2) >= 0;
            }
 
            friend bool operator>=(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                return flStr1.Compare(pStringPtr2) >= 0;
            }
 
            friend bool operator>=(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                return flStr2.Compare(pStringPtr1) >= 0;
            }
 
            friend CFLString<T> operator+(const CFLString<T>& flStr1, const CFLString<T>& flStr2)
            {
                CFLString<T> flString(flStr1);
                flString.Append(flStr2);
                return flString;
            }
 
            friend CFLString<T> operator+(const CFLString<T>& flStr1, const T* pStringPtr2)
            {
                CFLString<T> flString(flStr1);
                flString.Append(pStringPtr2);
                return flString;
            }
 
            friend CFLString<T> operator+(const T* pStringPtr1, const CFLString<T>& flStr2)
            {
                CFLString<T> flString(pStringPtr1);
                flString.Append(flStr2);
                return flString;
            }
 
            friend CFLString<T> operator+(const CFLString<T>& flStr1, T tValue2)
            {
                CFLString<T> flString(flStr1);
                flString.Append(tValue2);
                return flString;
            }
 
            friend CFLString<T> operator+(T tValue1, const CFLString<T>& flStr2)
            {
                CFLString<T> flString(tValue1);
                flString.Append(flStr2);
                return flString;
            }
 
            DeclareGetClassType();
 
        protected:
 
            const T* m_pTData;
            size_t m_stCount;
            int64_t m_i64FormatBufferSize;
 
            std::basic_string<T, std::char_traits<T>, std::allocator<T>>& m_strData;
            DeclareFLStringContainerObject;
        };
 
        typedef CFLString<char> CFLStringA;
        typedef CFLString<wchar_t> CFLStringW;
    }
}