athena/include/athena/YAMLDocReader.hpp

#pragma once

#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>

#include "athena/Types.hpp"
#include "athena/YAMLCommon.hpp"

namespace athena::io {

class YAMLDocReader {
  std::unique_ptr<YAMLNode> m_rootNode;
  std::vector<YAMLNode*> m_subStack;
  std::vector<int> m_seqTrackerStack;
  yaml_parser_t m_parser;
  std::unique_ptr<YAMLNode> ParseEvents(athena::io::IStreamReader* reader);
  void _leaveSubRecord();
  void _leaveSubVector();

public:
  YAMLDocReader();
  ~YAMLDocReader();

  void reset();

  yaml_parser_t* getParser() { return &m_parser; }

  bool parse(athena::io::IStreamReader* reader);

  bool ClassTypeOperation(std::function<bool(const char* dnaType)> func);
  bool ValidateClassType(const char* expectedType);

  const YAMLNode* getRootNode() const { return m_rootNode.get(); }
  const YAMLNode* getCurNode() const { return m_subStack.empty() ? nullptr : m_subStack.back(); }
  std::unique_ptr<YAMLNode> releaseRootNode() { return std::move(m_rootNode); }

  class RecordRAII {
    friend class YAMLDocReader;
    YAMLDocReader* m_r = nullptr;
    explicit RecordRAII(YAMLDocReader* r) : m_r(r) {}
    RecordRAII() = default;

  public:
    operator bool() const { return m_r != nullptr; }
    void leave() {
      if (m_r) {
        m_r->_leaveSubRecord();
        m_r = nullptr;
      }
    }
    ~RecordRAII() {
      if (m_r)
        m_r->_leaveSubRecord();
    }
  };
  friend class RecordRAII;

  RecordRAII enterSubRecord(const char* name);

  template <class T>
  void enumerate(const char* name, T& record, std::enable_if_t<__IsDNARecord_v<T>>* = nullptr) {
    if (auto rec = enterSubRecord(name))
      record.read(*this);
  }

  class VectorRAII {
    friend class YAMLDocReader;
    YAMLDocReader* m_r = nullptr;
    explicit VectorRAII(YAMLDocReader* r) : m_r(r) {}
    VectorRAII() = default;

  public:
    explicit operator bool() const { return m_r != nullptr; }
    ~VectorRAII() {
      if (m_r)
        m_r->_leaveSubVector();
    }
  };
  friend class VectorRAII;

  VectorRAII enterSubVector(const char* name, size_t& countOut);

  template <class T>
  size_t enumerate(const char* name, std::vector<T>& vector,
                   std::enable_if_t<!std::is_arithmetic_v<T> && !std::is_same_v<T, atVec2f> &&
                                    !std::is_same_v<T, atVec3f> && !std::is_same_v<T, atVec4f>>* = nullptr) {
    size_t countOut;
    if (auto v = enterSubVector(name, countOut)) {
      vector.clear();
      vector.reserve(countOut);
      for (size_t i = 0; i < countOut; ++i) {
        vector.emplace_back();
        if (auto rec = enterSubRecord(nullptr))
          vector.back().read(*this);
      }
    }
    return countOut;
  }

  template <class T>
  size_t enumerate(const char* name, std::vector<T>& vector,
                   std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, atVec2f> ||
                                    std::is_same_v<T, atVec3f> || std::is_same_v<T, atVec4f>>* = nullptr) {
    size_t countOut;
    if (auto v = enterSubVector(name, countOut)) {
      vector.clear();
      vector.reserve(countOut);
      for (size_t i = 0; i < countOut; ++i)
        vector.push_back(readVal<T>(name));
    }
    return countOut;
  }

  template <class T>
  size_t enumerate(const char* name, std::vector<T>& vector, std::function<void(YAMLDocReader&, T&)> readf) {
    size_t countOut;
    if (auto v = enterSubVector(name, countOut)) {
      vector.clear();
      vector.reserve(countOut);
      for (size_t i = 0; i < countOut; ++i) {
        vector.emplace_back();
        if (auto rec = enterSubRecord(nullptr))
          readf(*this, vector.back());
      }
    }
    return countOut;
  }

  bool hasVal(const char* name) const {
    if (m_subStack.size()) {
      const YAMLNode* mnode = m_subStack.back();
      if (mnode->m_type == YAML_MAPPING_NODE && name)
        for (const auto& item : mnode->m_mapChildren)
          if (!item.first.compare(name))
            return true;
    }
    return false;
  }

  template <typename RETURNTYPE>
  RETURNTYPE readVal(const char* name);
  bool readBool(const char* name);
  atInt8 readByte(const char* name);
  atUint8 readUByte(const char* name);
  atInt16 readInt16(const char* name);
  atUint16 readUint16(const char* name);
  atInt32 readInt32(const char* name);
  atUint32 readUint32(const char* name);
  atInt64 readInt64(const char* name);
  atUint64 readUint64(const char* name);
  float readFloat(const char* name);
  double readDouble(const char* name);
  atVec2f readVec2f(const char* name);
  atVec3f readVec3f(const char* name);
  atVec4f readVec4f(const char* name);
  atVec2d readVec2d(const char* name);
  atVec3d readVec3d(const char* name);
  atVec4d readVec4d(const char* name);
  std::unique_ptr<atUint8[]> readUBytes(const char* name);
  std::string readString(const char* name);
  std::wstring readWString(const char* name);
};

} // namespace athena::io