cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_delayed_merge_object.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <hocon/config_object.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/replaceable_merge_stack.hpp>
+#include <internal/values/config_delayed_merge.hpp>
+
+namespace hocon {
+
+    class config_delayed_merge_object : public config_object, public replaceable_merge_stack {
+    public:
+        config_delayed_merge_object(shared_origin origin, std::vector<shared_value> const& stack);
+
+        shared_value make_replacement(resolve_context const& context, int skipping) const override;
+
+        shared_object with_value(path raw_path, shared_value value) const override;
+        shared_object with_value(std::string key, shared_value value) const override;
+
+        resolve_status get_resolve_status() const override { return resolve_status::UNRESOLVED; }
+
+        std::vector<std::string> key_set() const override { throw not_resolved(); }
+
+        // map interface
+        bool is_empty() const override { throw not_resolved(); }
+        size_t size() const override { throw not_resolved(); }
+        shared_value operator[](std::string const& key) const override { throw not_resolved(); }
+        shared_value get(std::string const& key) const override { throw not_resolved(); }
+        iterator begin() const override { throw not_resolved(); }
+        iterator end() const override { throw not_resolved(); }
+        unwrapped_value unwrapped() const override;
+
+        bool operator==(config_value const& other) const override;
+
+        // container interface
+        shared_value replace_child(shared_value const& child, shared_value replacement) const override;
+        bool has_descendant(shared_value const& descendant) const override;
+
+
+    protected:
+        shared_value attempt_peek_with_partial_resolve(std::string const& key) const override;
+        std::unordered_map<std::string, shared_value> const& entry_set() const override;
+        shared_object without_path(path raw_path) const override;
+        shared_object with_only_path(path raw_path) const override;
+        shared_object with_only_path_or_null(path raw_path) const override;
+        shared_object new_copy(resolve_status const& status, shared_origin origin) const override;
+        bool ignores_fallbacks() const override;
+        virtual void render(std::string& result, int indent, bool at_root, std::string const& at_key, config_render_options options) const override;
+        virtual void render(std::string& result, int indent, bool at_root, config_render_options options) const override;
+
+    private:
+        not_resolved_exception not_resolved() const;
+
+        const std::vector<shared_value> _stack;
+    };
+
+}  // namespace hocon::config_delayed_merge_object
+

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_double.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "config_number.hpp"
+#include <internal/simple_config_origin.hpp>
+
+#include <string>
+
+namespace hocon {
+
+    class config_double : public config_number {
+    public:
+        config_double(shared_origin origin, double value, std::string original_text);
+
+        std::string transform_to_string() const override;
+
+        unwrapped_value unwrapped() const override;
+
+        int64_t long_value() const override;
+        double double_value() const override;
+
+    protected:
+        shared_value new_copy(shared_origin) const override;
+
+    private:
+        double _value;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_int.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "config_number.hpp"
+
+namespace hocon {
+
+    class config_int : public config_number {
+    public:
+        config_int(shared_origin origin, int value, std::string original_text);
+
+        std::string transform_to_string() const override;
+
+        unwrapped_value unwrapped() const override;
+
+        int64_t long_value() const override;
+        double double_value() const override;
+
+    protected:
+        shared_value new_copy(shared_origin) const override;
+
+    private:
+        int _value;
+    };
+
+}

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_long.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "config_number.hpp"
+#include <internal/simple_config_origin.hpp>
+
+#include <string>
+
+namespace hocon {
+
+    class config_long : public config_number {
+    public:
+        config_long(shared_origin origin, int64_t value, std::string original_text);
+
+        std::string transform_to_string() const override;
+
+        unwrapped_value unwrapped() const override;
+
+        int64_t long_value() const override;
+        double double_value() const override;
+
+    protected:
+        shared_value new_copy(shared_origin) const override;
+
+    private:
+        int64_t _value;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_null.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <internal/simple_config_origin.hpp>
+
+#include <string>
+
+namespace hocon {
+
+    /**
+     * This exists because sometimes null is not the same as missing. Specifically,
+     * if a value is set to null we can give a better error message (indicating
+     * where it was set to null) in case someone asks for the value. Also, null
+     * overrides values set "earlier" in the search path, while missing values do
+     * not.
+     */
+    class config_null : public config_value {
+    public:
+        config_null(shared_origin origin);
+
+        config_value::type value_type() const override;
+        std::string transform_to_string() const override;
+
+        unwrapped_value unwrapped() const override;
+
+        bool operator==(config_value const& other) const override;
+
+    protected:
+        shared_value new_copy(shared_origin) const override;
+        void render(std::string& result, int indent, bool at_root, config_render_options options) const override;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_number.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <internal/simple_config_origin.hpp>
+
+#include <string>
+
+namespace hocon {
+
+    class config_number : public config_value {
+    public:
+        config_number(shared_origin origin,
+                      std::string original_text);
+
+        std::string transform_to_string() const override;
+        config_value::type value_type() const override;
+
+        virtual int64_t long_value() const = 0;
+        virtual double double_value() const = 0;
+        bool is_whole() const;
+
+        bool operator==(const config_number &other) const;
+        bool operator!=(const config_number &other) const;
+        bool operator==(config_value const& other) const override;
+
+        int int_value_range_checked(std::string const& path) const;
+
+        static std::shared_ptr<config_number> new_number(
+                shared_origin origin, int64_t value, std::string original_text);
+
+        static std::shared_ptr<config_number> new_number(
+                shared_origin origin, double value, std::string original_text);
+
+    protected:
+        std::string _original_text;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_reference.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <internal/unmergeable.hpp>
+
+namespace hocon {
+
+    class substitution_expression;
+
+    class config_reference : public config_value, public unmergeable {
+    public:
+        config_reference(shared_origin origin, std::shared_ptr<substitution_expression> expr, int prefix_length = 0);
+
+        /**
+        * The type of the value; matches the JSON type schema.
+        *
+        * @return value's type
+        */
+        type value_type() const override;
+        std::vector<shared_value> unmerged_values() const override;
+        resolve_status get_resolve_status() const override;
+        unwrapped_value unwrapped() const override;
+
+        std::shared_ptr<substitution_expression> expression() const;
+
+        bool operator==(config_value const& other) const override;
+
+    protected:
+        shared_value new_copy(shared_origin origin) const override;
+        resolve_result<shared_value> resolve_substitutions(resolve_context const& context, resolve_source const& source) const override;
+        bool ignores_fallbacks() const override { return false; }
+        void render(std::string& s, int indent, bool at_root, config_render_options options) const override;
+
+    private:
+        std::shared_ptr<substitution_expression> _expr;
+        int _prefix_length;
+    };
+}

data/ext/facter/cpp-hocon/lib/inc/internal/values/config_string.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <internal/config_util.hpp>
+
+namespace hocon {
+
+    enum class config_string_type { QUOTED, UNQUOTED };
+
+    class config_string : public config_value {
+    public:
+        config_string(shared_origin origin, std::string text, config_string_type quoted);
+
+        config_value::type value_type() const override;
+        std::string transform_to_string() const override;
+
+        unwrapped_value unwrapped() const override;
+
+        bool was_quoted() const;
+        bool operator==(config_value const& other) const override;
+
+    protected:
+        shared_value new_copy(shared_origin) const override;
+
+        void render(std::string& s, int indent, bool at_root, config_render_options options) const override;
+
+    private:
+        std::string _text;
+        config_string_type _quoted;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/simple_config_list.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <hocon/config_list.hpp>
+#include <hocon/config_render_options.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/container.hpp>
+#include <algorithm>
+#include <memory>
+#include <vector>
+#include <boost/optional.hpp>
+
+namespace hocon {
+
+    class simple_config_list : public config_list, public container {
+    public:
+        simple_config_list(shared_origin origin, std::vector<shared_value> value);
+        simple_config_list(shared_origin origin, std::vector<shared_value> value, resolve_status status);
+
+        config_value::type value_type() const override { return config_value::type::LIST; }
+        resolve_status get_resolve_status() const override { return _resolved; }
+
+        shared_value replace_child(shared_value const& child, shared_value replacement) const override;
+        bool has_descendant(shared_value const& descendant) const override;
+
+        shared_value relativized(const std::string prefix) const override;
+
+        bool contains(shared_value v) const { return std::find(_value.begin(), _value.end(), v) != _value.end(); }
+        bool contains_all(std::vector<shared_value>) const;
+
+        int index_of(shared_value v) {
+            auto pos = find(_value.begin(), _value.end(), v);
+            if (pos == _value.end()) {
+                return -1;
+            } else {
+                return pos - _value.begin();
+            }
+        }
+
+        // list interface
+        bool is_empty() const override { return _value.empty(); }
+        size_t size() const override { return _value.size(); }
+        shared_value operator[](size_t index) const override { return _value.at(index); }
+        shared_value get(size_t index) const override { return _value.at(index); }
+        iterator begin() const override { return _value.begin(); }
+        iterator end() const override { return _value.end(); }
+
+        std::shared_ptr<const simple_config_list> concatenate(std::shared_ptr<const simple_config_list> other) const;
+
+        unwrapped_value unwrapped() const override;
+
+        bool operator==(config_value const& other) const override;
+
+    protected:
+        resolve_result<shared_value>
+            resolve_substitutions(resolve_context const& context, resolve_source const& source) const override;
+        shared_value new_copy(shared_origin origin) const override;
+
+        void render(std::string& result, int indent, bool at_root, config_render_options options) const override;
+
+    private:
+        static const long _serial_version_UID = 2L;
+        const std::vector<shared_value> _value;
+        const resolve_status _resolved;
+
+        std::shared_ptr<const simple_config_list>
+        modify(no_exceptions_modifier& modifier, boost::optional<resolve_status> new_resolve_status) const;
+
+        std::shared_ptr<const simple_config_list>
+        modify_may_throw(modifier& modifier, boost::optional<resolve_status> new_resolve_status) const;
+
+        struct resolve_modifier;
+    };
+
+}   // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/values/simple_config_object.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <internal/container.hpp>
+#include <hocon/config_object.hpp>
+#include <hocon/config_value.hpp>
+#include <hocon/config.hpp>
+#include <unordered_map>
+
+namespace hocon {
+
+    class simple_config_object : public config_object, public container {
+    public:
+        simple_config_object(shared_origin origin, std::unordered_map<std::string, shared_value> value,
+                             resolve_status status, bool ignores_fallbacks);
+
+        simple_config_object(shared_origin origin, std::unordered_map<std::string, shared_value> value);
+
+        shared_value attempt_peek_with_partial_resolve(std::string const& key) const override;
+
+        // map interface
+        bool is_empty() const override { return _value.empty(); }
+        size_t size() const override { return _value.size(); }
+        shared_value operator[](std::string const& key) const override { return _value.at(key); }
+        iterator begin() const override { return _value.begin(); }
+        iterator end() const override { return _value.end(); }
+        unwrapped_value unwrapped() const override;
+
+        shared_value get(std::string const& key) const override {
+            if (_value.find(key) == _value.end()) {
+                return nullptr;
+            }
+            return _value.at(key);
+        }
+
+        std::unordered_map<std::string, shared_value> const& entry_set() const override;
+
+        resolve_status get_resolve_status() const override { return _resolved; }
+        bool ignores_fallbacks() const override { return _ignores_fallbacks; }
+        shared_value with_fallbacks_ignored() const override;
+        shared_value merged_with_object(shared_object fallback) const override;
+
+        shared_object with_value(path raw_path, shared_value value) const override;
+        shared_object with_value(std::string key, shared_value value) const override;
+        shared_object without_path(path raw_path) const override;
+        shared_object with_only_path(path raw_path) const override;
+
+        /**
+         * Gets the object with only the path if the path
+         * exists, otherwise null if it doesn't. this ensures
+         * that if we have { a : { b : 42 } } and do
+         * withOnlyPath("a.b.c") that we don't keep an empty
+         * "a" object.
+         */
+        shared_object with_only_path_or_null(path raw_path) const override;
+
+        /**
+         * Replace a child of this value. CAUTION if replacement is null, delete the
+         * child, which may also delete the parent, or make the parent into a
+         * non-container.
+         */
+        shared_value replace_child(shared_value const& child, shared_value replacement) const override;
+
+        /**
+         * Super-expensive full traversal to see if descendant is anywhere
+         * underneath this container.
+         */
+        bool has_descendant(shared_value const& descendant) const override;
+
+        /**
+         * Construct a list of keys in the _value map.
+         * Use a vector rather than set, because most of the time we just want to iterate over them.
+         */
+        std::vector<std::string> key_set() const override;
+
+        /**
+         * Construct a list of the values from the provided map.
+         * Equivalent to Java's Collection.values() method.
+         */
+        std::vector<shared_value> value_set(std::unordered_map<std::string, shared_value> m) const;
+
+        bool operator==(config_value const& other) const override;
+
+        static std::shared_ptr<simple_config_object> empty();
+        static std::shared_ptr<simple_config_object> empty(shared_origin origin);
+        static std::shared_ptr<simple_config_object> empty_instance();
+
+    protected:
+        resolve_result<shared_value>
+            resolve_substitutions(resolve_context const& context, resolve_source const& source) const override;
+        shared_value new_copy(shared_origin) const override;
+        void render(std::string& s, int indent, bool at_root, config_render_options options) const override;
+
+    private:
+        std::unordered_map<std::string, shared_value> _value;
+        resolve_status _resolved;
+        bool _ignores_fallbacks;
+
+        shared_object new_copy(resolve_status const& new_status, shared_origin new_origin) const override;
+        std::shared_ptr<simple_config_object> modify(no_exceptions_modifier& modifier) const;
+        std::shared_ptr<simple_config_object> modify_may_throw(modifier& modifier) const;
+
+        static resolve_status resolve_status_from_value(const std::unordered_map<std::string, shared_value>& value);
+
+        struct resolve_modifier;
+    };
+
+}  // namespace hocon