fsStr.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsStr.h
*
*       Purpose:        String
*
*********************************************************************/
 
#ifndef fsStrhdr
#define fsStrhdr
 
#include <string>
 
#include "fsBaseTypes.h"
 
class fsStr;
fsStr operator+(const fsChar* pLHS, const fsStr& pRHS);
fsStr operator+(const fsStr& pLHS, const fsChar* pRHS);
fsBool operator==(const fsChar* pLHS, const fsStr& pRhs);
fsBool operator!=(const fsChar* pLHS, const fsStr& pRhs);
 
class fsStr
{
public:
 
        typedef std::string::size_type sizeT;
        
        static constexpr sizeT npos = std::string::npos;                                // Non-position in string. Similar to STL.
        static constexpr fsChar mNewLineChar{'\n'};
        static constexpr fsChar mLineFeedChar{'\r'};
        static constexpr fsChar mTabChar{'\t'};
        static constexpr fsChar mSpaceChar{' '};
 
        fsStr(const char* data, sizeT len);
        const fsU8* ptrGet() const;
        
        fsS32 count(fsChar pChar) const;
 
        fsBool isAlphaNumeric() const;
        static fsBool isDigit(fsChar pC);
 
        void formattingRemove();
        void removeXmlTags();
 
        fsBool emptyGet() const { return mImpl.empty(); }
        // Raw storage size in bytes. Use this for binary payloads and byte-oriented parsing.
        sizeT dataSizeGet() const { return mImpl.size(); }
        // Legacy text-length helper intended for human-readable string length, not raw storage size.
        // This should not be mixed with byte-oriented indexing or offsets from operator[], erase(),
        // find()/rfind(), substr-style slicing, or external APIs that expect a byte count.
        sizeT lengthGet() const;
 
        void erase(sizeT pOff = 0, sizeT pCount = npos) { mImpl.erase(pOff, pCount); }
        void eraseToLast(const fsStr& pMatch);
        void eraseFromLast(const fsStr& pMatch);
        // Parser helpers that consume from the front of the string.
        fsStr chomp(const fsStr& pTerm);
        fsStr chunk();
        // ASCII whitespace trimming used by legacy parsers/config readers.
        void leadingWhitespaceTrim();
        void trailingWhitespaceTrim();
        // Trims by the legacy text-length semantics above, while the underlying storage remains byte-oriented.
        void trimToLength(fsS32 pNumChars);
 
        void copy(const char* pString);
        void copy(const char* pString, fsS32 pStart, fsS32 pCount);
        void hTMLCodesReplace();
        void stringSet(const char* str, int len);
        void downcase();
        void upcase();
        fsBool compare(const char* pString, int len) const;
 
        sizeT find(const char* pSub, sizeT pOffset = 0) const { return mImpl.find(pSub, pOffset); }
        sizeT find(const char pSub, sizeT pOffset = 0) const { return mImpl.find(pSub, pOffset); }
        sizeT find(const fsStr& pSub, sizeT pOffset = 0) const { return mImpl.find(pSub.mImpl, pOffset); }
        sizeT rfind(const fsChar* pSub, sizeT pOffset = npos) const { return mImpl.rfind(pSub, pOffset); }
        sizeT rfind(const fsChar pSub, sizeT pOffset = npos) const { return mImpl.rfind(pSub, pOffset); }
        sizeT rfind(const fsStr& pSub, sizeT pOffset = npos) const { return mImpl.rfind(pSub.mImpl, pOffset); }
        sizeT find_first_of(const fsStr& pSub, sizeT pOffset = 0) const { return mImpl.find_first_of(pSub.mImpl, pOffset); }
 
        void replaceAll(const fsStr& pFind, const fsStr& pReplace);
        void replaceFirst(const fsStr& pFind, const fsStr& pReplace);
 
        fsF32 toF32() const;
        fsS32 toS32() const;
        fsU32 toU32() const;
        fsS64 toS64() const;
 
        // Underlying UTF-8/byte buffer.
        // Use with byte-oriented APIs only; dataSizeGet() is the matching size accessor.
        const char *utf8Get() const { return mImpl.c_str(); }
 
        fsBool operator<(const fsStr& pRHS) const { return mImpl < pRHS.mImpl; }
 
        fsBool operator!=(const fsStr& pRHS) const { return mImpl != pRHS.mImpl; }
        fsBool operator!=(const fsChar* pRHS) const { return mImpl != pRHS; }
 
        fsBool operator==(const fsStr& pRHS) const { return mImpl == pRHS.mImpl; }
        fsBool operator==(const fsChar* pRHS) const { return mImpl == pRHS; }
 
        fsStr& operator+=(const fsStr& pRHS)
        {
                mImpl += pRHS.mImpl;
                return *this;
        }
 
        fsStr& operator+=(fsChar pRHS)
        {
                mImpl += pRHS;
                return *this;
        }
 
        fsStr& operator+=(fsS32 pUnicode);
 
        //      fsStr& operator=( fsChar pRHS ) { mImpl = pRHS; return *this; }
 
        // Byte-oriented indexing into the underlying storage.
        // Do not combine with lengthGet() unless the caller is known to be ASCII-only.
        const fsChar& operator[](sizeT pIndex) const { return mImpl.operator[](pIndex); }
        fsChar& operator[](sizeT pIndex) { return mImpl.operator[](pIndex); }
 
        const fsStr operator+(const fsStr& pRHS) const { return fsStr(*this) += pRHS; }
 
        fsStr() {}
        fsStr(const fsChar* pStr) : mImpl(pStr) {}
        fsStr(fsChar pChar) : mImpl(1, pChar) {}
        fsStr(fsS32 pInt) : mImpl(std::to_string(pInt)) {}
        fsStr(fsU32 pInt) : mImpl(std::to_string(pInt)) {}
        fsStr(fsU64 pInt) : mImpl(std::to_string(pInt)) {}
        fsStr(fsS64 pInt) : mImpl(std::to_string(pInt)) {}
        fsStr(fsF32 pFlt) : mImpl(std::to_string(pFlt)) {}
protected:
 
private:
        
        static const fsStr mLessThanStr;
        static const fsStr mGreaterThanStr;
        static const fsStr mLineBreakStr;
 
        static const fsStr mLessThanCode;
        static const fsStr mGreaterThanCode;
        static const fsStr mAmpersandCode;
        static const fsStr mHardSpaceCode;
        static const fsStr mHyphenCode;
        static const fsStr mQuoteCode;
        static const fsStr mAposCode;
 
        std::string mImpl;
};
 
#endif