config_value.hpp

 
#pragma once
 
#include "config_origin.hpp"
#include "config_render_options.hpp"
#include "config_mergeable.hpp"
#include "path.hpp"
#include <string>
#include <vector>
#include "export.h"
#include <leatherman/locale/locale.hpp>
 
namespace hocon {
 
    class unmergeable;
    class resolve_source;
    class resolve_context;
 
    template<typename T>
    struct resolve_result;
 
    enum class resolve_status { RESOLVED, UNRESOLVED };
 
    class LIBCPP_HOCON_EXPORT config_value : public config_mergeable, public std::enable_shared_from_this<config_value> {
        friend class token;
        friend class value;
        friend class default_transformer;
        friend class config;
        friend class config_object;
        friend class simple_config_object;
        friend class simple_config_list;
        friend class config_concatenation;
        friend class resolve_context;
        friend class config_delayed_merge;
        friend class config_delayed_merge_object;
    public:
        enum class type {
            OBJECT, LIST, NUMBER, BOOLEAN, CONFIG_NULL, STRING, UNSPECIFIED
        };
        static char const* type_name(type t) {
            switch (t) {
                case type::OBJECT: return "object";
                case type::LIST: return "list";
                case type::NUMBER: return "number";
                case type::BOOLEAN: return "boolean";
                case type::CONFIG_NULL: return "null";
                case type::STRING: return "string";
                case type::UNSPECIFIED: return "unspecified";
                default: throw std::logic_error(leatherman::locale::format("Got impossible value for type enum"));
            }
        }
 
        virtual shared_origin const& origin() const;
 
        virtual type value_type() const = 0;
 
        char const* value_type_name() const {
            return type_name(value_type());
        }
 
        virtual unwrapped_value unwrapped() const = 0;
 
        virtual std::string render() const;
 
        virtual std::string render(config_render_options options) const;
 
        shared_config at_key(std::string const& key) const;
 
        shared_config at_path(std::string const& path_expression) const;
 
        virtual shared_value with_origin(shared_origin origin) const;
 
        virtual shared_value relativized(std::string prefix) const { return shared_from_this(); }
 
        virtual resolve_status get_resolve_status() const;
 
        friend resolve_status resolve_status_from_values(std::vector<shared_value> const& v);
 
        std::shared_ptr<const config_mergeable> with_fallback(std::shared_ptr<const config_mergeable> other) const override;
 
        virtual bool operator==(config_value const& other) const = 0;
 
        virtual std::string transform_to_string() const;
 
    protected:
        config_value(shared_origin origin);
 
        virtual void render(std::string& result, int indent, bool at_root, std::string const& at_key, config_render_options options) const;
        virtual void render(std::string& result, int indent, bool at_root, config_render_options options) const;
        static void indent(std::string& result, int indent, config_render_options const& options);
 
        shared_config at_key(shared_origin origin, std::string const& key) const;
        shared_config at_path(shared_origin origin, path raw_path) const;
 
        virtual shared_value new_copy(shared_origin origin) const = 0;
 
        virtual resolve_result<shared_value>
            resolve_substitutions(resolve_context const& context, resolve_source const& source) const;
 
        static std::vector<shared_value> replace_child_in_list(std::vector<shared_value> const& values,
                                                               shared_value const& child, shared_value replacement);
        static bool has_descendant_in_list(std::vector<shared_value> const& values, shared_value const& descendant);
 
        class modifier {
         public:
            virtual shared_value modify_child_may_throw(std::string const& key_or_null, shared_value v) = 0;
        };
 
        class no_exceptions_modifier : public modifier {
        public:
            no_exceptions_modifier(std::string prefix);
 
            shared_value modify_child_may_throw(std::string const &key_or_null, shared_value v) override;
            shared_value modify_child(std::string const& key, shared_value v) const;
        private:
            std::string _prefix;
        };
        void require_not_ignoring_fallbacks() const;
 
        /* this is virtualized rather than a field because only some subclasses
         * really need to store the boolean, and they may be able to pack it
         * with another boolean to save space.
         */
        virtual bool ignores_fallbacks() const;
        virtual shared_value with_fallbacks_ignored() const;
 
        shared_value merged_with_the_unmergeable(std::vector<shared_value> stack,
                                                 std::shared_ptr<const unmergeable> fallback) const;
        shared_value merged_with_the_unmergeable(std::shared_ptr<const unmergeable> fallback) const;
 
        shared_value merged_with_object(std::vector<shared_value> stack, shared_object fallback) const;
        virtual shared_value merged_with_object(shared_object fallback) const;
 
        shared_value merged_with_non_object(std::vector<shared_value> stack, shared_value fallback) const;
        shared_value merged_with_non_object(shared_value fallback) const;
 
        virtual shared_value construct_delayed_merge(shared_origin origin, std::vector<shared_value> stack) const;
 
        shared_value to_fallback_value() const override;
 
        template<typename T>
        static bool equals(config_value const& other, std::function<bool(T const&)> checker)
        {
            // Use pointer casts to avoid exceptions.
            auto other_t = dynamic_cast<T const*>(&other);
            if (!other_t) {
                return false;
            }
 
            // Pass to checker as a reference to clarify the object will exist.
            return checker(*other_t);
        }
 
    private:
        shared_value delay_merge(std::vector<shared_value> stack, shared_value fallback) const;
 
        shared_origin _origin;
    };
}  // namespace hocon