Console.h

#pragma once
 
#include <Core/Console/ConsoleFunction.h>
#include <Foundation/Communication/Event.h>
#include <Foundation/Configuration/CVar.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Containers/StaticArray.h>
#include <Foundation/Strings/StringBuilder.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Types/RefCounted.h>
#include <Foundation/Types/SharedPtr.h>
 
struct PL_CORE_DLL plConsoleString
{
  enum class Type : plUInt8
  {
    Default,
    Error,
    SeriousWarning,
    Warning,
    Note,
    Success,
    Executed,
    VarName,
    FuncName,
    Dev,
    Debug,
  };
 
  Type m_Type = Type::Default;
  plString m_sText;
  plColor GetColor() const;
 
  bool operator<(const plConsoleString& rhs) const { return m_sText < rhs.m_sText; }
};
 
struct PL_CORE_DLL plCommandInterpreterState
{
  plStringBuilder m_sInput;
  plHybridArray<plConsoleString, 16> m_sOutput;
 
  void AddOutputLine(const plFormatString& text, plConsoleString::Type type = plConsoleString::Type::Default);
};
 
class PL_CORE_DLL plCommandInterpreter : public plRefCounted
{
public:
  virtual void Interpret(plCommandInterpreterState& inout_state) = 0;
 
  virtual void AutoComplete(plCommandInterpreterState& inout_state);
 
  static void FindPossibleCVars(plStringView sVariable, plDeque<plString>& ref_commonStrings, plDeque<plConsoleString>& ref_consoleStrings);
 
  static void FindPossibleFunctions(plStringView sVariable, plDeque<plString>& ref_commonStrings, plDeque<plConsoleString>& ref_consoleStrings);
 
  static const plString FindCommonString(const plDeque<plString>& strings);
};
 
struct plConsoleEvent
{
  enum class Type : plInt32
  {
    OutputLineAdded, 
  };
 
  Type m_Type;
 
  const plConsoleString* m_AddedpConsoleString;
};
 
class PL_CORE_DLL plConsole
{
public:
  plConsole();
  virtual ~plConsole();
 
 
public:
  const plEvent<const plConsoleEvent&>& Events() const { return m_Events; }
 
protected:
  plEvent<const plConsoleEvent&> m_Events;
 
 
 
public:
  plMutex& GetMutex() const { return m_Mutex; }
 
  static void SetMainConsole(plConsole* pConsole);
  static plConsole* GetMainConsole();
 
protected:
  mutable plMutex m_Mutex;
 
private:
  static plConsole* s_pMainConsole;
 
 
 
public:
  void SetCommandInterpreter(const plSharedPtr<plCommandInterpreter>& pInterpreter) { m_pCommandInterpreter = pInterpreter; }
 
  const plSharedPtr<plCommandInterpreter>& GetCommandInterpreter() const { return m_pCommandInterpreter; }
 
  virtual bool AutoComplete(plStringBuilder& ref_sText);
 
  virtual void ExecuteCommand(plStringView sInput);
 
protected:
  plSharedPtr<plCommandInterpreter> m_pCommandInterpreter;
 
 
 
public:
  virtual void AddConsoleString(plStringView sText, plConsoleString::Type type = plConsoleString::Type::Default);
 
 
 
public:
  void AddToInputHistory(plStringView sText);
 
  const plStaticArray<plString, 16>& GetInputHistory() const { return m_InputHistory; }
 
  void RetrieveInputHistory(plInt32 iHistoryUp, plStringBuilder& ref_sResult);
 
  plResult SaveInputHistory(plStringView sFile);
 
  void LoadInputHistory(plStringView sFile);
 
protected:
  plInt32 m_iCurrentInputHistoryElement = -1;
  plStaticArray<plString, 16> m_InputHistory;
 
};