String.h

#pragma once
 
#include <Foundation/Algorithm/HashingUtils.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Strings/Implementation/StringBase.h>
#include <Foundation/Strings/StringConversion.h>
#include <Foundation/Strings/StringUtils.h>
#include <Foundation/Strings/StringView.h>
 
class plStringBuilder;
class plStreamReader;
 
template <plUInt16 Size>
struct plHybridStringBase : public plStringBase<plHybridStringBase<Size>>
{
protected:
  plHybridStringBase(plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(const plHybridStringBase& rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(plHybridStringBase&& rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(const char* rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(const wchar_t* rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(const plStringView& rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(const plStringBuilder& rhs, plAllocator* pAllocator); // [tested]
 
  plHybridStringBase(plStringBuilder&& rhs, plAllocator* pAllocator); // [tested]
 
  ~plHybridStringBase(); // [tested]
 
  void operator=(const plHybridStringBase& rhs); // [tested]
 
  void operator=(plHybridStringBase&& rhs); // [tested]
 
  void operator=(const char* rhs); // [tested]
 
  void operator=(const wchar_t* rhs); // [tested]
 
  void operator=(const plStringView& rhs); // [tested]
 
  void operator=(const plStringBuilder& rhs); // [tested]
 
  void operator=(plStringBuilder&& rhs); // [tested]
 
#if PL_ENABLED(PL_INTEROP_STL_STRINGS)
  plHybridStringBase(const std::string_view& rhs, plAllocator* pAllocator);
 
  plHybridStringBase(const std::string& rhs, plAllocator* pAllocator);
 
  void operator=(const std::string_view& rhs);
 
  void operator=(const std::string& rhs);
#endif
 
public:
  void Clear(); // [tested]
 
  const char* GetData() const; // [tested]
 
  plUInt32 GetElementCount() const; // [tested]
 
  plUInt32 GetCharacterCount() const; // [tested]
 
  plStringView GetSubString(plUInt32 uiFirstCharacter, plUInt32 uiNumCharacters) const; // [tested]
 
  plStringView GetFirst(plUInt32 uiNumCharacters) const; // [tested]
 
  plStringView GetLast(plUInt32 uiNumCharacters) const; // [tested]
 
  void ReadAll(plStreamReader& inout_stream);
 
  plUInt64 GetHeapMemoryUsage() const { return m_Data.GetHeapMemoryUsage(); }
 
private:
  friend class plStringBuilder;
 
  plHybridArray<char, Size> m_Data;
};
 
 
template <plUInt16 Size, typename AllocatorWrapper = plDefaultAllocatorWrapper>
struct plHybridString : public plHybridStringBase<Size>
{
public:
  plHybridString();
  plHybridString(plAllocator* pAllocator);
 
  plHybridString(const plHybridString<Size, AllocatorWrapper>& other);
  plHybridString(const plHybridStringBase<Size>& other);
  plHybridString(const char* rhs);
  plHybridString(const wchar_t* rhs);
  plHybridString(const plStringView& rhs);
  plHybridString(const plStringBuilder& rhs);
  plHybridString(plStringBuilder&& rhs);
  plHybridString(plHybridString<Size, AllocatorWrapper>&& other);
  plHybridString(plHybridStringBase<Size>&& other);
 
  void operator=(const plHybridString<Size, AllocatorWrapper>& rhs);
  void operator=(const plHybridStringBase<Size>& rhs);
  void operator=(const char* szString);
  void operator=(const wchar_t* pString);
  void operator=(const plStringView& rhs);
  void operator=(const plStringBuilder& rhs);
  void operator=(plStringBuilder&& rhs);
  void operator=(plHybridString<Size, AllocatorWrapper>&& rhs);
  void operator=(plHybridStringBase<Size>&& rhs);
 
#if PL_ENABLED(PL_INTEROP_STL_STRINGS)
  plHybridString(const std::string_view& rhs);
  plHybridString(const std::string& rhs);
  void operator=(const std::string_view& rhs);
  void operator=(const std::string& rhs);
#endif
};
 
using plUntrackedString = plHybridString<32, plStaticsAllocatorWrapper>;
 
using plDynamicString = plHybridString<1>;
using plString = plHybridString<32>;
using plString16 = plHybridString<16>;
using plString24 = plHybridString<24>;
using plString32 = plHybridString<32>;
using plString48 = plHybridString<48>;
using plString64 = plHybridString<64>;
using plString128 = plHybridString<128>;
using plString256 = plHybridString<256>;
 
static_assert(plGetTypeClass<plString>::value == plTypeIsClass::value);
 
template <plUInt16 Size>
struct plCompareHelper<plHybridString<Size>>
{
  static PL_ALWAYS_INLINE bool Less(plStringView lhs, plStringView rhs)
  {
    return lhs.Compare(rhs) < 0;
  }
 
  static PL_ALWAYS_INLINE bool Equal(plStringView lhs, plStringView rhs)
  {
    return lhs.IsEqual(rhs);
  }
};
 
struct plCompareString_NoCase
{
  static PL_ALWAYS_INLINE bool Less(plStringView lhs, plStringView rhs)
  {
    return lhs.Compare_NoCase(rhs) < 0;
  }
 
  static PL_ALWAYS_INLINE bool Equal(plStringView lhs, plStringView rhs)
  {
    return lhs.IsEqual_NoCase(rhs);
  }
};
 
struct CompareConstChar
{
  static PL_ALWAYS_INLINE bool Less(const char* a, const char* b) { return plStringUtils::Compare(a, b) < 0; }
 
  static PL_ALWAYS_INLINE bool Equal(const char* a, const char* b) { return plStringUtils::IsEqual(a, b); }
};
 
// For plFormatString
PL_FOUNDATION_DLL plStringView BuildString(char* szTmp, plUInt32 uiLength, const plString& sArg);
PL_FOUNDATION_DLL plStringView BuildString(char* szTmp, plUInt32 uiLength, const plUntrackedString& sArg);
 
#include <Foundation/Strings/Implementation/String_inl.h>