facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/cpp-hocon/lib/inc/hocon/config_syntax.hpp

@@ -1,24 +0,0 @@
-#pragma once
-
-enum class config_syntax {
-    /**
-     * Pedantically strict <a href="http://json.org">JSON</a> format; no
-     * comments, no unexpected commas, no duplicate keys in the same object.
-     * Associated with the <code>.json</code> file extension and
-     * <code>application/json</code> Content-Type.
-     */
-    JSON,
-
-    /**
-     * The JSON-superset <a
-     * href="https://github.com/typesafehub/config/blob/master/HOCON.md"
-     * >HOCON</a> format. Associated with the <code>.conf</code> file extension
-     * and <code>application/hocon</code> Content-Type.
-     */
-    CONF,
-
-    /** Used as a default */
-    UNSPECIFIED
-
-    // Original project also supported Java's .properties formats, but we do not
-};

data/ext/facter/cpp-hocon/lib/inc/hocon/config_value.hpp

@@ -1,267 +0,0 @@
-
-#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 };
-
-    /**
-     * An immutable value, following the <a href="http://json.org">JSON</a> type
-     * schema.
-     *
-     * <p>
-     * Because this object is immutable, it is safe to use from multiple threads and
-     * there's no need for "defensive copies."
-     *
-     * <p>
-     * <em>Do not implement interface {@code ConfigValue}</em>; it should only be
-     * implemented by the config library. Arbitrary implementations will not work
-     * because the library internals assume a specific concrete implementation.
-     * Also, this interface is likely to grow new methods over time, so third-party
-     * implementations will break.
-     */
-    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:
-        /**
-         * The type of a configuration value (following the <a
-         * href="http://json.org">JSON</a> type schema).
-         */
-        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"));
-            }
-        }
-
-        /**
-         * The origin of the value (file, line number, etc.), for debugging and
-         * error messages.
-         *
-         * @return where the value came from
-         */
-        virtual shared_origin const& origin() const;
-
-        /**
-         * The type of the value; matches the JSON type schema.
-         *
-         * @return value's type
-         */
-        virtual type value_type() const = 0;
-
-        /**
-         * The printable name of the value type.
-         *
-         * @return value's type's name
-         */
-        char const* value_type_name() const {
-            return type_name(value_type());
-        }
-
-        virtual unwrapped_value unwrapped() const = 0;
-
-        /**
-         * Renders the config value as a HOCON string. This method is primarily
-         * intended for debugging, so it tries to add helpful comments and
-         * whitespace.
-         *
-         * <p>
-         * If the config value has not been resolved (see {@link config#resolve}),
-         * it's possible that it can't be rendered as valid HOCON. In that case the
-         * rendering should still be useful for debugging but you might not be able
-         * to parse it. If the value has been resolved, it will always be parseable.
-         *
-         * <p>
-         * This method is equivalent to
-         * {@code render(config_render_options())}.
-         *
-         * @return the rendered value
-         */
-        virtual std::string render() const;
-
-        /**
-         * Renders the config value to a string, using the provided options.
-         *
-         * <p>
-         * If the config value has not been resolved (see {@link config#resolve}),
-         * it's possible that it can't be rendered as valid HOCON. In that case the
-         * rendering should still be useful for debugging but you might not be able
-         * to parse it. If the value has been resolved, it will always be parseable.
-         *
-         * <p>
-         * If the config value has been resolved and the options disable all
-         * HOCON-specific features (such as comments), the rendering will be valid
-         * JSON. If you enable HOCON-only features such as comments, the rendering
-         * will not be valid JSON.
-         *
-         * @param options
-         *            the rendering options
-         * @return the rendered value
-         */
-        virtual std::string render(config_render_options options) const;
-
-        /**
-         * Places the value inside a {@link config} at the given key. See also
-         * {@link config_value#at_path(string)}.
-         *
-         * @param key
-         *            key to store this value at.
-         * @return a {@code config} instance containing this value at the given key.
-         */
-        shared_config at_key(std::string const& key) const;
-
-        /**
-         * Places the value inside a {@link config} at the given path. See also
-         * {@link config_value#at_key(String)}.
-         *
-         * @param path
-         *            path to store this value at.
-         * @return a {@code config} instance containing this value at the given
-         *         path.
-         */
-        shared_config at_path(std::string const& path_expression) const;
-
-        /**
-         * Returns a {@code config_value} based on this one, but with the given
-         * origin. This is useful when you are parsing a new format of file or setting
-         * comments for a single config_value.
-         *
-         * @param origin the origin set on the returned value
-         * @return the new config_value with the given origin
-         */
-        virtual shared_value with_origin(shared_origin origin) const;
-
-        /**
-         * This is used when including one file in another; the included file is
-         * relativized to the path it's included into in the parent file. The point
-         * is that if you include a file at foo.bar in the parent, and the included
-         * file as a substitution ${a.b.c}, the included substitution now needs to
-         * be ${foo.bar.a.b.c} because we resolve substitutions globally only after
-         * parsing everything.
-         *
-         * @param prefix
-         * @return value relativized to the given path or the same value if nothing
-         *         to do
-         */
-        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

