CVar.h

#pragma once
 
#include <Foundation/Communication/Event.h>
#include <Foundation/Configuration/Plugin.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Types/Bitflags.h>
#include <Foundation/Utilities/EnumerableClass.h>
 
class plCVar;
 
struct plCVarType
{
  enum Enum
  {
    Int,    
    Float,  
    Bool,   
    String, 
    ENUM_COUNT
  };
};
 
struct plCVarFlags
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    None = 0,
 
    Save = PL_BIT(0),
 
    RequiresDelayedSync = PL_BIT(1),
 
    ShowRequiresRestartMsg = PL_BIT(2),
 
    RequiresRestart = Save | RequiresDelayedSync | ShowRequiresRestartMsg,
 
    Default = None
  };
 
  struct Bits
  {
    StorageType Save : 1;
    StorageType RequiresDelayedSync : 1;
    StorageType ShowRequiresRestartMsg : 1;
  };
};
 
PL_DECLARE_FLAGS_OPERATORS(plCVarFlags);
 
struct plCVarEvent
{
  plCVarEvent(plCVar* pCVar)
    : m_pCVar(pCVar)
  {
  }
 
  enum Type
  {
    ValueChanged,            
    DelayedSyncValueChanged, 
    ListOfVarsChanged,       
  };
 
  Type m_EventType = ValueChanged;
 
  plCVar* m_pCVar;
};
 
class PL_FOUNDATION_DLL plCVar : public plEnumerable<plCVar>
{
  PL_DECLARE_ENUMERABLE_CLASS(plCVar);
 
public:
  static void SetStorageFolder(plStringView sFolder); // [tested]
 
  static plCVar* FindCVarByName(plStringView sName); // [tested]
 
  static void SaveCVars(); // [tested]
 
  static void SaveCVarsToFile(plStringView sPath, bool bIgnoreSaveFlag = false);
 
  static void LoadCVars(bool bOnlyNewOnes = true, bool bSetAsCurrentValue = true); // [tested]
 
  static void LoadCVarsFromFile(bool bOnlyNewOnes = true, bool bSetAsCurrentValue = true, plDynamicArray<plCVar*>* pOutCVars = nullptr); // [tested]
 
  static void LoadCVarsFromFile(plStringView sPath, bool bOnlyNewOnes = true, bool bSetAsCurrentValue = true, bool bIgnoreSaveFlag = false, plDynamicArray<plCVar*>* pOutCVars = nullptr);
 
  static void LoadCVarsFromCommandLine(bool bOnlyNewOnes = true, bool bSetAsCurrentValue = true, plDynamicArray<plCVar*>* pOutCVars = nullptr); // [tested]
 
  virtual void SetToDelayedSyncValue() = 0; // [tested]
 
  plStringView GetName() const { return m_sName; } // [tested]
 
  virtual plCVarType::Enum GetType() const = 0; // [tested]
 
  plStringView GetDescription() const { return m_sDescription; } // [tested]
 
  plBitflags<plCVarFlags> GetFlags() const { return m_Flags; } // [tested]
 
  plEvent<const plCVarEvent&, plNoMutex, plStaticsAllocatorWrapper> m_CVarEvents; // [tested]
 
  static plEvent<const plCVarEvent&> s_AllCVarEvents;
 
  plStringView GetPluginName() const { return m_sPluginName; }
 
  static void ListOfCVarsChanged(plStringView sSetPluginNameTo);
 
protected:
  plCVar(plStringView sName, plBitflags<plCVarFlags> Flags, plStringView sDescription);
 
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Foundation, CVars);
 
  static void AssignSubSystemPlugin(plStringView sPluginName);
  static void PluginEventHandler(const plPluginEvent& EventData);
 
  static void LoadCVarsFromFileInternal(plStringView path, const plDynamicArray<plCVar*>& vars, bool bOnlyNewOnes, bool bSetAsCurrentValue, plDynamicArray<plCVar*>* pOutCVars);
 
  static void SaveCVarsToFileInternal(plStringView path, const plDynamicArray<plCVar*>& vars);
 
  bool m_bHasNeverBeenLoaded = true; // next time 'LoadCVars' is called, its state will be changed
  plStringView m_sName;
  plStringView m_sDescription;
  plStringView m_sPluginName;
  plBitflags<plCVarFlags> m_Flags;
 
  static plString s_sStorageFolder;
};
 
struct plCVarValue
{
  enum Enum
  {
    Current,     
    Default,     
    Stored,      
    DelayedSync, 
    ENUM_COUNT
  };
};
 
template <typename Type, plCVarType::Enum CVarType>
class plTypedCVar : public plCVar
{
public:
  plTypedCVar(plStringView sName, const Type& value, plBitflags<plCVarFlags> flags, plStringView sDescription);
 
  operator const Type&() const; // [tested]
 
  const Type& GetValue(plCVarValue::Enum val = plCVarValue::Current) const; // [tested]
 
  void operator=(const Type& value); // [tested]
 
  virtual plCVarType::Enum GetType() const override;
  virtual void SetToDelayedSyncValue() override;
 
  bool HasDelayedSyncValueChanged() const
  {
    return m_Values[plCVarValue::Current] != m_Values[plCVarValue::DelayedSync];
  }
 
private:
  friend class plCVar;
 
  Type m_Values[plCVarValue::ENUM_COUNT];
};
 
using plCVarFloat = plTypedCVar<float, plCVarType::Float>;
 
using plCVarBool = plTypedCVar<bool, plCVarType::Bool>;
 
using plCVarInt = plTypedCVar<int, plCVarType::Int>;
 
using plCVarString = plTypedCVar<plHybridString<32>, plCVarType::String>;
 
 
 
#include <Foundation/Configuration/Implementation/CVar_inl.h>