ConfigParser.h

Go to the documentation of this file.

// Copyright (c) XJ Music Inc. (https://xjmusic.com) All Rights Reserved.
 
#ifndef XJMUSIC_CONFIG_PARSER_H
#define XJMUSIC_CONFIG_PARSER_H
 
#include <map>
#include <set>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
namespace XJ {
 
  class ConfigValue {
  public:
    virtual ~ConfigValue() = default;
  };
 
  class ConfigSingleValue final : public ConfigValue {
    std::variant<std::string, int, float, bool> value;
 
  public:
    ConfigSingleValue() = default;
 
    explicit ConfigSingleValue(const std::variant<std::string, int, float, bool> &value);
 
    [[nodiscard]] std::string getString() const;
 
    [[nodiscard]] float getFloat() const;
 
    [[nodiscard]] int getInt() const;
 
    bool getBool() const;
 
    bool operator==(const ConfigSingleValue &other) const;
 
    bool operator!=(const ConfigSingleValue &other) const;
  };
 
  class ConfigObjectValue final : public ConfigValue {
    std::map<std::string, std::variant<ConfigSingleValue, std::vector<ConfigSingleValue>>> data;
 
  public:
    unsigned long size() const;
 
    ConfigSingleValue atSingle(const std::string &index);
 
    std::vector<ConfigSingleValue> atList(const std::string &index);
 
    void set(const std::string &key, const std::variant<ConfigSingleValue, std::vector<ConfigSingleValue>> &value);
 
    std::map<std::string, std::variant<ConfigSingleValue, std::vector<ConfigSingleValue>>> asMapOfSingleOrList();
 
    std::map<std::string, std::variant<std::string, std::vector<std::string>>> asMapOfStringsOrListsOfStrings() const;
 
    bool operator==(const ConfigObjectValue &other) const;
 
    bool operator!=(const ConfigObjectValue &other) const;
  };
 
  class ConfigListValue final : public ConfigValue {
    std::vector<std::variant<ConfigSingleValue, ConfigObjectValue>> data;
 
  public:
    unsigned long size() const;
 
    [[nodiscard]] std::vector<std::string> asListOfStrings() const;
 
    [[nodiscard]] std::set<std::string> asSetOfStrings() const;
 
    /*
     * Get the list as a vector of maps of strings to strings
     * @return  The list as a vector of maps of strings to strings
     */
    std::vector<std::map<std::string, std::variant<std::string, std::vector<std::string>>>> asListOfMapsOfStrings();
 
    ConfigSingleValue atSingle(const unsigned long &index);
 
    ConfigObjectValue atObject(const unsigned long &index);
 
    void add(const std::variant<ConfigSingleValue, ConfigObjectValue> &value);
 
    bool operator==(const ConfigListValue &other) const;
 
    bool operator!=(const ConfigListValue &other) const;
  };
 
  class ConfigException final : public std::exception {
  private:
    std::string message;
 
  public:
    explicit ConfigException(std::string msg) : message(std::move(msg)) {}
 
    [[nodiscard]] const char *what() const noexcept override {
      return message.c_str();
    }
  };
 
  class ConfigParser {
    std::map<std::string, std::variant<ConfigSingleValue, ConfigObjectValue, ConfigListValue>> config;
 
  public:
    explicit ConfigParser(const std::string &input);
 
    ConfigParser(const std::string &input, const ConfigParser &defaults);
 
    ConfigSingleValue getSingleValue(const std::string &key);
 
    ConfigListValue getListValue(const std::string &key);
 
    ConfigObjectValue getObjectValue(const std::string &key);
 
    static std::string format(const bool &value);
 
    static std::string format(const int &value);
 
    static std::string format(const float &value);
 
    static std::string format(const std::string &value);
 
    static std::string format(const std::vector<std::string> &values);
 
    static std::string format(const std::set<std::string> &values);
 
    static std::vector<std::string> splitCsvTopLevel(const std::string& basicString);
 
    bool operator==(const ConfigParser &other) const;
 
    void operator=(const ConfigParser &other);
  };
 
}// namespace XJ
 
#endif//XJMUSIC_CONFIG_PARSER_H