1 files changed, 575 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/spirit/home/support/container.hpp b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp
new file mode 100644
index 0000000..7f491aa
--- /dev/null
+++ b/3rdParty/Boost/src/boost/spirit/home/support/container.hpp
@@ -0,0 +1,575 @@
+/*=============================================================================
+    Copyright (c) 2001-2011 Joel de Guzman
+    Copyright (c) 2001-2011 Hartmut Kaiser
+    http://spirit.sourceforge.net/
+
+    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)
+=============================================================================*/
+#if !defined(BOOST_SPIRIT_CONTAINER_FEBRUARY_06_2007_1001AM)
+#define BOOST_SPIRIT_CONTAINER_FEBRUARY_06_2007_1001AM
+
+#if defined(_MSC_VER)
+#pragma once
+#endif
+
+#include <boost/spirit/home/support/unused.hpp>
+#include <boost/spirit/home/support/attributes_fwd.hpp>
+#include <boost/detail/iterator.hpp> // for boost::detail::iterator_traits
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/optional.hpp>
+#include <boost/variant.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost { namespace spirit { namespace traits
+{
+    ///////////////////////////////////////////////////////////////////////////
+    //  This file contains some container utils for stl containers. The
+    //  utilities provided also accept spirit's unused_type; all no-ops.
+    //  Compiler optimization will easily strip these away.
+    ///////////////////////////////////////////////////////////////////////////
+
+    namespace detail
+    {
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(value_type)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(iterator)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(reference)
+    }
+
+    template <typename T, typename Enable/* = void*/>
+    struct is_container
+      : mpl::bool_<
+            detail::has_value_type<T>::value &&
+            detail::has_iterator<T>::value &&
+            detail::has_size_type<T>::value &&
+            detail::has_reference<T>::value>
+    {};
+
+    template <typename T>
+    struct is_container<T&>
+      : is_container<T>
+    {};
+
+    template <typename T>
+    struct is_container<boost::optional<T> >
+      : is_container<T>
+    {};
+
+#define BOOST_SPIRIT_IS_CONTAINER(z, N, data)                                 \
+        is_container<BOOST_PP_CAT(T, N)>::value ||                            \
+    /***/
+
+    // make sure unused variant parameters do not affect the outcome
+    template <>
+    struct is_container<boost::detail::variant::void_>
+      : mpl::false_
+    {};
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct is_container<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+       : mpl::bool_<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_SPIRIT_IS_CONTAINER, _) false>
+    {};
+
+#undef BOOST_SPIRIT_IS_CONTAINER
+
+    template <typename T, typename Enable/* = void*/>
+    struct is_iterator_range
+      : mpl::false_
+    {};
+
+    template <typename T>
+    struct is_iterator_range<iterator_range<T> >
+      : mpl::true_
+    {};
+
+    ///////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+        template <typename T>
+        struct remove_value_const
+        {
+            typedef T type;
+        };
+
+        template <typename T>
+        struct remove_value_const<T const>
+          : remove_value_const<T>
+        {};
+
+        template <typename F, typename S>
+        struct remove_value_const<std::pair<F, S> >
+        {
+            typedef typename remove_value_const<F>::type first_type;
+            typedef typename remove_value_const<S>::type second_type;
+            typedef std::pair<first_type, second_type> type;
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////
+    //[customization_container_value_default
+    template <typename Container, typename Enable/* = void*/>
+    struct container_value
+      : detail::remove_value_const<typename Container::value_type>
+    {};
+    //]
+
+    template <typename T>
+    struct container_value<T&>
+      : container_value<T>
+    {};
+
+    // this will be instantiated if the optional holds a container
+    template <typename T>
+    struct container_value<boost::optional<T> >
+      : container_value<T>
+    {};
+
+    // this will be instantiated if the variant holds a container
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct container_value<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    {
+        typedef typename
+            variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types
+        types;
+        typedef typename
+            mpl::find_if<types, is_container<mpl::_1> >::type
+        iter;
+
+        typedef typename container_value<
+            typename mpl::if_<
+                is_same<iter, typename mpl::end<types>::type>
+              , unused_type, typename mpl::deref<iter>::type
+            >::type
+        >::type type;
+    };
+
+    //[customization_container_value_unused
+    template <>
+    struct container_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+    //]
+
+    template <>
+    struct container_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct container_iterator
+    {
+        typedef typename Container::iterator type;
+    };
+
+    template <typename Container>
+    struct container_iterator<Container&>
+      : container_iterator<Container>
+    {};
+
+    template <typename Container>
+    struct container_iterator<Container const>
+    {
+        typedef typename Container::const_iterator type;
+    };
+
+    template <typename T>
+    struct container_iterator<optional<T> >
+      : container_iterator<T>
+    {};
+
+    template <typename T>
+    struct container_iterator<optional<T> const>
+      : container_iterator<T const>
+    {};
+
+    template <typename Iterator>
+    struct container_iterator<iterator_range<Iterator> >
+    {
+        typedef typename range_const_iterator<
+              iterator_range<Iterator> >::type type;
+    };
+
+    template <>
+    struct container_iterator<unused_type>
+    {
+        typedef unused_type const* type;
+    };
+
+    template <>
+    struct container_iterator<unused_type const>
+    {
+        typedef unused_type const* type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T, typename Enable/* = void*/>
+    struct optional_attribute
+    {
+        typedef T const& type;
+
+        static type call(T const& val)
+        {
+            return val;
+        }
+
+        static bool is_valid(T const&)
+        {
+            return true;
+        }
+    };
+
+    template <typename T>
+    struct optional_attribute<boost::optional<T> >
+    {
+        typedef T const& type;
+
+        static type call(boost::optional<T> const& val)
+        {
+            return boost::get<T>(val);
+        }
+
+        static bool is_valid(boost::optional<T> const& val)
+        {
+            return val;
+        }
+    };
+
+    template <typename T>
+    typename optional_attribute<T>::type
+    optional_value(T const& val)
+    {
+        return optional_attribute<T>::call(val);
+    }
+
+    inline unused_type optional_value(unused_type)
+    {
+        return unused;
+    }
+
+    template <typename T>
+    bool has_optional_value(T const& val)
+    {
+        return optional_attribute<T>::is_valid(val);
+    }
+
+    inline bool has_optional_value(unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val);
+
+    //[customization_push_back_default
+    template <typename Container, typename T, typename Enable/* = void*/>
+    struct push_back_container
+    {
+        static bool call(Container& c, T const& val)
+        {
+            c.insert(c.end(), val);
+            return true;
+        }
+    };
+    //]
+
+    template <typename Container, typename T>
+    struct push_back_container<optional<Container>, T>
+    {
+        static bool call(boost::optional<Container>& c, T const& val)
+        {
+            if (!c)
+                c = Container();
+            return push_back(boost::get<Container>(c), val);
+        }
+    };
+
+    namespace detail
+    {
+        template <typename T>
+        struct push_back_visitor : public static_visitor<>
+        {
+            typedef bool result_type;
+
+            push_back_visitor(T const& t) : t_(t) {}
+
+            template <typename Container>
+            bool push_back_impl(Container& c, mpl::true_) const
+            {
+                return push_back(c, t_);
+            }
+
+            template <typename T_>
+            bool push_back_impl(T_&, mpl::false_) const
+            {
+                // this variant doesn't hold a container
+                BOOST_ASSERT(false && "This variant doesn't hold a container");
+                return false;
+            }
+
+            template <typename T_>
+            bool operator()(T_& c) const
+            {
+                return push_back_impl(c, typename is_container<T_>::type());
+            }
+
+            T const& t_;
+        };
+    }
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T_), typename T>
+    struct push_back_container<variant<BOOST_VARIANT_ENUM_PARAMS(T_)>, T>
+    {
+        static bool call(variant<BOOST_VARIANT_ENUM_PARAMS(T_)>& c, T const& val)
+        {
+            return apply_visitor(detail::push_back_visitor<T>(val), c);
+        }
+    };
+
+    template <typename Container, typename T>
+    bool push_back(Container& c, T const& val)
+    {
+        return push_back_container<Container, T>::call(c, val);
+    }
+
+    //[customization_push_back_unused
+    template <typename Container>
+    bool push_back(Container&, unused_type)
+    {
+        return true;
+    }
+    //]
+
+    template <typename T>
+    bool push_back(unused_type, T const&)
+    {
+        return true;
+    }
+
+    inline bool push_back(unused_type, unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct is_empty_container
+    {
+        static bool call(Container const& c)
+        {
+            return c.empty();
+        }
+    };
+
+    template <typename Container>
+    bool is_empty(Container const& c)
+    {
+        return is_empty_container<Container>::call(c);
+    }
+
+    inline bool is_empty(unused_type)
+    {
+        return true;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Ensure the attribute is actually a container type
+    template <typename Container, typename Enable/* = void*/>
+    struct make_container_attribute
+    {
+        static void call(Container&)
+        {
+            // for static types this function does nothing
+        }
+    };
+
+    template <typename T>
+    void make_container(T& t)
+    {
+        make_container_attribute<T>::call(t);
+    }
+
+    inline void make_container(unused_type)
+    {
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct begin_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.begin();
+        }
+    };
+
+    template <typename Container>
+    typename spirit::result_of::begin<Container>::type
+    begin(Container& c)
+    {
+        return begin_container<Container>::call(c);
+    }
+
+    inline unused_type const*
+    begin(unused_type)
+    {
+        return &unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container, typename Enable/* = void*/>
+    struct end_container
+    {
+        static typename container_iterator<Container>::type call(Container& c)
+        {
+            return c.end();
+        }
+    };
+
+    template <typename Container>
+    inline typename spirit::result_of::end<Container>::type
+    end(Container& c)
+    {
+        return end_container<Container>::call(c);
+    }
+
+    inline unused_type const*
+    end(unused_type)
+    {
+        return &unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct deref_iterator
+    {
+        typedef typename boost::detail::iterator_traits<Iterator>::reference type;
+        static type call(Iterator& it)
+        {
+            return *it;
+        }
+    };
+
+    template <typename Iterator>
+    typename deref_iterator<Iterator>::type
+    deref(Iterator& it)
+    {
+        return deref_iterator<Iterator>::call(it);
+    }
+
+    inline unused_type
+    deref(unused_type const*)
+    {
+        return unused;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct next_iterator
+    {
+        static void call(Iterator& it)
+        {
+            ++it;
+        }
+    };
+
+    template <typename Iterator>
+    void next(Iterator& it)
+    {
+        next_iterator<Iterator>::call(it);
+    }
+
+    inline void next(unused_type const*)
+    {
+        // do nothing
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Iterator, typename Enable/* = void*/>
+    struct compare_iterators
+    {
+        static bool call(Iterator const& it1, Iterator const& it2)
+        {
+            return it1 == it2;
+        }
+    };
+
+    template <typename Iterator>
+    bool compare(Iterator& it1, Iterator& it2)
+    {
+        return compare_iterators<Iterator>::call(it1, it2);
+    }
+
+    inline bool compare(unused_type const*, unused_type const*)
+    {
+        return false;
+    }
+}}}
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit { namespace result_of
+{
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename T>
+    struct optional_value
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct optional_value<boost::optional<T> >
+    {
+        typedef T type;
+    };
+
+    template <typename T>
+    struct optional_value<boost::optional<T> const>
+    {
+        typedef T const type;
+    };
+
+    template <>
+    struct optional_value<unused_type>
+    {
+        typedef unused_type type;
+    };
+
+    template <>
+    struct optional_value<unused_type const>
+    {
+        typedef unused_type type;
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+    template <typename Container>
+    struct begin
+      : traits::container_iterator<Container>
+    {};
+
+    template <typename Container>
+    struct end
+      : traits::container_iterator<Container>
+    {};
+
+    template <typename Iterator>
+    struct deref
+      : traits::deref_iterator<Iterator>
+    {};
+
+    template <>
+    struct deref<unused_type const*>
+    {
+        typedef unused_type type;
+    };
+
+}}}
+
+#endif