data/ext/facter/cpp-hocon/lib/inc/hocon/config_value_factory.hpp

@@ -1,48 +0,0 @@
-# pragma once
-
-#include "types.hpp"
-#include "export.h"
-#include <string>
-
-namespace hocon {
-    class LIBCPP_HOCON_EXPORT config_value_factory {
-         public:
-         /**
-          * Creates a {@link ConfigValue} from a plain value, which may be
-          * a <code>bool</code>, <code>long</code>, <code>string</code>,
-          * <code>unordered_map</code>, <code>vector</code> or <code>nullptr</code>. An
-          * <code>unordered_map</code> must be a <code>unordered_map</code> from string to more values
-          * that can be supplied to <code>from_any_ref()</code>. An <code>unordered_map</code>
-          * will become a {@link ConfigObject} and a <code>vector</code> will become a
-          * {@link ConfigList}.
-          *
-          * <p>
-          * In a <code>unordered_map</code> passed to <code>from_any_ref()</code>, the map's keys
-          * are plain keys, not path expressions. So if your <code>unordered_map</code> has a
-          * key "foo.bar" then you will get one object with a key called "foo.bar",
-          * rather than an object with a key "foo" containing another object with a
-          * key "bar".
-          *
-          * <p>
-          * The origin_description will be used to set the origin() field on the
-          * ConfigValue. It should normally be the name of the file the values came
-          * from, or something short describing the value such as "default settings".
-          * The origin_description is prefixed to error messages so users can tell
-          * where problematic values are coming from.
-          *
-          * <p>
-          * Supplying the result of ConfigValue.unwrapped() to this function is
-          * guaranteed to work and should give you back a ConfigValue that matches
-          * the one you unwrapped. The re-wrapped ConfigValue will lose some
-          * information that was present in the original such as its origin, but it
-          * will have matching values.
-          *
-          * @param unwrapped_value object
-          *         object to convert to ConfigValue
-          * @param string origin_description
-          *         name of origin file or brief description of what the value is
-          * @return shared_value a new value
-          * */
-       static shared_value from_any_ref(unwrapped_value value, std::string origin_description = "");
-    };
-}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/hocon/functional_list.hpp

