comparison DEPENDENCIES/generic/include/boost/log/utility/setup/settings.hpp @ 16:2665513ce2d3

Add boost headers

+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   settings.hpp
+ * \author Andrey Semashev
+ * \date   11.10.2009
+ *
+ * The header contains definition of the library settings container.
+ */
+
+#ifndef BOOST_LOG_UTILITY_SETUP_SETTINGS_HPP_INCLUDED_
+#define BOOST_LOG_UTILITY_SETUP_SETTINGS_HPP_INCLUDED_
+
+#include <cstddef>
+#include <string>
+#include <iterator>
+#include <boost/assert.hpp>
+#include <boost/move/core.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/optional/optional.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <boost/log/detail/setup_config.hpp>
+#include <boost/log/detail/native_typeof.hpp>
+#include <boost/utility/explicit_operator_bool.hpp>
+#if !defined(BOOST_LOG_TYPEOF)
+#include <boost/utility/enable_if.hpp>
+#endif
+#if defined(BOOST_LOG_TYPEOF) && defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
+#include <boost/utility/declval.hpp>
+#endif
+#include <boost/log/detail/header.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+BOOST_LOG_OPEN_NAMESPACE
+
+namespace aux {
+
+// This workaround is needed for MSVC 10 to work around ICE caused by stack overflow
+template< typename SectionT, bool IsConstV >
+struct basic_settings_section_iterator_base;
+
+template< typename SectionT >
+struct basic_settings_section_iterator_base< SectionT, true >
+{
+    typedef typename SectionT::BOOST_NESTED_TEMPLATE iter< true > iterator_type;
+    typedef typename SectionT::property_tree_type::const_iterator base_iterator_type;
+    typedef iterator_adaptor<
+        iterator_type,
+        base_iterator_type,
+        SectionT,
+        use_default,
+        const SectionT
+    > type;
+};
+
+template< typename SectionT >
+struct basic_settings_section_iterator_base< SectionT, false >
+{
+    typedef typename SectionT::BOOST_NESTED_TEMPLATE iter< false > iterator_type;
+    typedef typename SectionT::property_tree_type::iterator base_iterator_type;
+    typedef iterator_adaptor<
+        iterator_type,
+        base_iterator_type,
+        SectionT,
+        use_default,
+        SectionT
+    > type;
+};
+
+} // namespace aux
+
+/*!
+ * \brief The class represents a reference to the settings container section
+ *
+ * The section refers to a sub-tree of the library settings container. It does not
+ * own the referred sub-tree but allows for convenient access to parameters within the subsection.
+ */
+template< typename CharT >
+class basic_settings_section
+{
+    template< typename SectionT, bool IsConstV >
+    friend struct aux::basic_settings_section_iterator_base;
+
+public:
+    //! Character type
+    typedef CharT char_type;
+    //! String type
+    typedef std::basic_string< char_type > string_type;
+    //! Property tree type
+    typedef property_tree::basic_ptree< std::string, string_type > property_tree_type;
+    //! Property tree path type
+    typedef typename property_tree_type::path_type path_type;
+
+private:
+#if !defined(BOOST_LOG_DOXYGEN_PASS)
+
+    //! A reference proxy object
+#ifndef BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS
+    template< bool IsConstV >
+    class ref;
+    template< bool IsConstV >
+    friend class ref;
+#endif
+    template< bool IsConstV >
+    class ref
+    {
+    private:
+        typedef typename mpl::if_c<
+            IsConstV,
+            basic_settings_section< char_type > const,
+            basic_settings_section< char_type >
+        >::type section_type;
+
+    private:
+        section_type& m_section;
+        path_type m_path;
+
+    public:
+        ref(section_type& section, std::string const& section_name) :
+            m_section(section),
+            m_path(section_name)
+        {
+        }
+        ref(section_type& section, const char* section_name) :
+            m_section(section),
+            m_path(section_name)
+        {
+        }
+
+        ref& operator[] (std::string const& param_name)
+        {
+            m_path /= param_name;
+            return *this;
+        }
+
+        ref& operator= (string_type const& value)
+        {
+            BOOST_ASSERT(m_section.m_ptree != NULL);
+            m_section.m_ptree->put(m_path, value);
+            return *this;
+        }
+
+        template< bool V >
+        ref& operator= (ref< V > const& value)
+        {
+            BOOST_ASSERT(m_section.m_ptree != NULL);
+            optional< string_type > val = value.get();
+            if (!!val)
+            {
+                m_section.m_ptree->put(m_path, val);
+            }
+            else if (optional< property_tree_type& > node = m_section.m_ptree->get_child_optional(m_path))
+            {
+                node.put_value(string_type());
+            }
+
+            return *this;
+        }
+
+        template< typename T >
+        ref& operator= (T const& value)
+        {
+            BOOST_ASSERT(m_section.m_ptree != NULL);
+            m_section.m_ptree->put(m_path, value);
+            return *this;
+        }
+
+        BOOST_EXPLICIT_OPERATOR_BOOL()
+
+        bool operator! () const
+        {
+            return !m_section.m_ptree || !m_section.m_ptree->get_child_optional(m_path);
+        }
+
+        std::string get_name() const
+        {
+            return m_path.dump();
+        }
+
+        operator optional< string_type > () const
+        {
+            return get();
+        }
+
+        optional< string_type > get() const
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->template get_optional< string_type >(m_path);
+            else
+                return optional< string_type >();
+        }
+
+        template< typename T >
+        optional< T > get() const
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->template get_optional< T >(m_path);
+            else
+                return optional< T >();
+        }
+
+        operator section_type () const
+        {
+            return get_section();
+        }
+
+        section_type get_section() const
+        {
+            if (m_section.m_ptree)
+                return section_type(m_section.m_ptree->get_child_optional(m_path).get_ptr());
+            else
+                return section_type();
+        }
+
+#if defined(BOOST_LOG_TYPEOF) && !(defined(__GNUC__) && !defined(__INTEL_COMPILER) && !defined(__clang__) && !defined(__PATHSCALE__) && !defined(__GXX_EXPERIMENTAL_CXX0X__) && (__GNUC__ == 4 && __GNUC_MINOR__ <= 5))
+#if !defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
+        template< typename T >
+        auto or_default(T const& def_value) const -> BOOST_LOG_TYPEOF(property_tree_type().get(typename property_tree_type::path_type(), def_value))
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->get(m_path, def_value);
+            else
+                return def_value;
+        }
+#else
+        // GCC up to 4.5 (inclusively) segfaults on the following code, if C++11 mode is not enabled
+        template< typename T >
+        BOOST_LOG_TYPEOF(property_tree_type().get(typename property_tree_type::path_type(), boost::declval< T >())) or_default(T const& def_value) const
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->get(m_path, def_value);
+            else
+                return def_value;
+        }
+#endif
+#else
+        template< typename T >
+        T or_default(T const& def_value) const
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->get(m_path, def_value);
+            else
+                return def_value;
+        }
+
+        template< typename T >
+        typename enable_if< boost::property_tree::detail::is_character< T >, std::basic_string< T > >::type
+        or_default(const T* def_value) const
+        {
+            if (m_section.m_ptree)
+                return m_section.m_ptree->get(m_path, def_value);
+            else
+                return def_value;
+        }
+#endif
+        string_type or_default(string_type const& def_value) const
+        {
+            return get().get_value_or(def_value);
+        }
+        string_type or_default(typename string_type::value_type const* def_value) const
+        {
+            if (optional< string_type > val = get())
+                return val.get();
+            else
+                return def_value;
+        }
+    };
+
+    //! An iterator over subsections and parameters
+#ifndef BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS
+    template< bool IsConstV >
+    class iter;
+    template< bool IsConstV >
+    friend class iter;
+#endif
+    template< bool IsConstV >
+    class iter :
+        public aux::basic_settings_section_iterator_base< basic_settings_section< char_type >, IsConstV >::type
+    {
+        friend class boost::iterator_core_access;
+
+        typedef typename iter::iterator_adaptor_ iterator_adaptor_;
+        // NOTE: This typedef must not come from iterator_adaptor_::base_type in order to work around MSVC 10 ICE
+        typedef typename aux::basic_settings_section_iterator_base< basic_settings_section< char_type >, IsConstV >::base_iterator_type base_iterator_type;
+
+    public:
+        typedef typename iterator_adaptor_::reference reference;
+
+    public:
+        BOOST_DEFAULTED_FUNCTION(iter(), {})
+        template< bool OtherIsConstV >
+        iter(iter< OtherIsConstV > const& that) : iterator_adaptor_(that.base()) {}
+        explicit iter(base_iterator_type const& it) : iterator_adaptor_(it) {}
+
+        //! Returns the section name
+        std::string const& get_name() const
+        {
+            return this->base()->first;
+        }
+
+    private:
+        reference dereference() const
+        {
+            return reference(const_cast< property_tree_type* >(&this->base()->second));
+        }
+    };
+
+public:
+    typedef ref< true > const_reference;
+    typedef ref< false > reference;
+    typedef iter< true > const_iterator;
+    typedef iter< false > iterator;
+    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+    typedef std::reverse_iterator< iterator > reverse_iterator;
+
+#else
+
+public:
+    /*!
+     * Constant reference to the parameter value
+     */
+    typedef implementation_defined const_reference;
+    /*!
+     * Mutable reference to the parameter value
+     */
+    typedef implementation_defined reference;
+
+    /*!
+     * Constant iterator over nested parameters and subsections
+     */
+    typedef implementation_defined const_iterator;
+    /*!
+     * Mutable iterator over nested parameters and subsections
+     */
+    typedef implementation_defined iterator;
+
+#endif // !defined(BOOST_LOG_DOXYGEN_PASS)
+
+protected:
+    //! Parameters
+    property_tree_type* m_ptree;
+
+public:
+    /*!
+     * Default constructor. Creates an empty settings container.
+     */
+    basic_settings_section() : m_ptree(NULL)
+    {
+    }
+
+    /*!
+     * Copy constructor.
+     */
+    basic_settings_section(basic_settings_section const& that) : m_ptree(that.m_ptree)
+    {
+    }
+
+    /*!
+     * Checks if the section refers to the container.
+     */
+    BOOST_EXPLICIT_OPERATOR_BOOL()
+
+    /*!
+     * Checks if the section refers to the container.
+     */
+    bool operator! () const { return !m_ptree; }
+
+    /*!
+     * Returns an iterator over the nested subsections and parameters.
+     */
+    iterator begin()
+    {
+        if (m_ptree)
+            return iterator(m_ptree->begin());
+        else
+            return iterator();
+    }
+
+    /*!
+     * Returns an iterator over the nested subsections and parameters.
+     */
+    iterator end()
+    {
+        if (m_ptree)
+            return iterator(m_ptree->end());
+        else
+            return iterator();
+    }
+
+    /*!
+     * Returns an iterator over the nested subsections and parameters.
+     */
+    const_iterator begin() const
+    {
+        if (m_ptree)
+            return const_iterator(m_ptree->begin());
+        else
+            return const_iterator();
+    }
+
+    /*!
+     * Returns an iterator over the nested subsections and parameters.
+     */
+    const_iterator end() const
+    {
+        if (m_ptree)
+            return const_iterator(m_ptree->end());
+        else
+            return const_iterator();
+    }
+
+    /*!
+     * Returns a reverse iterator over the nested subsections and parameters.
+     */
+    reverse_iterator rbegin() { return reverse_iterator(begin()); }
+
+    /*!
+     * Returns a reverse iterator over the nested subsections and parameters.
+     */
+    reverse_iterator rend() { return reverse_iterator(end()); }
+
+    /*!
+     * Returns a reverse iterator over the nested subsections and parameters.
+     */
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(begin()); }
+
+    /*!
+     * Returns a reverse iterator over the nested subsections and parameters.
+     */
+    const_reverse_iterator rend() const { return const_reverse_iterator(end()); }
+
+    /*!
+     * Checks if the container is empty (i.e. contains no sections and parameters).
+     */
+    bool empty() const { return m_ptree == NULL || m_ptree->empty(); }
+
+    /*!
+     * Accessor to a single parameter. This operator should be used in conjunction
+     * with the subsequent subscript operator that designates the parameter name.
+     *
+     * \param section_name The name of the section in which the parameter resides
+     * \return An unspecified reference type that can be used for parameter name specifying
+     */
+    reference operator[] (std::string const& section_name) { return reference(*this, section_name); }
+    /*!
+     * Accessor to a single parameter. This operator should be used in conjunction
+     * with the subsequent subscript operator that designates the parameter name.
+     *
+     * \param section_name The name of the section in which the parameter resides
+     * \return An unspecified reference type that can be used for parameter name specifying
+     */
+    const_reference operator[] (std::string const& section_name) const { return const_reference(*this, section_name); }
+
+    /*!
+     * Accessor to a single parameter. This operator should be used in conjunction
+     * with the subsequent subscript operator that designates the parameter name.
+     *
+     * \param section_name The name of the section in which the parameter resides
+     * \return An unspecified reference type that can be used for parameter name specifying
+     */
+    reference operator[] (const char* section_name) { return reference(*this, section_name); }
+    /*!
+     * Accessor to a single parameter. This operator should be used in conjunction
+     * with the subsequent subscript operator that designates the parameter name.
+     *
+     * \param section_name The name of the section in which the parameter resides
+     * \return An unspecified reference type that can be used for parameter name specifying
+     */
+    const_reference operator[] (const char* section_name) const { return const_reference(*this, section_name); }
+
+    /*!
+     * Accessor for the embedded property tree
+     */
+    property_tree_type const& property_tree() const { return *m_ptree; }
+    /*!
+     * Accessor for the embedded property tree
+     */
+    property_tree_type& property_tree() { return *m_ptree; }
+
+    /*!
+     * Checks if the specified section is present in the container.
+     *
+     * \param section_name The name of the section
+     */
+    bool has_section(string_type const& section_name) const
+    {
+        return m_ptree != NULL && !!m_ptree->get_child_optional(section_name);
+    }
+    /*!
+     * Checks if the specified parameter is present in the container.
+     *
+     * \param section_name The name of the section in which the parameter resides
+     * \param param_name The name of the parameter
+     */
+    bool has_parameter(string_type const& section_name, string_type const& param_name) const
+    {
+        if (m_ptree)
+        {
+            optional< property_tree_type& > section = m_ptree->get_child_optional(section_name);
+            if (!!section)
+                return (section->find(param_name) != section->not_found());
+        }
+
+        return false;
+    }
+
+    /*!
+     * Swaps two references to settings sections.
+     */
+    void swap(basic_settings_section& that)
+    {
+        property_tree_type* const p = m_ptree;
+        m_ptree = that.m_ptree;
+        that.m_ptree = p;
+    }
+
+protected:
+    explicit basic_settings_section(property_tree_type* tree) : m_ptree(tree)
+    {
+    }
+};
+
+template< typename CharT >
+inline void swap(basic_settings_section< CharT >& left, basic_settings_section< CharT >& right)
+{
+    left.swap(right);
+}
+
+
+/*!
+ * \brief The class represents settings container
+ *
+ * All settings are presented as a number of named parameters divided into named sections.
+ * The parameters values are stored as strings. Individual parameters may be queried via subscript operators, like this:
+ *
+ * <code><pre>
+ * optional< string > param = settings["Section1"]["Param1"]; // reads parameter "Param1" in section "Section1"
+ *                                                            // returns an empty value if no such parameter exists
+ * settings["Section2"]["Param2"] = 10; // sets the parameter "Param2" in section "Section2"
+ *                                      // to value "10"
+ * </pre></code>
+ *
+ * There are also other methods to work with parameters.
+ */
+template< typename CharT >
+class basic_settings :
+    public basic_settings_section< CharT >
+{
+    typedef basic_settings this_type;
+    BOOST_COPYABLE_AND_MOVABLE(this_type)
+
+public:
+    //! Section type
+    typedef basic_settings_section< CharT > section;
+    //! Property tree type
+    typedef typename section::property_tree_type property_tree_type;
+
+public:
+    /*!
+     * Default constructor. Creates an empty settings container.
+     */
+    basic_settings() : section(new property_tree_type())
+    {
+    }
+
+    /*!
+     * Copy constructor.
+     */
+    basic_settings(basic_settings const& that) :
+        section(that.m_ptree ? new property_tree_type(*that.m_ptree) : static_cast< property_tree_type* >(NULL))
+    {
+    }
+
+    /*!
+     * Move constructor.
+     */
+    basic_settings(BOOST_RV_REF(this_type) that)
+    {
+        this->swap(that);
+    }
+    /*!
+     * Initializing constructor. Creates a settings container with the copy of the specified property tree.
+     */
+    explicit basic_settings(property_tree_type const& tree) : section(new property_tree_type(tree))
+    {
+    }
+
+    /*!
+     * Destructor
+     */
+    ~basic_settings()
+    {
+        delete this->m_ptree;
+    }
+
+    /*!
+     * Copy assignment operator.
+     */
+    basic_settings& operator= (BOOST_COPY_ASSIGN_REF(basic_settings) that)
+    {
+        if (this != &that)
+        {
+            basic_settings tmp = that;
+            this->swap(tmp);
+        }
+        return *this;
+    }
+    /*!
+     * Move assignment operator.
+     */
+    basic_settings& operator= (BOOST_RV_REF(basic_settings) that)
+    {
+        this->swap(that);
+        return *this;
+    }
+};
+
+#ifdef BOOST_LOG_USE_CHAR
+typedef basic_settings< char > settings;                        //!< Convenience typedef for narrow-character logging
+typedef basic_settings_section< char > settings_section;        //!< Convenience typedef for narrow-character logging
+#endif
+#ifdef BOOST_LOG_USE_WCHAR_T
+typedef basic_settings< wchar_t > wsettings;                    //!< Convenience typedef for wide-character logging
+typedef basic_settings_section< wchar_t > wsettings_section;    //!< Convenience typedef for wide-character logging
+#endif
+
+BOOST_LOG_CLOSE_NAMESPACE // namespace log
+
+} // namespace boost
+
+#include <boost/log/detail/footer.hpp>
+
+#endif // BOOST_LOG_UTILITY_SETUP_SETTINGS_HPP_INCLUDED_