StringBuilder.h

#pragma once
 
#include <Foundation/ThirdParty/utf8/utf8.h>
 
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Memory/MemoryUtils.h>
#include <Foundation/Strings/FormatString.h>
#include <Foundation/Strings/Implementation/StringBase.h>
#include <Foundation/Strings/PathUtils.h>
#include <Foundation/Strings/StringUtils.h>
#include <Foundation/Strings/StringView.h>
 
template <plUInt16 Size>
struct plHybridStringBase;
 
template <plUInt16 Size, typename AllocatorWrapper>
struct plHybridString;
 
class plStreamReader;
class plFormatString;
 
class PL_FOUNDATION_DLL plStringBuilder : public plStringBase<plStringBuilder>
{
public:
  plStringBuilder(plAllocator* pAllocator = plFoundation::GetDefaultAllocator()); // [tested]
 
  plStringBuilder(const plStringBuilder& rhs); // [tested]
 
  plStringBuilder(plStringBuilder&& rhs) noexcept;
 
  template <plUInt16 Size>
  plStringBuilder(const plHybridStringBase<Size>& rhs)
    : m_Data(rhs.m_Data)
  {
  }
 
  template <plUInt16 Size, typename A>
  plStringBuilder(const plHybridString<Size, A>& rhs)
    : m_Data(rhs.m_Data)
  {
  }
 
 
  template <plUInt16 Size>
  plStringBuilder(plHybridStringBase<Size>&& rhs)
    : m_Data(std::move(rhs.m_Data))
  {
  }
 
  template <plUInt16 Size, typename A>
  plStringBuilder(plHybridString<Size, A>&& rhs)
    : m_Data(std::move(rhs.m_Data))
  {
  }
 
  plStringBuilder(plStringView sData1, plStringView sData2, plStringView sData3 = {}, plStringView sData4 = {},
    plStringView sData5 = {}, plStringView sData6 = {}); // [tested]
 
  /* implicit */ plStringBuilder(const char* szUTF8, plAllocator* pAllocator = plFoundation::GetDefaultAllocator()); // [tested]
 
  /* implicit */ plStringBuilder(const wchar_t* pWChar, plAllocator* pAllocator = plFoundation::GetDefaultAllocator()); // [tested]
 
  /* implicit */ plStringBuilder(plStringView rhs, plAllocator* pAllocator = plFoundation::GetDefaultAllocator()); // [tested]
 
  void operator=(const plStringBuilder& rhs); // [tested]
 
  void operator=(plStringBuilder&& rhs) noexcept;
 
  void operator=(const char* szUTF8); // [tested]
 
  void operator=(const wchar_t* pWChar); // [tested]
 
  void operator=(plStringView rhs); // [tested]
 
  template <plUInt16 Size>
  void operator=(const plHybridStringBase<Size>& rhs)
  {
    m_Data = rhs.m_Data;
  }
 
  template <plUInt16 Size, typename A>
  void operator=(const plHybridString<Size, A>& rhs)
  {
    m_Data = rhs.m_Data;
  }
 
  template <plUInt16 Size>
  void operator=(plHybridStringBase<Size>&& rhs)
  {
    m_Data = std::move(rhs.m_Data);
  }
 
  template <plUInt16 Size, typename A>
  void operator=(plHybridString<Size, A>&& rhs) noexcept
  {
    m_Data = std::move(rhs.m_Data);
  }
 
  plAllocator* GetAllocator() const;
 
  void Clear(); // [tested]
 
  const char* GetData() const; // [tested]
 
  plUInt32 GetElementCount() const; // [tested]
 
  plUInt32 GetCharacterCount() const; // [tested]
 
  void ToUpper(); // [tested]
 
  void ToLower(); // [tested]
 
  void ChangeCharacter(iterator& ref_it, plUInt32 uiCharacter); // [tested]
 
