config.hpp

#pragma once
 
#include "types.hpp"
#include "config_mergeable.hpp"
#include "config_origin.hpp"
#include "config_object.hpp"
#include "config_resolve_options.hpp"
#include "config_value.hpp"
#include "config_list.hpp"
#include "config_exception.hpp"
#include "path.hpp"
#include <vector>
#include <string>
#include <set>
#include "export.h"
#include <leatherman/locale/locale.hpp>
 
namespace hocon {
 
    enum class time_unit { NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS };
 
    class LIBCPP_HOCON_EXPORT config : public config_mergeable, public std::enable_shared_from_this<config> {
        friend class config_object;
        friend class config_value;
        friend class config_parseable;
        friend class parseable;
 
    public:
        static shared_config parse_file_any_syntax(std::string file_basename, config_parse_options options);
 
        static shared_config parse_file_any_syntax(std::string file_basename);
 
        static shared_config parse_string(std::string s, config_parse_options options);
 
        static shared_config parse_string(std::string s);
 
        virtual shared_object root() const;
 
        virtual shared_origin origin() const;
 
        std::shared_ptr<const config_mergeable> with_fallback(std::shared_ptr<const config_mergeable> other) const override;
 
        shared_value to_fallback_value() const override;
 
        virtual shared_config resolve() const;
 
        virtual shared_config resolve(config_resolve_options options) const;
 
        virtual bool is_resolved() const;
 
        virtual shared_config resolve_with(shared_config source) const;
 
        virtual shared_config resolve_with(shared_config source, config_resolve_options options) const;
 
        virtual void check_valid(shared_config reference, std::vector<std::string> restrict_to_paths) const;
 
        virtual bool has_path(std::string const& path) const;
 
        virtual bool has_path_or_null(std::string const& path) const;
 
        virtual bool is_empty() const;
 
        virtual std::set<std::pair<std::string, std::shared_ptr<const config_value>>> entry_set() const;
 
        virtual bool get_is_null(std::string const& path) const;
 
        virtual bool get_bool(std::string const& path) const;
        virtual int get_int(std::string const& path) const;
        virtual int64_t get_long(std::string const& path) const;
        virtual double get_double(std::string const& path) const;
        virtual std::string get_string(std::string const& path) const;
        virtual std::shared_ptr<const config_object> get_object(std::string const& path) const;
        virtual shared_config get_config(std::string const& path) const;
        virtual unwrapped_value get_any_ref(std::string const& path) const;
        virtual std::shared_ptr<const config_value> get_value(std::string const& path) const;
 
        template<typename T>
        std::vector<T> get_homogeneous_unwrapped_list(std::string const& path) const {
            auto list = boost::get<std::vector<unwrapped_value>>(get_list(path)->unwrapped());
            std::vector<T> T_list;
            for (auto item : list) {
                try {
                    T_list.push_back(boost::get<T>(item));
                } catch (boost::bad_get &ex) {
                    throw config_exception(leatherman::locale::format("The list did not contain only the desired type."));
                }
            }
            return T_list;
        }
 
        virtual shared_list get_list(std::string const& path) const;
        virtual std::vector<bool> get_bool_list(std::string const& path) const;
        virtual std::vector<int> get_int_list(std::string const& path) const;
        virtual std::vector<int64_t> get_long_list(std::string const& path) const;
        virtual std::vector<double> get_double_list(std::string const& path) const;
        virtual std::vector<std::string> get_string_list(std::string const& path) const;
        virtual std::vector<shared_object> get_object_list(std::string const& path) const;
        virtual std::vector<shared_config> get_config_list(std::string const& path) const;
 
        // TODO: memory parsing
 
        virtual int64_t get_duration(std::string const& path, time_unit unit) const;
 
        virtual shared_config with_only_path(std::string const& path) const;
 
        virtual shared_config without_path(std::string const& path) const;
 
        virtual shared_config at_path(std::string const& path) const;
 
        virtual shared_config at_key(std::string const& key) const;
 
        virtual shared_config with_value(std::string const& path, std::shared_ptr<const config_value> value) const;
 
        bool operator==(config const& other) const;
 
        config(shared_object object);
 
        static shared_object env_variables_as_config_object();
 
    protected:
        shared_value find(std::string const& path_expression, config_value::type expected) const;
        shared_value find(path path_expression, config_value::type expected, path original_path) const;
        shared_value find(path path_expression, config_value::type expected) const;
        shared_config at_key(shared_origin origin, std::string const& key) const;
 
        static shared_includer default_includer();
 
        // TODO: memory and duration parsing
 
    private:
        static duration parse_duration(std::string input, shared_origin origin_for_exception, std::string path_for_exception);
 
        static duration convert(int64_t number, time_unit units);
        static duration convert(double number, time_unit units);
        static time_unit get_units(std::string const& unit_string);
        duration get_duration(std::string const& path) const;
 
        shared_value has_path_peek(std::string const& path_expression) const;
        shared_value peek_path(path desired_path) const;
 
        static void find_paths(std::set<std::pair<std::string, std::shared_ptr<const config_value>>>& entries,
                               path parent, shared_object obj);
        static shared_value throw_if_null(shared_value v, config_value::type expected, path original_path);
        static shared_value find_key(shared_object self, std::string const& key,
                                     config_value::type expected, path original_path);
        static shared_value find_key_or_null(shared_object self, std::string const& key,
                                             config_value::type expected, path original_path);
        static shared_value find_or_null(shared_object self, path desired_path,
                                         config_value::type expected, path original_path);
        shared_value find_or_null(std::string const& path_expression, config_value::type expected) const;
        shared_value find_or_null(path path_expression, config_value::type expected, path original_path) const;
 
        shared_object _object;
    };
 
    template<>
    std::vector<int64_t> config::get_homogeneous_unwrapped_list(std::string const& path) const;
 
}  // namespace hocon