Parsing.h

#pragma once
 
#include "Base.h"
#include "Flags.h"
#include "Utilities/Strings.h"
#include "ValueVariant.h"
 
#include "Rendering/DataFormat.h"
 
#include "Foundation/StringView.h"
#include "Foundation/Reflection/TypeDatabase.h"
 
#include <glm/glm.hpp>
 
#include <vector>
 
 
namespace Cogs::Core
{
  extern const size_t ParsedDataTypeSizes[];
  extern const char * ParsedDataTypeNames[];
 
  enum struct ParsedValueTextureFlags
  {
    None            = 0,
    LinearSampler   = 1<<0, // Use linear sampler instead of point sampling.
    DepthTexture    = 1<<1, 
  };
  ENABLE_ENUM_FLAGS(ParsedValueTextureFlags);
 
  enum struct ParsedValueBufferFlags
  {
    None = 0,
    Structured = 1 << 0, 
  };
  ENABLE_ENUM_FLAGS(ParsedValueBufferFlags);
 
  struct COGSCORE_DLL_API ParsedValue
  {
    ParsedValue() {};
    ParsedValue(const ParsedValue & other);
    ParsedValue(ParsedValue && other) noexcept;
    ParsedValue & operator=(const ParsedValue & other);
 
    std::string key;
 
    std::string value;
 
    ParsedDataType type = ParsedDataType::Unknown;
    size_t valueHash = 0;
 
    size_t dimension = static_cast<size_t>(-1);
 
    public:
    union
    {
      float floatValue;
      glm::vec2 float2Value;
      glm::vec3 float3Value;
      glm::vec4 float4Value;
      glm::mat4 float4x4Value;
      int intValue;
      glm::ivec2 int2Value;
      glm::ivec3 int3Value;
      glm::ivec4 int4Value;
      uint32_t uintValue;
      glm::uvec2 uint2Value;
      glm::uvec3 uint3Value;
      glm::uvec4 uint4Value;
      double doubleValue;
      bool boolValue;
      struct {
        ParsedValueTextureFlags flags;
        ParsedDataType dataType;
        int samples;
      } texture;
      struct {
        ParsedValueBufferFlags flags;
        ParsedDataType dataType;
      } buffer;
 
      float _fill[16] = { 0.f };
    };
    std::vector<std::pair<size_t, std::string>> expressions;
 
    std::vector<ParsedValue> values;
 
    public:
      bool asBool(bool& rv, bool complain = true) const;
      bool asFloat(float& rv, bool complain = true) const;
      bool asInt(int& rv, bool complain = true) const;
  };
 
  using TokenStream = std::vector<StringView>;
 
  bool matchChars(const char c, const StringView & chars);
 
  void COGSCORE_DLL_API split(const StringView & str, const StringView & splits, TokenStream & tokens);
  void COGSCORE_DLL_API split(const StringView & str, const StringView & splits, const int grouper, TokenStream & tokens);
  TokenStream COGSCORE_DLL_API split(const StringView & str, const StringView & splits);
 
  TokenStream tokenize(const StringView & valueStr);
  void tokenize(const StringView & valueStr, TokenStream & tokens);
 
  void COGSCORE_DLL_API parseStringValue(const StringView & value, ParsedValue & v);
 
  Cogs::TextureFormat COGSCORE_DLL_API parseTextureFormat(const StringView & str, Cogs::TextureFormat defaultFormat = TextureFormat::R8G8B8A8_UNORM_SRGB);
 
  double parseDouble(const StringView & token, double defaultValue = 0);
  float parseFloat(const StringView & token, float defaultValue = 0);
  int32_t parseInt(const StringView & token, int32_t defaultValue = 0);
  uint32_t parseUInt(const StringView & token, uint32_t defaultValue = 0);
  bool parseBool(const StringView & token, bool defaultValue = false);
 
  // Underscore postfix is to avoid name-resolution failure in a template.
  bool parseBool_(bool& rv, const StringView& token);
 
  // Underscore postfix is to avoid name-resolution failure in a template.
  bool parseInt_(int32_t& rv, const StringView& token);
 
  uint64_t COGSCORE_DLL_API parseISO8601(const StringView& iso8601);
  uint64_t COGSCORE_DLL_API parseISO8601(const StringView& iso8601, int& tzOffset);
 
  int COGSCORE_DLL_API parseEnum(const StringView & token, const Reflection::Type & type, int defaultValue);
  int COGSCORE_DLL_API parseEnumFlags(const StringView & token, const Reflection::Type & type, int defaultValue);
 
  template<typename T>
  T parseEnum(const StringView & token, T defaultValue = T())
  {
    return static_cast<T>(parseEnum(token, Reflection::TypeDatabase::getType<T>(), static_cast<int>(defaultValue)));
  }
 
  template<typename T>
  T parseEnumFlags(const StringView & token, T defaultValue = T())
  {
    return static_cast<T>(parseEnumFlags(token, Reflection::TypeDatabase::getType<T>(), static_cast<int>(defaultValue)));
  }
 
  void parseQueryString(std::vector<ParsedValue>& attributes, StringView query);
 
    void parseValues(float * values, const TokenStream & tokens, size_t expected);
    void parseValues(double * values, const TokenStream & tokens, size_t expected);
    void parseValues(int * values, const TokenStream & tokens, size_t expected);
    void parseValues(uint32_t * values, const TokenStream & tokens, size_t expected);
    void parseValues(bool* values, const TokenStream & tokens, size_t expected);
 
    void parseValues(std::vector<std::pair<size_t, std::string>>& expressions, float * values, const TokenStream & tokens, size_t expected);
    void parseValues(std::vector<std::pair<size_t, std::string>>& expressions, double * values, const TokenStream & tokens, size_t expected);
    void parseValues(std::vector<std::pair<size_t, std::string>>& expressions, int * values, const TokenStream & tokens, size_t expected);
    void parseValues(std::vector<std::pair<size_t, std::string>>& expressions, uint32_t * values, const TokenStream & tokens, size_t expected);
    void parseValues(std::vector<std::pair<size_t, std::string>>& expressions, bool* values, const TokenStream & tokens, size_t expected);
}