add boost on mac

macx64/include/boost/test/utils/is_forward_iterable.hpp

@@ -0,0 +1,267 @@
+//  (C) Copyright Gennadiy Rozental 2001.
+//  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)
+
+//  See http://www.boost.org/libs/test for the library home page.
+//
+//! @file
+//! Defines the is_forward_iterable collection type trait
+// ***************************************************************************
+
+#ifndef BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP
+#define BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP
+
+#if defined(BOOST_NO_CXX11_DECLTYPE) || \
+    defined(BOOST_NO_CXX11_NULLPTR) || \
+    defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
+
+  // this feature works with VC2012 upd 5 while BOOST_NO_CXX11_TRAILING_RESULT_TYPES is defined
+  #if !defined(BOOST_MSVC) || BOOST_MSVC_FULL_VER < 170061232 /* VC2012 upd 5 */
+    #define BOOST_TEST_FWD_ITERABLE_CXX03
+  #endif
+#endif
+
+#if defined(BOOST_TEST_FWD_ITERABLE_CXX03)
+// Boost
+#include <boost/mpl/bool.hpp>
+
+// STL
+#include <list>
+#include <vector>
+#include <map>
+#include <set>
+
+#else
+
+// Boost
+#include <boost/static_assert.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/test/utils/is_cstring.hpp>
+
+// STL
+#include <utility>
+#include <type_traits>
+
+#endif
+//____________________________________________________________________________//
+
+namespace boost {
+namespace unit_test {
+
+template<typename T>
+struct is_forward_iterable;
+
+// ************************************************************************** //
+// **************             is_forward_iterable              ************** //
+// ************************************************************************** //
+
+#if defined(BOOST_TEST_FWD_ITERABLE_CXX03) && !defined(BOOST_TEST_DOXYGEN_DOC__)
+template<typename T>
+struct is_forward_iterable : public mpl::false_ {};
+
+template<typename T>
+struct is_forward_iterable<T const> : public is_forward_iterable<T> {};
+
+template<typename T>
+struct is_forward_iterable<T&> : public is_forward_iterable<T> {};
+
+template<typename T, std::size_t N>
+struct is_forward_iterable< T [N] > : public mpl::true_ {};
+
+template<typename T, typename A>
+struct is_forward_iterable< std::vector<T, A> > : public mpl::true_ {};
+
+template<typename T, typename A>
+struct is_forward_iterable< std::list<T, A> > : public mpl::true_ {};
+
+template<typename K, typename V, typename C, typename A>
+struct is_forward_iterable< std::map<K, V, C, A> > : public mpl::true_ {};
+
+template<typename K, typename C, typename A>
+struct is_forward_iterable< std::set<K, C, A> > : public mpl::true_ {};
+
+// string is also forward iterable, even if sometimes we want to treat the
+// assertions differently.
+template<>
+struct is_forward_iterable< std::string > : public mpl::true_ {};
+
+#else
+
+namespace ut_detail {
+
+// SFINAE helper
+template<typename T>
+struct is_present : public mpl::true_ {};
+
+//____________________________________________________________________________//
+
+// some compiler do not implement properly decltype non expression involving members (eg. VS2013)
+// a workaround is to use -> decltype syntax.
+template <class T>
+struct has_member_size {
+private:
+    struct nil_t {};
+    template<typename U> static auto  test( U* ) -> decltype(boost::declval<U>().size());
+    template<typename>   static nil_t test( ... );
+
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+//____________________________________________________________________________//
+
+template <class T>
+struct has_member_begin {
+private:
+    struct nil_t {};
+    template<typename U>  static auto  test( U* ) -> decltype(std::begin(boost::declval<U&>())); // does not work with boost::begin
+    template<typename>    static nil_t test( ... );
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+//____________________________________________________________________________//
+
+template <class T>
+struct has_member_end {
+private:
+    struct nil_t {};
+    template<typename U>  static auto  test( U* ) -> decltype(std::end(boost::declval<U&>())); // does not work with boost::end
+    template<typename>    static nil_t test( ... );
+public:
+    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
+};
+
+//____________________________________________________________________________//
+
+template <class T, class enabled = void>
+struct is_forward_iterable_impl : std::false_type {
+};
+
+template <class T>
+struct is_forward_iterable_impl<
+    T,
+    typename std::enable_if<
+      has_member_begin<T>::value &&
+      has_member_end<T>::value
+    >::type
+> : std::true_type
+{};
+
+//____________________________________________________________________________//
+
+template <class T, class enabled = void>
+struct is_container_forward_iterable_impl : std::false_type {
+};
+
+template <class T>
+struct is_container_forward_iterable_impl<
+    T,
+    typename std::enable_if<
+      is_present<typename T::const_iterator>::value &&
+      is_present<typename T::value_type>::value &&
+      has_member_size<T>::value &&
+      is_forward_iterable_impl<T>::value
+    >::type
+> : is_forward_iterable_impl<T>
+{};
+
+//____________________________________________________________________________//
+
+} // namespace ut_detail
+
+/*! Indicates that a specific type implements the forward iterable concept. */
+template<typename T>
+struct is_forward_iterable {
+    typedef typename std::remove_reference<T>::type T_ref;
+    typedef ut_detail::is_forward_iterable_impl<T_ref> is_fwd_it_t;
+    typedef mpl::bool_<is_fwd_it_t::value> type;
+    enum { value = is_fwd_it_t::value };
+};
+
+/*! Indicates that a specific type implements the forward iterable concept. */
+template<typename T>
+struct is_container_forward_iterable {
+    typedef typename std::remove_reference<T>::type T_ref;
+    typedef ut_detail::is_container_forward_iterable_impl<T_ref> is_fwd_it_t;
+    typedef mpl::bool_<is_fwd_it_t::value> type;
+    enum { value = is_fwd_it_t::value };
+};
+
+#endif /* defined(BOOST_TEST_FWD_ITERABLE_CXX03) */
+
+
+//! Helper structure for accessing the content of a container or an array
+template <typename T, bool is_forward_iterable = is_forward_iterable<T>::value >
+struct bt_iterator_traits;
+
+template <typename T>
+struct bt_iterator_traits< T, true >{
+    BOOST_STATIC_ASSERT((is_forward_iterable<T>::value));
+
+#if defined(BOOST_TEST_FWD_ITERABLE_CXX03) || \
+    (defined(BOOST_MSVC) && (BOOST_MSVC_FULL_VER <= 170061232))
+    typedef typename T::const_iterator const_iterator;
+    typedef typename std::iterator_traits<const_iterator>::value_type value_type;
+#else
+    typedef decltype(boost::declval<
+        typename boost::add_const<
+          typename boost::remove_reference<T>::type
+        >::type>().begin()) const_iterator;
+
+    typedef typename std::iterator_traits<const_iterator>::value_type value_type;
+#endif /* BOOST_TEST_FWD_ITERABLE_CXX03 */
+
+    static const_iterator begin(T const& container) {
+        return container.begin();
+    }
+    static const_iterator end(T const& container) {
+        return container.end();
+    }
+
+#if defined(BOOST_TEST_FWD_ITERABLE_CXX03) || \
+    (defined(BOOST_MSVC) && (BOOST_MSVC_FULL_VER <= 170061232))
+    static std::size_t
+    size(T const& container) {
+        return container.size();
+    }
+#else
+    static std::size_t
+    size(T const& container) {
+        return size(container,
+                    std::integral_constant<bool, ut_detail::has_member_size<T>::value>());
+    }
+private:
+    static std::size_t
+    size(T const& container, std::true_type)  { return container.size(); }
+
+    static std::size_t
+    size(T const& container, std::false_type) { return std::distance(begin(container), end(container)); }
+#endif /* BOOST_TEST_FWD_ITERABLE_CXX03 */
+};
+
+template <typename T, std::size_t N>
+struct bt_iterator_traits< T [N], true > {
+    typedef typename boost::add_const<T>::type T_const;
+    typedef typename boost::add_pointer<T_const>::type const_iterator;
+    typedef T value_type;
+
+    static const_iterator begin(T_const (&array)[N]) {
+        return &array[0];
+    }
+    static const_iterator end(T_const (&array)[N]) {
+        return &array[N];
+    }
+    static std::size_t size(T_const (&)[N]) {
+        return N;
+    }
+};
+
+} // namespace unit_test
+} // namespace boost
+
+#endif // BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP