facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,98 +0,0 @@
-#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

@@ -1,139 +0,0 @@
-#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

@@ -1,47 +0,0 @@
-#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

@@ -1,128 +0,0 @@
-#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

@@ -1,83 +0,0 @@
-#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