  void Set(plStringView sData1); // [tested]
  void Set(plStringView sData1, plStringView sData2); // [tested]
  void Set(plStringView sData1, plStringView sData2, plStringView sData3); // [tested]
  void Set(plStringView sData1, plStringView sData2, plStringView sData3, plStringView sData4); // [tested]
  void Set(plStringView sData1, plStringView sData2, plStringView sData3, plStringView sData4, plStringView sData5, plStringView sData6 = {}); // [tested]
 
  void SetPath(plStringView sData1, plStringView sData2, plStringView sData3 = {}, plStringView sData4 = {});
 
  void SetSubString_FromTo(const char* pStart, const char* pEnd);
 
  void SetSubString_ElementCount(const char* pStart, plUInt32 uiElementCount);
 
  void SetSubString_CharacterCount(const char* pStart, plUInt32 uiCharacterCount);
 
  void Append(plUInt32 uiChar); // [tested]
 
  void Append(const wchar_t* pData1, const wchar_t* pData2 = nullptr, const wchar_t* pData3 = nullptr, const wchar_t* pData4 = nullptr, const wchar_t* pData5 = nullptr, const wchar_t* pData6 = nullptr); // [tested]
 
  void Append(plStringView sData1); // [tested]
  void Append(plStringView sData1, plStringView sData2); // [tested]
  void Append(plStringView sData1, plStringView sData2, plStringView sData3); // [tested]
  void Append(plStringView sData1, plStringView sData2, plStringView sData3, plStringView sData4); // [tested]
  void Append(plStringView sData1, plStringView sData2, plStringView sData3, plStringView sData4, plStringView sData5, plStringView sData6 = {}); // [tested]
 
  void Prepend(plUInt32 uiChar); // [tested]
 
  void Prepend(const wchar_t* pData1, const wchar_t* pData2 = nullptr, const wchar_t* pData3 = nullptr, const wchar_t* pData4 = nullptr,
    const wchar_t* pData5 = nullptr, const wchar_t* pData6 = nullptr); // [tested]
 
  void Prepend(plStringView sData1, plStringView sData2 = {}, plStringView sData3 = {}, plStringView sData4 = {},
    plStringView sData5 = {}, plStringView sData6 = {}); // [tested]
 
  void SetPrintf(const char* szUtf8Format, ...); // [tested]
 
  void SetPrintfArgs(const char* szUtf8Format, va_list szArgs); // [tested]
 
  void SetFormat(const plFormatString& string);
 
  template <typename... ARGS>
  void SetFormat(const char* szFormat, ARGS&&... args)
  {
    SetFormat(plFormatStringImpl<ARGS...>(szFormat, std::forward<ARGS>(args)...));
  }
 
  void AppendFormat(const plFormatString& string);
 
  template <typename... ARGS>
  void AppendFormat(const char* szFormat, ARGS&&... args)
  {
    AppendFormat(plFormatStringImpl<ARGS...>(szFormat, std::forward<ARGS>(args)...));
  }
 
  void PrependFormat(const plFormatString& string);
 
  template <typename... ARGS>
  void PrependFormat(const char* szFormat, ARGS&&... args)
  {
    PrependFormat(plFormatStringImpl<ARGS...>(szFormat, std::forward<ARGS>(args)...));
  }
 
  void Shrink(plUInt32 uiShrinkCharsFront, plUInt32 uiShrinkCharsBack); // [tested]
 
  void Reserve(plUInt32 uiNumElements); // [tested]
 
 
  void ReplaceSubString(const char* szStartPos, const char* szEndPos, plStringView sReplaceWith); // [tested]
 
  void Insert(const char* szInsertAtPos, plStringView sTextToInsert); // [tested]
 
  void Remove(const char* szRemoveFromPos, const char* szRemoveToPos); // [tested]
 
  const char* ReplaceFirst(plStringView sSearchFor, plStringView sReplacement, const char* szStartSearchAt = nullptr); // [tested]
 
  const char* ReplaceFirst_NoCase(plStringView sSearchFor, plStringView sReplacement, const char* szStartSearchAt = nullptr); // [tested]
 
  const char* ReplaceLast(plStringView sSearchFor, plStringView sReplacement, const char* szStartSearchAt = nullptr); // [tested]
 
