cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "types.hpp"
+#include <memory>
+#include <string>
+#include <vector>
+#include "export.h"
+
+namespace hocon {
+
+    /**
+     * Represents the origin (such as filename and line number) of a
+     * {@link config_value} for use in error messages. Obtain the origin of a value
+     * with {@link config_value#origin}. Exceptions may have an origin, see
+     * {@link config_exception#origin}, but be careful because
+     * <code>config_exception.origin()</code> may return null.
+     *
+     * <p>
+     * It's best to use this interface only for debugging; its accuracy is
+     * "best effort" rather than guaranteed, and a potentially-noticeable amount of
+     * memory could probably be saved if origins were not kept around, so in the
+     * future there might be some option to discard origins.
+     *
+     * <p>
+     * <em>Do not implement this interface</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 config_origin {
+    public:
+        /**
+         * Returns a string describing the origin of a value or exception. This will
+         * never return null.
+         *
+         * @return string describing the origin
+         */
+        LIBCPP_HOCON_EXPORT virtual std::string const& description() const = 0;
+
+        /**
+         * Returns a {@code ConfigOrigin} based on this one, but with the given
+         * line number. This origin must be a FILE, URL or RESOURCE. Does not modify
+         * this instance or any {@code ConfigValue}s with this origin (since they are
+         * immutable).  To set the returned origin to a  {@code ConfigValue}, use
+         * {@link ConfigValue#withOrigin}.
+         *
+         * <p>
+         * Note that when the given lineNumber are equal to the lineNumber on this
+         * object, a new instance may not be created and {@code this} is returned
+         * directly.
+         *
+         * @since 1.3.0
+         *
+         * @param lineNumber the new line number
+         * @return the created ConfigOrigin
+         */
+        LIBCPP_HOCON_EXPORT virtual shared_origin with_line_number(int line_number) const = 0;
+
+        /**
+         * Returns a line number where the value or exception originated. This will
+         * return -1 if there's no meaningful line number.
+         *
+         * @return line number or -1 if none is available
+         */
+        LIBCPP_HOCON_EXPORT virtual int line_number() const = 0;
+
+        /**
+         * Returns any comments that appeared to "go with" this place in the file.
+         * Often an empty list, but never null. The details of this are subject to
+         * change, but at the moment comments that are immediately before an array
+         * element or object field, with no blank line after the comment, "go with"
+         * that element or field.
+         *
+         * @return any comments that seemed to "go with" this origin, empty list if
+         *         none
+         */
+        LIBCPP_HOCON_EXPORT virtual std::vector<std::string> const& comments() const = 0;
+
+        /**
+         * Returns a {@code config_origin} based on this one, but with the given
+         * comments. Does not modify this instance or any {@code config_value}s with
+         * this origin (since they are immutable).  To set the returned origin to a
+         * {@code config_value}, use {@link config_value#with_origin}.
+         *
+         * <p>
+         * Note that when the given comments are equal to the comments on this object,
+         * a new instance may not be created and {@code this} is returned directly.
+         *
+         * @since 1.3.0
+         *
+         * @param comments the comments used on the returned origin
+         * @return the config_origin with the given comments
+         */
+        LIBCPP_HOCON_EXPORT virtual shared_origin with_comments(std::vector<std::string> comments) const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,139 @@
+#pragma once
+
+#include "types.hpp"
+#include "config_syntax.hpp"
+#include "export.h"
+
+namespace hocon {
+    /**
+     * A set of options related to parsing.
+     *
+     * <p>
+     * This object is immutable, so the "setters" return a new object.
+     *
+     * <p>
+     * Here is an example of creating a custom {@code config_parse_options}:
+     *
+     * <pre>
+     *     config_parse_options options = config_parse_options()
+     *         .set_syntax(config_syntax.JSON)
+     *         .set_allow_missing(false)
+     * </pre>
+     *
+     * ClassLoader is Java-specific, so it was not ported to C++.
+     */
+    class LIBCPP_HOCON_EXPORT config_parse_options {
+    public:
+        /**
+         * Gets an instance of <code>config_parse_options</code> with all fields
+         * set to the default values. Start with this instance and make any
+         * changes you need.
+         * @return the default parse options
+         */
+        config_parse_options();
+
+        /**
+         * Gets an instance of <code>ConfigParseOptions</code> with all fields
+         * set to the default values. Start with this instance and make any
+         * changes you need.
+         * @return the default parse options
+         */
+        static config_parse_options defaults();
+
+        /**
+         * Set the file format. If set to null, try to guess from any available
+         * filename extension; if guessing fails, assume {@link config_syntax#CONF}.
+         *
+         * @param syntax
+         *            a syntax or {@code nullptr} for best guess
+         * @return options with the syntax set
+         */
+        config_parse_options set_syntax(config_syntax syntax) const;
+
+        /**
+         * Gets the current syntax option
+         */
+        config_syntax const& get_syntax() const;
+
+        /**
+         * Set a description for the thing being parsed. In most cases this will be
+         * set up for you to something like the filename, but if you provide just an
+         * input stream you might want to improve on it. Set to null to allow the
+         * library to come up with something automatically. This description is the
+         * basis for the {@link config_origin} of the parsed values.
+         *
+         * @param origin_description description to put in the {@link config_origin}
+         * @return options with the origin description set
+         */
+        config_parse_options set_origin_description(shared_string origin_description) const;
+
+        /**
+         * Gets the current origin description, which may be null for "automatic".
+         * @return the current origin description or null
+         */
+        shared_string const& get_origin_description() const;
+
+        /**
+         * Set to false to throw an exception if the item being parsed (for example
+         * a file) is missing. Set to true to just return an empty document in that
+         * case.
+         *
+         * @param allow_missing true to silently ignore missing item
+         * @return options with the "allow missing" flag set
+         */
+        config_parse_options set_allow_missing(bool allow_missing) const;
+
+        /**
+         * Gets the current "allow missing" flag.
+         * @return whether we allow missing files
+         */
+        bool get_allow_missing() const;
+
+        /**
+         * Set a {@link config_includer} which customizes how includes are handled.
+         * null means to use the default includer.
+         *
+         * @param includer the includer to use or null for default
+         * @return new version of the parse options with different includer
+         */
+        config_parse_options set_includer(shared_includer includer) const;
+
+        /**
+         * Prepends a {@link config_includer} which customizes how
+         * includes are handled.  To prepend your includer, the
+         * library calls {@link config_includer#with_fallback} on your
+         * includer to append the existing includer to it.
+         *
+         * @param includer the includer to prepend (may not be null)
+         * @return new version of the parse options with different includer
+         */
+        config_parse_options prepend_includer(shared_includer includer) const;
+
+        /**
+         * Appends a {@link config_includer} which customizes how
+         * includes are handled.  To append, the library calls {@link
+         * config_includer#with_fallback} on the existing includer.
+         *
+         * @param includer the includer to append (may not be null)
+         * @return new version of the parse options with different includer
+         */
+        config_parse_options append_includer(shared_includer includer) const;
+
+        /**
+         * Gets the current includer (will be null for the default includer).
+         * @return current includer or null
+         */
+        shared_includer const& get_includer() const;
+
+    private:
+        config_parse_options(shared_string origin_desc,
+                             bool allow_missing, shared_includer includer,
+                             config_syntax syntax = config_syntax::UNSPECIFIED);
+        config_parse_options with_fallback_origin_description(shared_string origin_description) const;
+
+        config_syntax _syntax;
+        shared_string _origin_description;
+        bool _allow_missing;
+        shared_includer _includer;
+    };
+}  // namespace hocon

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

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "types.hpp"
+#include "export.h"
+
+namespace hocon {
+
+    /**
+     * An opaque handle to something that can be parsed, obtained from
+     * {@link config_include_context}.
+     *
+     * <p>
+     * <em>Do not implement this interface</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_parseable {
+    public:
+        /**
+         * Parse whatever it is. The options should come from
+         * {@link config_parseable#options()} but you could tweak them if you
+         * like.
+         *
+         * @param options
+         *            parse options, should be based on the ones from
+         *            {@link config_parseable#options()}
+         * @return the parsed object
+         */
+        virtual shared_object parse(config_parse_options const& options) const = 0;
+
+        /**
+         * Returns a config_origin describing the origin of the paresable item.
+         */
+        virtual shared_origin origin() const = 0;
+
+        /**
+         * Get the initial options, which can be modified then passed to parse().
+         * These options will have the right description, includer, and other
+         * parameters already set up.
+         * @return the initial options
+         */
+        virtual config_parse_options const& options() const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,128 @@
+#pragma once
+
+#include "export.h"
+
+namespace hocon {
+
+    /**
+     * <p>
+     * A set of options related to rendering a {@link config_value}. Passed to
+     * {@link config_value#render(config_render_options)}.
+     *
+     * <p>
+     * Here is an example of creating a {@code config_render_options}:
+     *
+     * <pre>
+     *     config_render_options options =
+     *         config_render_options().set_comments(false)
+     * </pre>
+     */
+    class LIBCPP_HOCON_EXPORT config_render_options {
+    public:
+        /** Leaving the default arguments will result in a verbose rendering,
+         * which contains comments and therefore is not valid JSON.
+         * See {@link config_render_options#concise} for stripped-down options.
+         */
+        config_render_options(bool origin_comments = true, bool comments = true,
+                              bool formatted = true, bool json = true);
+
+        /**
+         * Returns concise render options (no whitespace or comments). For a
+         * resolved {@link config}, the concise rendering will be valid JSON.
+         *
+         * @return the concise render options
+         */
+        static config_render_options concise();
+
+        /**
+         * Returns options with comments toggled. This controls human-written
+         * comments but not the autogenerated "origin of this setting" comments,
+         * which are controlled by {@link config_render_options#set_origin_comments}.
+         *
+         * @param value
+         *            true to include comments in the render
+         * @return options with requested setting for comments
+         */
+        config_render_options set_comments(bool value);
+
+        /**
+         * Returns whether the options enable comments. This method is mostly used
+         * by the config lib internally, not by applications.
+         *
+         * @return true if comments should be rendered
+         */
+        bool get_comments() const;
+
+        /**
+         * Returns options with origin comments toggled. If this is enabled, the
+         * library generates comments for each setting based on the
+         * {@link config_value#origin} of that setting's value. For example these
+         * comments might tell you which file a setting comes from.
+         *
+         * <p>
+         * {@code set_origin_comments()} controls only these autogenerated
+         * "origin of this setting" comments, to toggle regular comments use
+         * {@link config_render_options#set_comments}.
+         *
+         * @param value
+         *            true to include autogenerated setting-origin comments in the
+         *            render
+         * @return options with origin comments toggled
+         */
+        config_render_options set_origin_comments(bool value);
+
+        /**
+         * Returns whether the options enable automated origin comments. This method
+         * is mostly used by the config lib internally, not by applications.
+         *
+         * @return true if origin comments should be rendered
+         */
+        bool get_origin_comments() const;
+
+        /**
+         * Returns options with formatting toggled. Formatting means indentation and
+         * whitespace, enabling formatting makes things prettier but larger.
+         *
+         * @param value
+         *            true to enable formatting
+         * @return options with requested setting for formatting
+         */
+        config_render_options set_formatted(bool value);
+
+        /**
+         * Returns whether the options enable formatting. This method is mostly used
+         * by the config lib internally, not by applications.
+         *
+         * @return true if the options enable formatting
+         */
+        bool get_formatted() const;
+
+        /**
+         * Returns options with JSON toggled. JSON means that HOCON extensions
+         * (omitting commas, quotes for example) won't be used. However, whether to
+         * use comments is controlled by the separate {@link #set_comments(boolean)}
+         * and {@link #set_origin_comments(boolean)} options. So if you enable
+         * comments you will get invalid JSON despite setting this to true.
+         *
+         * @param value
+         *            true to include non-JSON extensions in the render
+         * @return options with requested setting for JSON
+         */
+        config_render_options set_json(bool value);
+
+        /**
+         * Returns whether the options enable JSON. This method is mostly used by
+         * the config lib internally, not by applications.
+         *
+         * @return true if only JSON should be rendered
+         */
+        bool get_json() const;
+
+    private:
+        bool _origin_comments;
+        bool _comments;
+        bool _formatted;
+        bool _json;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,83 @@
+#pragma once
+
+#include "export.h"
+
+namespace hocon {
+
+    /**
+     * A set of options related to resolving substitutions. Substitutions use the
+     * <code>${foo.bar}</code> syntax and are documented in the <a
+     * href="https://github.com/typesafehub/config/blob/master/HOCON.md">HOCON</a>
+     * spec.
+     * <p>
+     * Typically this class would be used with the method
+     * {@link config#resolve(config_resolve_options)}.
+     * <p>
+     * This object is immutable, so the "setters" return a new object.
+     * <p>
+     * Here is an example of creating a custom {@code config_resolve_options}:
+     *
+     * <pre>
+     *     config_resolve_options options = config_resolve_options()
+     *         .set_use_system_environment(false)
+     * </pre>
+     * <p>
+     * In addition to {@link config_resolve_options}, there's a prebuilt
+     * {@link config_resolve_options#no_system} which avoids looking at any system
+     * environment variables or other external system information. (Right now,
+     * environment variables are the only example.)
+     */
+    class LIBCPP_HOCON_EXPORT config_resolve_options {
+    public:
+        /**
+         * Returns the default resolve options. By default the system environment
+         * will be used and unresolved substitutions are not allowed.
+         *
+         * @return the default resolve options
+         */
+        config_resolve_options(bool use_system_environment = true, bool allow_unresolved = false);
+
+        /**
+         * Returns resolve options that disable any reference to "system" data
+         * (currently, this means environment variables).
+         *
+         * @return the resolve options with env variables disabled
+         */
+        config_resolve_options set_use_system_environment(bool value) const;
+
+        /**
+         * Returns whether the options enable use of system environment variables.
+         * This method is mostly used by the config lib internally, not by
+         * applications.
+         *
+         * @return true if environment variables should be used
+         */
+        bool get_use_system_environment() const;
+
+        /**
+         * Returns options with "allow unresolved" set to the given value. By
+         * default, unresolved substitutions are an error. If unresolved
+         * substitutions are allowed, then a future attempt to use the unresolved
+         * value may fail, but {@link config#resolve(config_resolve_options)} itself
+         * will not throw.
+         *
+         * @param value
+         *            true to silently ignore unresolved substitutions.
+         * @return options with requested setting for whether to allow substitutions
+         */
+        config_resolve_options set_allow_unresolved(bool value) const;
+
+        /**
+         * Returns whether the options allow unresolved substitutions. This method
+         * is mostly used by the config lib internally, not by applications.
+         *
+         * @return true if unresolved substitutions are allowed
+         */
+        bool get_allow_unresolved() const;
+
+    private:
+        bool _use_system_environment;
+        bool _allow_unresovled;
+    };
+
+}  // namespace hocon