HashedString.h

#pragma once
 
#include <Foundation/Algorithm/HashingUtils.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Threading/AtomicInteger.h>
 
class plTempHashedString;
 
class PL_FOUNDATION_DLL plHashedString
{
public:
  struct HashedData
  {
#if PL_ENABLED(PL_HASHED_STRING_REF_COUNTING)
    plAtomicInteger32 m_iRefCount;
#endif
    plString m_sString;
  };
 
  // Do NOT use a hash-table! The map does not relocate memory when it resizes, which is a vital aspect for the hashed strings to work.
  using StringStorage = plMap<plUInt64, HashedData, plCompareHelper<plUInt64>, plStaticsAllocatorWrapper>;
  using HashedType = StringStorage::Iterator;
 
#if PL_ENABLED(PL_HASHED_STRING_REF_COUNTING)
  static plUInt32 ClearUnusedStrings();
#endif
 
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
  plHashedString(); // [tested]
 
  plHashedString(const plHashedString& rhs); // [tested]
 
  plHashedString(plHashedString&& rhs); // [tested]
 
#if PL_ENABLED(PL_HASHED_STRING_REF_COUNTING)
  ~plHashedString();
#endif
 
  void operator=(const plHashedString& rhs); // [tested]
 
  void operator=(plHashedString&& rhs); // [tested]
 
  template <size_t N>
  void Assign(const char (&string)[N]); // [tested]
 
  template <size_t N>
  void Assign(char (&string)[N]) = delete;
 
  void Assign(plStringView sString); // [tested]
 
  bool operator==(const plHashedString& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plHashedString&);
 
  bool operator==(const plTempHashedString& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plTempHashedString&);
 
  bool operator<(const plHashedString& rhs) const; // [tested]
 
  bool operator<(const plTempHashedString& rhs) const; // [tested]
 
  const plString& GetString() const; // [tested]
 
  const char* GetData() const;
 
  plUInt64 GetHash() const; // [tested]
 
  bool IsEmpty() const;
 
  void Clear();
 
  PL_ALWAYS_INLINE operator plStringView() const { return GetString().GetView(); }
 
  PL_ALWAYS_INLINE plStringView GetView() const { return GetString().GetView(); }
 
  PL_ALWAYS_INLINE operator const char*() const { return GetData(); }
 
private:
  static void InitHashedString();
  static HashedType AddHashedString(plStringView sString, plUInt64 uiHash);
 
  HashedType m_Data;
};
 
template <size_t N>
plHashedString plMakeHashedString(const char (&string)[N]);
 
 
class PL_FOUNDATION_DLL plTempHashedString
{
  friend class plHashedString;
 
public:
  plTempHashedString(); // [tested]
 
  template <size_t N>
  plTempHashedString(const char (&string)[N]); // [tested]
 
  template <size_t N>
  plTempHashedString(char (&string)[N]) = delete;
 
  explicit plTempHashedString(plStringView sString); // [tested]
 
  plTempHashedString(const plTempHashedString& rhs); // [tested]
 
  plTempHashedString(const plHashedString& rhs); // [tested]
 
  explicit plTempHashedString(plUInt32 uiHash) = delete;
 
  explicit plTempHashedString(plUInt64 uiHash);
 
  template <size_t N>
  void operator=(const char (&string)[N]); // [tested]
 
  void operator=(plStringView sString); // [tested]
 
  void operator=(const plTempHashedString& rhs); // [tested]
 
  void operator=(const plHashedString& rhs); // [tested]
 
  bool operator==(const plTempHashedString& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plTempHashedString&);
 
  bool operator<(const plTempHashedString& rhs) const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  void Clear(); // [tested]
 
  plUInt64 GetHash() const; // [tested]
 
private:
  plUInt64 m_uiHash;
};
 
// For plFormatString
PL_FOUNDATION_DLL plStringView BuildString(char* szTmp, plUInt32 uiLength, const plHashedString& sArg);
 
#include <Foundation/Strings/Implementation/HashedString_inl.h>