  const char* ReplaceLast_NoCase(plStringView sSearchFor, plStringView sReplacement, const char* szStartSearchAt = nullptr); // [tested]
 
  plUInt32 ReplaceAll(plStringView sSearchFor, plStringView sReplacement); // [tested]
 
  plUInt32 ReplaceAll_NoCase(plStringView sSearchFor, plStringView sReplacement); // [tested]
 
  const char* ReplaceWholeWord(const char* szSearchFor, plStringView sReplaceWith, plStringUtils::PL_CHARACTER_FILTER isDelimiterCB); // [tested]
 
  const char* ReplaceWholeWord_NoCase(const char* szSearchFor, plStringView sReplaceWith, plStringUtils::PL_CHARACTER_FILTER isDelimiterCB); // [tested]
 
  plUInt32 ReplaceWholeWordAll(const char* szSearchFor, plStringView sReplaceWith, plStringUtils::PL_CHARACTER_FILTER isDelimiterCB); // [tested]
 
  plUInt32 ReplaceWholeWordAll_NoCase(const char* szSearchFor, plStringView sReplaceWith, plStringUtils::PL_CHARACTER_FILTER isDelimiterCB); // [tested]
 
  void ReadAll(plStreamReader& inout_stream);
 
  // ******* Path Functions ********
 
  void MakeCleanPath(); // [tested]
 
  void PathParentDirectory(plUInt32 uiLevelsUp = 1); // [tested]
 
  void AppendPath(plStringView sPath1, plStringView sPath2 = {}, plStringView sPath3 = {}, plStringView sPath4 = {}); // [tested]
 
  void AppendWithSeparator(plStringView sSeparator, plStringView sText1, plStringView sText2 = plStringView(), plStringView sText3 = plStringView(), plStringView sText4 = plStringView(), plStringView sText5 = plStringView(), plStringView sText6 = plStringView());
 
  void ChangeFileName(plStringView sNewFileName); // [tested]
 
  void ChangeFileNameAndExtension(plStringView sNewFileNameWithExtension); // [tested]
 
  void ChangeFileExtension(plStringView sNewExtension, bool bFullExtension = false); // [tested]
 
  void RemoveFileExtension(bool bFullExtension = false); // [tested]
 
  plResult MakeRelativeTo(plStringView sAbsolutePathToMakeThisRelativeTo); // [tested]
 
  void MakePathSeparatorsNative(); // [tested]
 
  bool IsPathBelowFolder(const char* szPathToFolder); // [tested]
 
  plUInt64 GetHeapMemoryUsage() const { return m_Data.GetHeapMemoryUsage(); }
 
  void Trim(const char* szTrimChars = " \f\n\r\t\v"); // [tested]
 
  void Trim(const char* szTrimCharsStart, const char* szTrimCharsEnd); // [tested]
 
  void TrimLeft(const char* szTrimChars = " \f\n\r\t\v");
 
  void TrimRight(const char* szTrimChars = " \f\n\r\t\v");
 
  bool TrimWordStart(plStringView sWord); // [tested]
 
  bool TrimWordEnd(plStringView sWord); // [tested]
 
#if PL_ENABLED(PL_INTEROP_STL_STRINGS)
  /* implicit */ plStringBuilder(const std::string_view& rhs, plAllocator* pAllocator = plFoundation::GetDefaultAllocator());
 
  /* implicit */ plStringBuilder(const std::string& rhs, plAllocator* pAllocator = plFoundation::GetDefaultAllocator());
 
  void operator=(const std::string_view& rhs);
 
  void operator=(const std::string& rhs);
#endif
 
private:
  void RemoveDoubleSlashesInPath(); // [tested]
 
  void ChangeCharacterNonASCII(iterator& it, plUInt32 uiCharacter);
  void AppendTerminator();
 
  // needed for better copy construction
  template <plUInt16 T>
  friend struct plHybridStringBase;
 
  friend plStreamReader;
 
  plHybridArray<char, 128> m_Data;
};
 
#include <Foundation/Strings/Implementation/StringBuilder_inl.h>