@@ -1,318 +0,0 @@
-#pragma once
-
-#include <cassert>
-#include <memory>
-#include <functional>
-#include <initializer_list>
-#include <iterator>
-#include <iostream>  // print
-
-template<class T> class FwdListIter;
-
-template<class T>
-class List
-{
-    struct Item
-    {
-        Item(T v, std::shared_ptr<const Item> tail)
-                : _val(v), _next(std::move(tail))
-        {}
-        // singleton
-        explicit Item(T v) : _val(v) {}
-        // ~Item() { std::cout << "~" << _val << std::endl; }
-        T _val;
-        std::shared_ptr<const Item> _next;
-    };
-    friend Item;
-    explicit List(std::shared_ptr<const Item> items)
-            : _head(std::move(items)) {}
-public:
-    // Empty list
-    List() {}
-    // Cons
-    List(T v, List const & tail)
-            : _head(std::make_shared<Item>(v, tail._head)) {}
-    // Singleton
-    explicit List(T v) : _head(std::make_shared<Item>(v)) {}
-
-    bool isEmpty() const { return !_head; }  // conversion to bool
-    T front() const
-    {
-        assert(!isEmpty());
-        return _head->_val;
-    }
-    List popped_front() const
-    {
-        assert(!isEmpty());
-        return List(_head->_next);
-    }
-    // Additional utilities
-    List pushed_front(T v) const
-    {
-        return List(v, *this);
-    }
-    List take(int n)
-    {
-        if (n <= 0 || isEmpty()) return List();
-        return popped_front().take(n - 1).pushed_front(front());
-    }
-    List insertedAt(int i, T v) const
-    {
-        if (i == 0) {
-            return pushed_front(v);
-        } else {
-            assert(!isEmpty());
-            return List<T>(front(), popped_front().insertedAt(i - 1, v));
-        }
-    }
-    List removed(T v) const
-    {
-        if (isEmpty()) return List();
-        if (v == front())
-            return popped_front().removed(v);
-        return List(front(), popped_front().removed(v));
-    }
-    List removed1(T v) const
-    {
-        if (isEmpty()) return List();
-        if (v == front())
-            return popped_front();
-        return List(front(), popped_front().removed(v));
-    }
-    bool member(T v) const
-    {
-        if (isEmpty()) return false;
-        if (v == front()) return true;
-        return popped_front().member(v);
-    }
-    template<class F>
-    void forEach(F f) const
-    {
-        Item const * it = _head.get();
-        while (it != nullptr)
-        {
-            f(it->_val);
-            it = it->_next.get();
-        }
-    }
-
-    friend class FwdListIter<T>;
-    // For debugging
-    int headCount() const { return _head.use_count(); }
-private:
-    std::shared_ptr<const Item> _head;
-};
-
-template<class T, class P>
-bool all(List<T> const & lst, P & p)
-{
-    if (lst.isEmpty())
-        return true;
-    if (!p(lst.front()))
-        return false;
-    return all(lst.popped_front(), p);
-}
-
-template<class T>
-class FwdListIter : public std::iterator<std::forward_iterator_tag, T>
-{
-public:
-    FwdListIter() {}  // end
-    FwdListIter(List<T> const & lst) : _cur(lst._head)
-    {}
-    T operator*() const { return _cur->_val; }
-    FwdListIter & operator++()
-    {
-        _cur = _cur->_next;
-        return *this;
-    }
-    bool operator==(FwdListIter<T> const & other)
-    {
-        return _cur == other._cur;
-    }
-    bool operator!=(FwdListIter<T> const & other)
-    {
-        return !(*this == other);
-    }
-private:
-    std::shared_ptr<const typename List<T>::Item> _cur;
-};
-
-template<class T>
-class OutListIter : public std::iterator<std::output_iterator_tag, T>
-{
-public:
-    OutListIter() {}
-    T & operator*() { return _val; }
-    OutListIter & operator++()
-    {
-        _lst = List<T>(_val, _lst);
-        return *this;
-    }
-    List<T> getList() const { return _lst; }
-private:
-    T _val;
-    List<T> _lst;
-};
-
-
-namespace std
-{
-    template<class T>
-    FwdListIter<T> begin(List<T> const & lst)
-    {
-        return FwdListIter<T>(lst);
-    }
-    template<class T>
-    FwdListIter<T> end(List<T> const & lst)
-    {
-        return FwdListIter<T>();
-    }
-}
-
-template<class T>
-List<T> concat(List<T> const & a, List<T> const & b)
-{
-    if (a.isEmpty())
-        return b;
-    return List<T>(a.front(), concat(a.popped_front(), b));
-}
-
-template<class T, class F>
-auto fmap(F f, List<T> lst) -> List<decltype(f(lst.front()))>
-{
-    using U = decltype(f(lst.front()));
-    static_assert(std::is_convertible<F, std::function<U(T)>>::value,
-                  "fmap requires a function type U(T)");
-    if (lst.isEmpty())
-        return List<U>();
-    else
-        return List<U>(f(lst.front()), fmap(f, lst.popped_front()));
-}
-
-template<class T, class P>
-List<T> filter(P p, List<T> lst)
-{
-    static_assert(std::is_convertible<P, std::function<bool(T)>>::value,
-                  "filter requires a function type bool(T)");
-    if (lst.isEmpty())
-        return List<T>();
-    if (p(lst.front()))
-        return List<T>(lst.front(), filter(p, lst.popped_front()));
-    else
-        return filter(p, lst.popped_front());
-}
-
-template<class T, class U, class F>
-U foldr(F f, U acc, List<T> lst)
-{
-    static_assert(std::is_convertible<F, std::function<U(T, U)>>::value,
-                  "foldr requires a function type U(T, U)");
-    if (lst.isEmpty())
-        return acc;
-    else
-        return f(lst.front(), foldr(f, acc, lst.popped_front()));
-}
-
-template<class T, class U, class F>
-U foldl(F f, U acc, List<T> lst)
-{
-    static_assert(std::is_convertible<F, std::function<U(U, T)>>::value,
-                  "foldl requires a function type U(U, T)");
-    if (lst.isEmpty())
-        return acc;
-    else
-        return foldl(f, f(acc, lst.front()), lst.popped_front());
-}
-
-// Set difference a \ b
-template<class T>
-List<T> set_diff(List<T> const & as, List<T> const & bs)
-{
-    return foldl([](List<T> const & acc, T x) {
-        return acc.removed(x);
-    }, as, bs);
-}
-
-// Set union of two lists, xs u ys
-// Assume no duplicates inside either list
-template<class T>
-List<T> set_union(List<T> const & xs, List<T> const & ys)
-{
-    // xs u ys = (ys \ xs) ++ xs
-    // removed all xs from ys
-    auto trimmed = foldl([](List<T> const & acc, T x) {
-        return acc.removed(x);
-    }, ys, xs);
-    return concat(trimmed, xs);
-}
-
-template<class T>
-List<T> concatAll(List<List<T>> const & xss)
-{
-    if (xss.isEmpty()) return List<T>();
-    return concat(xss.front(), concatAll(xss.popped_front()));
-}
-
-// consumes the list when called:
-// forEach(std::move(lst), f);
-
-template<class T, class F>
-void forEach(List<T> lst, F f)
-{
-    static_assert(std::is_convertible<F, std::function<void(T)>>::value,
-                  "forEach requires a function type void(T)");
-    while (!lst.isEmpty()) {
-        f(lst.front());
-        lst = lst.popped_front();
-    }
-}
-
-template<class Beg, class End>
-auto fromIt(Beg it, End end) -> List<typename Beg::value_type>
-{
-    typedef typename Beg::value_type T;
-    if (it == end)
-        return List<T>();
-    T item = *it;
-    return List<T>(item, fromIt(++it, end));
-}
-
-template<class T, class F>
-List<T> iterateN(F f, T init, int count)
-{
-    if (count <= 0) return List<T>();
-    return iterateN(f, f(init), count - 1).pushed_front(init);
-}
-
-// Pass lst by value not reference!
-template<class T>
-void printRaw(List<T> lst)
-{
-    if (lst.isEmpty()) {
-        std::cout << std::endl;
-    } else {
-        std::cout << "(" << lst.front() << ", " << lst.headCount() - 1 << ") ";
-        printRaw(lst.popped_front());
-    }
-}
-
-template<class T>
-std::ostream& operator<<(std::ostream& os, List<T> const & lst)
-{
-    os << "[";
-    forEach(lst, [&os](T v) {
-        os << v << " ";
-    });
-    os << "]";
-    return os;
-}
-
-template<class T>
-List<T> reversed(List<T> const & lst)
-{
-    return foldl([](List<T> const & acc, T v)
-                 {
-                     return List<T>(v, acc);
-                 }, List<T>(), lst);
-}