/Src/Dependencies/Boost/boost/interprocess/detail/variadic_templates_tools.hpp
http://hadesmem.googlecode.com/ · C++ Header · 153 lines · 102 code · 34 blank · 17 comment · 1 complexity · c1145bb7eeb8744b87db22d9ef867a5f MD5 · raw file
- //////////////////////////////////////////////////////////////////////////////
- //
- // (C) Copyright Ion Gaztanaga 2008-2009. 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/interprocess for documentation.
- //
- //////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_INTERPROCESS_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
- #define BOOST_INTERPROCESS_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP
- #if (defined _MSC_VER) && (_MSC_VER >= 1200)
- # pragma once
- #endif
- #include <boost/interprocess/detail/config_begin.hpp>
- #include <boost/interprocess/detail/workaround.hpp>
- #include <boost/interprocess/detail/type_traits.hpp>
- #include <cstddef> //std::size_t
- namespace boost {
- namespace interprocess {
- namespace detail {
- template<typename... Values>
- class tuple;
- template<> class tuple<>
- {};
- template<typename Head, typename... Tail>
- class tuple<Head, Tail...>
- : private tuple<Tail...>
- {
- typedef tuple<Tail...> inherited;
- public:
- tuple() { }
- // implicit copy-constructor is okay
- // Construct tuple from separate arguments.
- tuple(typename add_const_reference<Head>::type v,
- typename add_const_reference<Tail>::type... vtail)
- : inherited(vtail...), m_head(v)
- {}
- // Construct tuple from another tuple.
- template<typename... VValues>
- tuple(const tuple<VValues...>& other)
- : m_head(other.head()), inherited(other.tail())
- {}
- template<typename... VValues>
- tuple& operator=(const tuple<VValues...>& other)
- {
- m_head = other.head();
- tail() = other.tail();
- return this;
- }
- typename add_reference<Head>::type head() { return m_head; }
- typename add_reference<const Head>::type head() const { return m_head; }
- inherited& tail() { return *this; }
- const inherited& tail() const { return *this; }
- protected:
- Head m_head;
- };
- template<typename... Values>
- tuple<Values&&...> tie_forward(Values&&... values)
- { return tuple<Values&&...>(values...); }
- template<int I, typename Tuple>
- struct tuple_element;
- template<int I, typename Head, typename... Tail>
- struct tuple_element<I, tuple<Head, Tail...> >
- {
- typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
- };
- template<typename Head, typename... Tail>
- struct tuple_element<0, tuple<Head, Tail...> >
- {
- typedef Head type;
- };
- template<int I, typename Tuple>
- class get_impl;
- template<int I, typename Head, typename... Values>
- class get_impl<I, tuple<Head, Values...> >
- {
- typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
- typedef get_impl<I-1, tuple<Values...> > Next;
- public:
- typedef typename add_reference<Element>::type type;
- typedef typename add_const_reference<Element>::type const_type;
- static type get(tuple<Head, Values...>& t) { return Next::get(t.tail()); }
- static const_type get(const tuple<Head, Values...>& t) { return Next::get(t.tail()); }
- };
- template<typename Head, typename... Values>
- class get_impl<0, tuple<Head, Values...> >
- {
- public:
- typedef typename add_reference<Head>::type type;
- typedef typename add_const_reference<Head>::type const_type;
- static type get(tuple<Head, Values...>& t) { return t.head(); }
- static const_type get(const tuple<Head, Values...>& t){ return t.head(); }
- };
- template<int I, typename... Values>
- typename get_impl<I, tuple<Values...> >::type get(tuple<Values...>& t)
- { return get_impl<I, tuple<Values...> >::get(t); }
- template<int I, typename... Values>
- typename get_impl<I, tuple<Values...> >::const_type get(const tuple<Values...>& t)
- { return get_impl<I, tuple<Values...> >::get(t); }
- ////////////////////////////////////////////////////
- // Builds an index_tuple<0, 1, 2, ..., Num-1>, that will
- // be used to "unpack" into comma-separated values
- // in a function call.
- ////////////////////////////////////////////////////
- template<int... Indexes>
- struct index_tuple{};
- template<std::size_t Num, typename Tuple = index_tuple<> >
- struct build_number_seq;
- template<std::size_t Num, int... Indexes>
- struct build_number_seq<Num, index_tuple<Indexes...> >
- : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
- {};
- template<int... Indexes>
- struct build_number_seq<0, index_tuple<Indexes...> >
- { typedef index_tuple<Indexes...> type; };
- }}} //namespace boost { namespace interprocess { namespace detail {
- #include <boost/interprocess/detail/config_end.hpp>
- #endif //#ifndef BOOST_INTERPROCESS_DETAIL_VARIADIC_TEMPLATES_TOOLS_HPP