facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -1,734 +0,0 @@
-#pragma once
-
-#include "types.hpp"
-#include "config_mergeable.hpp"
-#include "config_origin.hpp"
-#include "config_object.hpp"
-#include "config_resolve_options.hpp"
-#include "config_value.hpp"
-#include "config_list.hpp"
-#include "config_exception.hpp"
-#include "path.hpp"
-#include <vector>
-#include <string>
-#include <set>
-#include "export.h"
-#include <leatherman/locale/locale.hpp>
-
-namespace hocon {
-
-    enum class time_unit { NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS };
-
-    /**
-     * An immutable map from config paths to config values. Paths are dot-separated
-     * expressions such as <code>foo.bar.baz</code>. Values are as in JSON
-     * (booleans, strings, numbers, lists, or objects), represented by
-     * {@link config_value} instances. Values accessed through the
-     * <code>config</code> interface are never null.
-     *
-     * <p>
-     * {@code config} is an immutable object and thus safe to use from multiple
-     * threads. There's never a need for "defensive copies."
-     *
-     * <p>
-     * Fundamental operations on a {@code config} include getting configuration
-     * values, <em>resolving</em> substitutions with {@link config#resolve()}, and
-     * merging configs using {@link config#with_fallback(config_mergeable)}.
-     *
-     * <p>
-     * All operations return a new immutable {@code config} rather than modifying
-     * the original instance.
-     *
-     * <p>
-     * <strong>Examples</strong>
-     *
-     * <p>
-     * You can find an example app and library <a
-     * href="https://github.com/typesafehub/config/tree/master/examples">on
-     * GitHub</a>. Also be sure to read the <a
-     * href="package-summary.html#package_description">package overview</a> which
-     * describes the big picture as shown in those examples.
-     *
-     * <p>
-     * <strong>Paths, keys, and config vs. config_object</strong>
-     *
-     * <p>
-     * <code>config</code> is a view onto a tree of {@link config_object}; the
-     * corresponding object tree can be found through {@link config#root()}.
-     * <code>config_object</code> is a map from config <em>keys</em>, rather than
-     * paths, to config values. Think of <code>config_object</code> as a JSON object
-     * and <code>config</code> as a configuration API.
-     *
-     * <p>
-     * The API tries to consistently use the terms "key" and "path." A key is a key
-     * in a JSON object; it's just a string that's the key in a map. A "path" is a
-     * parseable expression with a syntax and it refers to a series of keys. Path
-     * expressions are described in the <a
-     * href="https://github.com/typesafehub/config/blob/master/HOCON.md">spec for
-     * Human-Optimized Config Object Notation</a>. In brief, a path is
-     * period-separated so "a.b.c" looks for key c in object b in object a in the
-     * root object. Sometimes double quotes are needed around special characters in
-     * path expressions.
-     *
-     * <p>
-     * The API for a {@code config} is in terms of path expressions, while the API
-     * for a {@code config_object} is in terms of keys. Conceptually, {@code config}
-     * is a one-level map from <em>paths</em> to values, while a
-     * {@code config_object} is a tree of nested maps from <em>keys</em> to values.
-     *
-     * <p>
-     * Use {@link config_util#join_path} and {@link config_util#split_path} to convert
-     * between path expressions and individual path elements (keys).
-     *
-     * <p>
-     * Another difference between {@code config} and {@code config_object} is that
-     * conceptually, {@code config_value}s with a {@link config_value#value_type()
-     * value_type()} of {@link config_value::type#NULL NULL} exist in a
-     * {@code config_object}, while a {@code config} treats null values as if they
-     * were missing. (With the exception of two methods: {@link config#has_path_or_null}
-     * and {@link config#get_is_null} let you detect <code>null</code> values.)
-     *
-     * <p>
-     * <strong>Getting configuration values</strong>
-     *
-     * <p>
-     * The "getters" on a {@code config} all work in the same way. They never return
-     * null, nor do they return a {@code config_value} with
-     * {@link config_value#value_type() value_type()} of {@link config_value::type#NULL
-     * NULL}. Instead, they throw {@link config_exception} if the value is
-     * completely absent or set to null. If the value is set to null, a subtype of
-     * {@code config_exception.missing} called {@link config_exception.null} will be
-     * thrown. {@link config_excpetion.wrong_type} will be thrown anytime you ask for
-     * a type and the value has an incompatible type. Reasonable type conversions
-     * are performed for you though.
-     *
-     * <p>
-     * <strong>Iteration</strong>
-     *
-     * <p>
-     * If you want to iterate over the contents of a {@code config}, you can get its
-     * {@code config_object} with {@link #root()}, and then iterate over the
-     * {@code config_object} (which implements <code>java.util.Map</code>). Or, you
-     * can use {@link #entry_set()} which recurses the object tree for you and builds
-     * up a <code>set</code> of all path-value pairs where the value is not null.
-     *
-     * <p>
-     * <strong>Resolving substitutions</strong>
-     *
-     * <p>
-     * <em>Substitutions</em> are the <code>${foo.bar}</code> syntax in config
-     * files, described in the <a href=
-     * "https://github.com/typesafehub/config/blob/master/HOCON.md#substitutions"
-     * >specification</a>. Resolving substitutions replaces these references with real
-     * values.
-     *
-     * <p>
-     * Before using a {@code config} it's necessary to call {@link config#resolve()}
-     * to handle substitutions (though {@link config_factory#load()} and similar
-     * methods will do the resolve for you already).
-     *
-     * <p>
-     * <strong>Merging</strong>
-     *
-     * <p>
-     * The full <code>config</code> for your application can be constructed using
-     * the associative operation {@link config#with_fallback(config_mergeable)}. If
-     * you use {@link config_factory#load()} (recommended), it merges system
-     * properties over the top of <code>application.conf</code> over the top of
-     * <code>reference.conf</code>, using <code>with_fallback</code>. You can add in
-     * additional sources of configuration in the same way (usually, custom layers
-     * should go either just above or just below <code>application.conf</code>,
-     * keeping <code>reference.conf</code> at the bottom and system properties at
-     * the top).
-     *
-     * <p>
-     * <strong>Serialization</strong>
-     *
-     * <p>
-     * Convert a <code>config</code> to a JSON or HOCON string by calling
-     * {@link config_object#render()} on the root object,
-     * <code>my_config.root().render()</code>. There's also a variant
-     * {@link config_object#render(config_render_options)} which allows you to control
-     * the format of the rendered string. (See {@link config_render_options}.) Note
-     * that <code>config</code> does not remember the formatting of the original
-     * file, so if you load, modify, and re-save a config file, it will be
-     * substantially reformatted.
-     *
-     * <p>
-     * As an alternative to {@link config_object#render()}, the
-     * <code>to_string()</code> method produces a debug-output-oriented
-     * representation (which is not valid JSON).
-     *
-     * <p>
-     * <strong>This is an interface but don't implement it yourself</strong>
-     *
-     * <p>
-     * <em>Do not implement {@code config}</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 : public config_mergeable, public std::enable_shared_from_this<config> {
-        friend class config_object;
-        friend class config_value;
-        friend class config_parseable;
-        friend class parseable;
-
-    public:
-        /**
-         * Parses a file with a flexible extension. If the <code>fileBasename</code>
-         * already ends in a known extension, this method parses it according to
-         * that extension (the file's syntax must match its extension). If the
-         * <code>fileBasename</code> does not end in an extension, it parses files
-         * with all known extensions and merges whatever is found.
-         *
-         * <p>
-         * In the current implementation, the extension ".conf" forces
-         * {@link ConfigSyntax#CONF}, ".json" forces {@link ConfigSyntax#JSON}.
-         * When merging files, ".conf" falls back to ".json".
-         *
-         * <p>
-         * Future versions of the implementation may add additional syntaxes or
-         * additional extensions. However, the ordering (fallback priority) of the
-         * three current extensions will remain the same.
-         *
-         * <p>
-         * If <code>options</code> forces a specific syntax, this method only parses
-         * files with an extension matching that syntax.
-         *
-         * <p>
-         * If {@link ConfigParseOptions#getAllowMissing options.getAllowMissing()}
-         * is true, then no files have to exist; if false, then at least one file
-         * has to exist.
-         *
-         * @param fileBasename
-         *            a filename with or without extension
-         * @param options
-         *            parse options
-         * @return the parsed configuration
-         */
-        static shared_config parse_file_any_syntax(std::string file_basename, config_parse_options options);
-
-        /**
-         * Like {@link #parseFileAnySyntax(File,ConfigParseOptions)} but always uses
-         * default parse options.
-         *
-         * @param fileBasename
-         *            a filename with or without extension
-         * @return the parsed configuration
-         */
-        static shared_config parse_file_any_syntax(std::string file_basename);
-
-        /**
-         * Parses a string (which should be valid HOCON or JSON by default, or
-         * the syntax specified in the options otherwise).
-         *
-         * @param s string to parse
-         * @param options parse options
-         * @return the parsed configuration
-         */
-        static shared_config parse_string(std::string s, config_parse_options options);
-
-        /**
-         * Parses a string (which should be valid HOCON or JSON).
-         *
-         * @param s string to parse
-         * @return the parsed configuration
-         */
-        static shared_config parse_string(std::string s);
-
-        /**
-         * Gets the {@code Config} as a tree of {@link ConfigObject}. This is a
-         * constant-time operation (it is not proportional to the number of values
-         * in the {@code Config}).
-         *
-         * @return the root object in the configuration
-         */
-        virtual shared_object root() const;
-
-        /**
-         * Gets the origin of the {@code Config}, which may be a file, or a file
-         * with a line number, or just a descriptive phrase.
-         *
-         * @return the origin of the {@code Config} for use in error messages
-         */
-        virtual shared_origin origin() const;
-
-        std::shared_ptr<const config_mergeable> with_fallback(std::shared_ptr<const config_mergeable> other) const override;
-
-        shared_value to_fallback_value() const override;
-
-        /**
-         * Returns a replacement config with all substitutions (the
-         * <code>${foo.bar}</code> syntax, see <a
-         * href="https://github.com/typesafehub/config/blob/master/HOCON.md">the
-         * spec</a>) resolved. Substitutions are looked up using this
-         * <code>config</code> as the root object, that is, a substitution
-         * <code>${foo.bar}</code> will be replaced with the result of
-         * <code>get_value("foo.bar")</code>.
-         *
-         * <p>
-         * This method uses {@link config_resolve_options()}, there is
-         * another variant {@link config#resolve(config_resolve_options)} which lets
-         * you specify non-default options.
-         *
-         * <p>
-         * A given {@link config} must be resolved before using it to retrieve
-         * config values, but ideally should be resolved one time for your entire
-         * stack of fallbacks (see {@link config#with_fallback}). Otherwise, some
-         * substitutions that could have resolved with all fallbacks available may
-         * not resolve, which will be potentially confusing for your application's
-         * users.
-         *
-         * <p>
-         * <code>resolve()</code> should be invoked on root config objects, rather
-         * than on a subtree (a subtree is the result of something like
-         * <code>config.get_config("foo")</code>). The problem with
-         * <code>resolve()</code> on a subtree is that substitutions are relative to
-         * the root of the config and the subtree will have no way to get values
-         * from the root. For example, if you did
-         * <code>config.get_config("foo").resolve()</code> on the below config file,
-         * it would not work:
-         *
-         * <pre>
-         *   common-value = 10
-         *   foo {
-         *      whatever = ${common-value}
-         *   }
-         * </pre>
-         *
-         * <p>
-         * Many methods on {@link config_factory} such as
-         * {@link config_factory#load()} automatically resolve the loaded
-         * <code>config</code> on the loaded stack of config files.
-         *
-         * <p>
-         * Resolving an already-resolved config is a harmless no-op, but again, it
-         * is best to resolve an entire stack of fallbacks (such as all your config
-         * files combined) rather than resolving each one individually.
-         *
-         * @return an immutable object with substitutions resolved
-         */
-        virtual shared_config resolve() const;
-
-        /**
-         * Like {@link config#resolve()} but allows you to specify non-default
-         * options.
-         *
-         * @param options
-         *            resolve options
-         * @return the resolved <code>config</code> (may be only partially resolved if options are
-         *          set to allow unresolved)
-         */
-        virtual shared_config resolve(config_resolve_options options) const;
-
-        /**
-         * Checks whether the config is completely resolved. After a successful call
-         * to {@link config#resolve()} it will be completely resolved, but after
-         * calling {@link config#resolve(config_resolve_options)} with
-         * <code>allow_unresolved</code> set in the options, it may or may not be
-         * completely resolved. A newly-loaded config may or may not be completely
-         * resolved depending on whether there were substitutions present in the
-         * file.
-         *
-         * @return true if there are no unresolved substitutions remaining in this
-         *         configuration.
-         */
-        virtual bool is_resolved() const;
-
-        /**
-         * Like {@link config#resolve()} except that substitution values are looked
-         * up in the given source, rather than in this instance. This is a
-         * special-purpose method which doesn't make sense to use in most cases;
-         * it's only needed if you're constructing some sort of app-specific custom
-         * approach to configuration. The more usual approach if you have a source
-         * of substitution values would be to merge that source into your config
-         * stack using {@link config#withFallback} and then resolve.
-         * <p>
-         * Note that this method does NOT look in this instance for substitution
-         * values. If you want to do that, you could either merge this instance into
-         * your value source using {@link config#with_fallback}, or you could resolve
-         * multiple times with multiple sources (using
-         * {@link config_resolve_options#setAllowUnresolved(boolean)} so the partial
-         * resolves don't fail).
-         *
-         * @param source
-         *            configuration to pull values from
-         * @return an immutable object with substitutions resolved
-         */
-        virtual shared_config resolve_with(shared_config source) const;
-
-        /**
-         * Like {@link config#resolve_with(config)} but allows you to specify
-         * non-default options.
-         *
-         * @param source
-         *            source configuration to pull values from
-         * @param options
-         *            resolve options
-         * @return the resolved <code>config</code> (may be only partially resolved
-         *         if options are set to allow unresolved)
-         */
-        virtual shared_config resolve_with(shared_config source, config_resolve_options options) const;
-
-        /**
-         * Validates this config against a reference config, throwing an exception
-         * if it is invalid. The purpose of this method is to "fail early" with a
-         * comprehensive list of problems; in general, anything this method can find
-         * would be detected later when trying to use the config, but it's often
-         * more user-friendly to fail right away when loading the config.
-         *
-         * <p>
-         * Using this method is always optional, since you can "fail late" instead.
-         *
-         * <p>
-         * You must restrict validation to paths you "own" (those whose meaning are
-         * defined by your code module). If you validate globally, you may trigger
-         * errors about paths that happen to be in the config but have nothing to do
-         * with your module. It's best to allow the modules owning those paths to
-         * validate them. Also, if every module validates only its own stuff, there
-         * isn't as much redundant work being done.
-         *
-         * <p>
-         * If no paths are specified in <code>check_valid()</code>'s parameter list,
-         * validation is for the entire config.
-         *
-         * <p>
-         * If you specify paths that are not in the reference config, those paths
-         * are ignored. (There's nothing to validate.)
-         *
-         * <p>
-         * Here's what validation involves:
-         *
-         * <ul>
-         * <li>All paths found in the reference config must be present in this
-         * config or an exception will be thrown.
-         * <li>
-         * Some changes in type from the reference config to this config will cause
-         * an exception to be thrown. Not all potential type problems are detected,
-         * in particular it's assumed that strings are compatible with everything
-         * except objects and lists. This is because string types are often "really"
-         * some other type (system properties always start out as strings, or a
-         * string like "5ms" could be used with {@link #get_milliseconds}). Also,
-         * it's allowed to set any type to null or override null with any type.
-         * <li>
-         * Any unresolved substitutions in this config will cause a validation
-         * failure; both the reference config and this config should be resolved
-         * before validation. If the reference config is unresolved, it's a bug in
-         * the caller of this method.
-         * </ul>
-         *
-         * <p>
-         * If you want to allow a certain setting to have a flexible type (or
-         * otherwise want validation to be looser for some settings), you could
-         * either remove the problematic setting from the reference config provided
-         * to this method, or you could intercept the validation exception and
-         * screen out certain problems. Of course, this will only work if all other
-         * callers of this method are careful to restrict validation to their own
-         * paths, as they should be.
-         *
-         * <p>
-         * If validation fails, the thrown exception contains a list of all problems
-         * found. The exception will have all the problem concatenated into one huge string.
-         *
-         * <p>
-         * Again, <code>check_valid()</code> can't guess every domain-specific way a
-         * setting can be invalid, so some problems may arise later when attempting
-         * to use the config. <code>check_valid()</code> is limited to reporting
-         * generic, but common, problems such as missing settings and blatant type
-         * incompatibilities.
-         *
-         * @param reference
-         *            a reference configuration
-         * @param restrictToPaths
-         *            only validate values underneath these paths that your code
-         *            module owns and understands
-         */
-        virtual void check_valid(shared_config reference, std::vector<std::string> restrict_to_paths) const;
-
-        /**
-         * Checks whether a value is present and non-null at the given path. This
-         * differs in two ways from {@code Map.containsKey()} as implemented by
-         * {@link config_object}: it looks for a path expression, not a key; and it
-         * returns false for null values, while {@code contains_key()} returns true
-         * indicating that the object contains a null value for the key.
-         *
-         * <p>
-         * If a path exists according to {@link #has_path(string)}, then
-         * {@link #get_value(string)} will never throw an exception. However, the
-         * typed getters will still throw if the value is not convertible to the
-         * requested type.
-         *
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            the path expression
-         * @return true if a non-null value is present at the path
-         */
-        virtual bool has_path(std::string const& path) const;
-
-        /**
-         * Checks whether a value is present at the given path, even
-         * if the value is null. Most of the getters on
-         * <code>config</code> will throw if you try to get a null
-         * value, so if you plan to call {@link #get_value(string)},
-         * {@link #get_int(string)}, or another getter you may want to
-         * use plain {@link #has_path(string)} rather than this method.
-         *
-         * <p>
-         * To handle all three cases (unset, null, and a non-null value)
-         * the code might look like:
-         * <pre><code>
-         * if (config.has_path_or_null(path)) {
-         *     if (config.get_is_null(path)) {
-         *        // handle null setting
-         *     } else {
-         *        // get and use non-null setting
-         *     }
-         * } else {
-         *     // handle entirely unset path
-         * }
-         * </code></pre>
-         *
-         * <p> However, the usual thing is to allow entirely unset
-         * paths to be a bug that throws an exception (because you set
-         * a default in your <code>reference.conf</code>), so in that
-         * case it's OK to call {@link #get_is_null(string)} without
-         * checking <code>has_path_or_null</code> first.
-         *
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            the path expression
-         * @return true if a value is present at the path, even if the value is null
-         */
-        virtual bool has_path_or_null(std::string const& path) const;
-
-        /**
-         * Returns true if the {@code Config}'s root object contains no key-value
-         * pairs.
-         *
-         * @return true if the configuration is empty
-         */
-        virtual bool is_empty() const;
-
-        /**
-         * Returns the set of path-value pairs, excluding any null values, found by
-         * recursing {@link #root() the root object}. Note that this is very
-         * different from <code>root().entry_set()</code> which returns the set of
-         * immediate-child keys in the root object and includes null values.
-         * <p>
-         * Entries contain <em>path expressions</em> meaning there may be quoting
-         * and escaping involved. Parse path expressions with
-         * {@link config_util#split_path}.
-         * <p>
-         * Because a <code>config</code> is conceptually a single-level map from
-         * paths to values, there will not be any {@link config_object} values in the
-         * entries (that is, all entries represent leaf nodes). Use
-         * {@link config_object} rather than <code>config</code> if you want a tree.
-         * (OK, this is a slight lie: <code>config</code> entries may contain
-         * {@link config_list} and the lists may contain objects. But no objects are
-         * directly included as entry values.)
-         *
-         * @return set of paths with non-null values, built up by recursing the
-         *         entire tree of {@link config_object} and creating an entry for
-         *         each leaf value.
-         */
-        virtual std::set<std::pair<std::string, std::shared_ptr<const config_value>>> entry_set() const;
-
-        /**
-         * Checks whether a value is set to null at the given path,
-         * but throws an exception if the value is entirely
-         * unset. This method will not throw if {@link
-         * #has_path_or_null(string)} returned true for the same path, so
-         * to avoid any possible exception check
-         * <code>has_path_or_null()</code> first.  However, an exception
-         * for unset paths will usually be the right thing (because a
-         * <code>reference.conf</code> should exist that has the path
-         * set, the path should never be unset unless something is
-         * broken).
-         *
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            the path expression
-         * @return true if the value exists and is null, false if it
-         * exists and is not null
-         */
-        virtual bool get_is_null(std::string const& path) const;
-
-        virtual bool get_bool(std::string const& path) const;
-        virtual int get_int(std::string const& path) const;
-        virtual int64_t get_long(std::string const& path) const;
-        virtual double get_double(std::string const& path) const;
-        virtual std::string get_string(std::string const& path) const;
-        virtual std::shared_ptr<const config_object> get_object(std::string const& path) const;
-        virtual shared_config get_config(std::string const& path) const;
-        virtual unwrapped_value get_any_ref(std::string const& path) const;
-        virtual std::shared_ptr<const config_value> get_value(std::string const& path) const;
-
-        template<typename T>
-        std::vector<T> get_homogeneous_unwrapped_list(std::string const& path) const {
-            auto list = boost::get<std::vector<unwrapped_value>>(get_list(path)->unwrapped());
-            std::vector<T> T_list;
-            for (auto item : list) {
-                try {
-                    T_list.push_back(boost::get<T>(item));
-                } catch (boost::bad_get &ex) {
-                    throw config_exception(leatherman::locale::format("The list did not contain only the desired type."));
-                }
-            }
-            return T_list;
-        }
-
-        virtual shared_list get_list(std::string const& path) const;
-        virtual std::vector<bool> get_bool_list(std::string const& path) const;
-        virtual std::vector<int> get_int_list(std::string const& path) const;
-        virtual std::vector<int64_t> get_long_list(std::string const& path) const;
-        virtual std::vector<double> get_double_list(std::string const& path) const;
-        virtual std::vector<std::string> get_string_list(std::string const& path) const;
-        virtual std::vector<shared_object> get_object_list(std::string const& path) const;
-        virtual std::vector<shared_config> get_config_list(std::string const& path) const;
-
-        // TODO: memory parsing
-
-        /**
-         * Gets a value as an integer number of the specified units.
-         * If the result would have a fractional part, the number is truncated.
-         * Correctly handles durations within the range +/-2^63 seconds.
-         * @param path the path to the time value
-         * @param unit the units of the number returned
-         * @return a 64-bit integer representing the value converted to the requested units
-         */
-        virtual int64_t get_duration(std::string const& path, time_unit unit) const;
-
-        /**
-         * Clone the config with only the given path (and its children) retained;
-         * all sibling paths are removed.
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            path to keep
-         * @return a copy of the config minus all paths except the one specified
-         */
-        virtual shared_config with_only_path(std::string const& path) const;
-
-        /**
-         * Clone the config with the given path removed.
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            path expression to remove
-         * @return a copy of the config minus the specified path
-         */
-        virtual shared_config without_path(std::string const& path) const;
-
-        /**
-         * Places the config inside another {@code config} at the given path.
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            path expression to store this config at.
-         * @return a {@code config} instance containing this config at the given
-         *         path.
-         */
-        virtual shared_config at_path(std::string const& path) const;
-
-        /**
-         * Places the config inside a {@code config} at the given key. See also
-         * at_path(). Note that a key is NOT a path expression (see
-         * {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param key
-         *            key to store this config at.
-         * @return a {@code config} instance containing this config at the given
-         *         key.
-         */
-        virtual shared_config at_key(std::string const& key) const;
-
-        /**
-         * Returns a {@code config} based on this one, but with the given path set
-         * to the given value. Does not modify this instance (since it's immutable).
-         * If the path already has a value, that value is replaced. To remove a
-         * value, use withoutPath().
-         * <p>
-         * Note that path expressions have a syntax and sometimes require quoting
-         * (see {@link config_util#join_path} and {@link config_util#split_path}).
-         *
-         * @param path
-         *            path expression for the value's new location
-         * @param value
-         *            value at the new path
-         * @return the new instance with the new map entry
-         */
-        virtual shared_config with_value(std::string const& path, std::shared_ptr<const config_value> value) const;
-
-        bool operator==(config const& other) const;
-
-        config(shared_object object);
-
-        static shared_object env_variables_as_config_object();
-
-    protected:
-        shared_value find(std::string const& path_expression, config_value::type expected) const;
-        shared_value find(path path_expression, config_value::type expected, path original_path) const;
-        shared_value find(path path_expression, config_value::type expected) const;
-        shared_config at_key(shared_origin origin, std::string const& key) const;
-
-        static shared_includer default_includer();
-
-        // TODO: memory and duration parsing
-
-    private:
-        /**
-         * Parses a duration string. If no units are specified in the string, it is assumed to be in
-         * milliseconds.
-         * Valid suffixes include ns, us, ms, s, m, h, and d. The units can also be specified as complete
-         * words (e.g. "seconds").
-         * @param input the string to parse
-         * @param origin_for_exception the origin of the value being parsed
-         * @param path_for_exception the path to the value being parsed
-         * @return the value parsed as a time_duration
-         */
-        static duration parse_duration(std::string input, shared_origin origin_for_exception, std::string path_for_exception);
-
-        static duration convert(int64_t number, time_unit units);
-        static duration convert(double number, time_unit units);
-        static time_unit get_units(std::string const& unit_string);
-        duration get_duration(std::string const& path) const;
-
-        shared_value has_path_peek(std::string const& path_expression) const;
-        shared_value peek_path(path desired_path) const;
-
-        static void find_paths(std::set<std::pair<std::string, std::shared_ptr<const config_value>>>& entries,
-                               path parent, shared_object obj);
-        static shared_value throw_if_null(shared_value v, config_value::type expected, path original_path);
-        static shared_value find_key(shared_object self, std::string const& key,
-                                     config_value::type expected, path original_path);
-        static shared_value find_key_or_null(shared_object self, std::string const& key,
-                                             config_value::type expected, path original_path);
-        static shared_value find_or_null(shared_object self, path desired_path,
-                                         config_value::type expected, path original_path);
-        shared_value find_or_null(std::string const& path_expression, config_value::type expected) const;
-        shared_value find_or_null(path path_expression, config_value::type expected, path original_path) const;
-
-        shared_object _object;
-    };
-
-    template<>
-    std::vector<int64_t> config::get_homogeneous_unwrapped_list(std::string const& path) const;
-
-}  // namespace hocon