OpenDdlWriter.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/IO/OpenDdlParser.h>
 
// TODO
// Write primitives in HEX (esp. float)
 
class PL_FOUNDATION_DLL plOpenDdlWriter
{
public:
  enum class TypeStringMode
  {
    Compliant,            
    ShortenedUnsignedInt, 
    Shortest              
  };
 
  enum class FloatPrecisionMode
  {
    Readable, 
    Exact,    
  };
 
  plOpenDdlWriter();
 
  virtual ~plOpenDdlWriter() = default;
 
  void SetOutputStream(plStreamWriter* pOutput) { m_pOutput = pOutput; } // [tested]
 
  void SetCompactMode(bool bCompact) { m_bCompactMode = bCompact; } // [tested]
 
  void SetPrimitiveTypeStringMode(TypeStringMode mode) { m_TypeStringMode = mode; }
 
  void SetFloatPrecisionMode(FloatPrecisionMode mode) { m_FloatPrecisionMode = mode; }
 
  FloatPrecisionMode GetFloatPrecisionMode() const { return m_FloatPrecisionMode; }
 
  void SetIndentation(plInt8 iIndentation) { m_iIndentation = iIndentation; }
 
  void BeginObject(plStringView sType, plStringView sName = {}, bool bGlobalName = false, bool bSingleLine = false); // [tested]
 
  void EndObject(); // [tested]
 
  void BeginPrimitiveList(plOpenDdlPrimitiveType type, plStringView sName = {}, bool bGlobalName = false); // [tested]
 
  void EndPrimitiveList(); // [tested]
 
  void WriteBool(const bool* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteInt8(const plInt8* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteInt16(const plInt16* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteInt32(const plInt32* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteInt64(const plInt64* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteUInt8(const plUInt8* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteUInt16(const plUInt16* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteUInt32(const plUInt32* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteUInt64(const plUInt64* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteFloat(const float* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteDouble(const double* pValues, plUInt32 uiCount = 1); // [tested]
 
  void WriteString(const plStringView& sString); // [tested]
 
  void WriteBinaryAsString(const void* pData, plUInt32 uiBytes);
 
 
protected:
  enum State
  {
    Invalid = -5,
    Empty = -4,
    ObjectSingleLine = -3,
    ObjectMultiLine = -2,
    ObjectStart = -1,
    PrimitivesBool = 0, // same values as in plOpenDdlPrimitiveType to enable casting
    PrimitivesInt8,
    PrimitivesInt16,
    PrimitivesInt32,
    PrimitivesInt64,
    PrimitivesUInt8,
    PrimitivesUInt16,
    PrimitivesUInt32,
    PrimitivesUInt64,
    PrimitivesFloat,
    PrimitivesDouble,
    PrimitivesString,
  };
 
  struct DdlState
  {
    State m_State = State::Empty;
    bool m_bPrimitivesWritten = false;
  };
 
  PL_ALWAYS_INLINE void OutputString(plStringView s) { m_pOutput->WriteBytes(s.GetStartPointer(), s.GetElementCount()).IgnoreResult(); }
  PL_ALWAYS_INLINE void OutputString(plStringView s, plUInt32 uiElementCount) { m_pOutput->WriteBytes(s.GetStartPointer(), uiElementCount).IgnoreResult(); }
  void OutputEscapedString(const plStringView& string);
  void OutputIndentation();
  void OutputPrimitiveTypeNameCompliant(plOpenDdlPrimitiveType type);
  void OutputPrimitiveTypeNameShort(plOpenDdlPrimitiveType type);
  void OutputPrimitiveTypeNameShortest(plOpenDdlPrimitiveType type);
  void WritePrimitiveType(plOpenDdlWriter::State exp);
  void OutputObjectName(plStringView sName, bool bGlobalName);
  void WriteBinaryAsHex(const void* pData, plUInt32 uiBytes);
  void OutputObjectBeginning();
 
  plInt32 m_iIndentation = 0;
  bool m_bCompactMode = false;
  TypeStringMode m_TypeStringMode = TypeStringMode::ShortenedUnsignedInt;
  FloatPrecisionMode m_FloatPrecisionMode = FloatPrecisionMode::Exact;
  plStreamWriter* m_pOutput = nullptr;
  plStringBuilder m_sTemp;
 
  plHybridArray<DdlState, 16> m_StateStack;
};