diff DEPENDENCIES/generic/include/boost/variant/get.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/variant/get.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,203 @@
+//-----------------------------------------------------------------------------
+// boost variant/get.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman, Itay Maman
+//
+// 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)
+
+#ifndef BOOST_VARIANT_GET_HPP
+#define BOOST_VARIANT_GET_HPP
+
+#include <exception>
+
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+#include "boost/throw_exception.hpp"
+#include "boost/utility/addressof.hpp"
+#include "boost/variant/variant_fwd.hpp"
+
+#include "boost/type_traits/add_reference.hpp"
+#include "boost/type_traits/add_pointer.hpp"
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+#   include "boost/mpl/bool.hpp"
+#   include "boost/mpl/or.hpp"
+#   include "boost/type_traits/is_same.hpp"
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class bad_get
+//
+// The exception thrown in the event of a failed get of a value.
+//
+class bad_get
+    : public std::exception
+{
+public: // std::exception implementation
+
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    {
+        return "boost::bad_get: "
+               "failed value get using boost::get";
+    }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// function template get<T>
+//
+// Retrieves content of given variant object if content is of type T.
+// Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
+//
+
+namespace detail { namespace variant {
+
+// (detail) class template get_visitor
+//
+// Generic static visitor that: if the value is of the specified type,
+// returns a pointer to the value it visits; else a null pointer.
+//
+template <typename T>
+struct get_visitor
+{
+private: // private typedefs
+
+    typedef typename add_pointer<T>::type pointer;
+    typedef typename add_reference<T>::type reference;
+
+public: // visitor typedefs
+
+    typedef pointer result_type;
+
+public: // visitor interfaces
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+
+    pointer operator()(reference operand) const
+    {
+        return boost::addressof(operand);
+    }
+
+    template <typename U>
+    pointer operator()(const U&) const
+    {
+        return static_cast<pointer>(0);
+    }
+
+#else // MSVC6
+
+private: // helpers, for visitor interfaces (below)
+
+    pointer execute_impl(reference operand, mpl::true_) const
+    {
+        return boost::addressof(operand);
+    }
+
+    template <typename U>
+    pointer execute_impl(const U& operand, mpl::false_) const
+    {
+        return static_cast<pointer>(0);
+    }
+
+public: // visitor interfaces
+
+    template <typename U>
+    pointer operator()(U& operand) const
+    {
+        // MSVC6 finds normal implementation (above) ambiguous,
+        // so we must explicitly disambiguate
+
+        typedef typename mpl::or_<
+              is_same<U, T>
+            , is_same<const U, T>
+            >::type U_is_T;
+
+        return execute_impl(operand, U_is_T());
+    }
+
+#endif // MSVC6 workaround
+
+};
+
+}} // namespace detail::variant
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+    BOOST_APPEND_EXPLICIT_TEMPLATE_TYPE(t)
+#else
+#   define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+    , t* = 0
+#endif
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<const U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = get<U>(&operand);
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return *result;
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    U_ptr result = get<const U>(&operand);
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return *result;
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_GET_HPP