uploading some boost libraries (96a68b36) · Commits · Elphel / kicad-source-mirror

include/boost/typeof/dmc/typeof_impl.hpp

0 → 100644

+100 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2007 Peder Holt

			// Use, modification and distribution is subject to the Boost Software
			// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)

			#ifndef BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED
			# define BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED

			# include <boost/config.hpp>
			# include <boost/detail/workaround.hpp>
			# include <boost/mpl/int.hpp>

			namespace boost
			{
			namespace type_of
			{

			template<int N> struct encode_counter : encode_counter<N - 1> {};
			template<> struct encode_counter<0> {};

			char (*encode_index(...))[1];

			# define BOOST_TYPEOF_INDEX(T) (sizeof(boost::type_of::encode_index((boost::type_of::encode_counter<1000>)0)))
			# define BOOST_TYPEOF_NEXT_INDEX(next) friend char (encode_index(encode_counter<next>))[next];


			//Typeof code

			template<typename ID>
			struct msvc_extract_type
			{
			struct id2type;
			};

			template<typename T, typename ID>
			struct msvc_register_type : msvc_extract_type<ID>
			{
			typedef msvc_extract_type<ID> base_type;
			struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature, also works for Digital Mars
			{
			typedef T type;
			};
			};


			template<int ID>
			struct msvc_typeid_wrapper {
			typedef typename msvc_extract_type<mpl::int_<ID> >::id2type id2type;
			typedef typename id2type::type type;
			};

			//Tie it all together
			template<typename T>
			struct encode_type
			{
			//Get the next available compile time constants index
			BOOST_STATIC_CONSTANT(unsigned,value=BOOST_TYPEOF_INDEX(T));
			//Instantiate the template
			typedef typename msvc_register_type<T,mpl::int_<value> >::id2type type;
			//Set the next compile time constants index
			BOOST_STATIC_CONSTANT(unsigned,next=value+1);
			//Increment the compile time constant (only needed when extensions are not active
			BOOST_TYPEOF_NEXT_INDEX(next);
			};

			template<class T>
			struct sizer
			{
			typedef char(*type)[encode_type<T>::value];
			};

			template<typename T>
			typename sizer<T>::type encode_start(T const&);

			template<typename Organizer, typename T>
			msvc_register_type<T,Organizer> typeof_register_type(const T&,Organizer* =0);

			# define BOOST_TYPEOF(expr) \
			boost::type_of::msvc_typeid_wrapper<sizeof(*boost::type_of::encode_start(expr))>::type

			# define BOOST_TYPEOF_TPL(expr) typename BOOST_TYPEOF(expr)

			# define BOOST_TYPEOF_NESTED_TYPEDEF_TPL(name,expr) \
			struct name {\
			BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
			typedef typename boost::type_of::msvc_extract_type<name>::id2type id2type;\
			typedef typename id2type::type type;\
			};

			# define BOOST_TYPEOF_NESTED_TYPEDEF(name,expr) \
			struct name {\
			BOOST_STATIC_CONSTANT(int,_typeof_register_value=sizeof(boost::type_of::typeof_register_type<name>(expr)));\
			typedef boost::type_of::msvc_extract_type<name>::id2type id2type;\
			typedef id2type::type type;\
			};

			}
			}

			#endif//BOOST_TYPEOF_MSVC_TYPEOF_IMPL_HPP_INCLUDED

include/boost/typeof/encode_decode.hpp

0 → 100644

+61 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2004 Arkadiy Vertleyb

			// 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)

			// boostinspect:nounnamed

			#ifndef BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED
			#define BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED

			#include <boost/mpl/deref.hpp>
			#include <boost/mpl/next.hpp>

			#ifndef BOOST_TYPEOF_SUPPRESS_UNNAMED_NAMESPACE

			# define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace { namespace boost_typeof {
			# define BOOST_TYPEOF_END_ENCODE_NS }}
			# define BOOST_TYPEOF_ENCODE_NS_QUALIFIER boost_typeof

			#else

			# define BOOST_TYPEOF_BEGIN_ENCODE_NS namespace boost { namespace type_of {
			# define BOOST_TYPEOF_END_ENCODE_NS }}
			# define BOOST_TYPEOF_ENCODE_NS_QUALIFIER boost::type_of

			# define BOOST_TYPEOF_TEXT "unnamed namespace is off"
			# include <boost/typeof/message.hpp>

			#endif

			BOOST_TYPEOF_BEGIN_ENCODE_NS

			template<class V, class Type_Not_Registered_With_Typeof_System>
			struct encode_type_impl;

			template<class T, class Iter>
			struct decode_type_impl
			{
			typedef int type; // MSVC ETI workaround
			};

			template<class T>
			struct decode_nested_template_helper_impl;

			BOOST_TYPEOF_END_ENCODE_NS

			namespace boost { namespace type_of {

			template<class V, class T>
			struct encode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::encode_type_impl<V, T>
			{};

			template<class Iter>
			struct decode_type : BOOST_TYPEOF_ENCODE_NS_QUALIFIER::decode_type_impl<
			typename Iter::type,
			typename Iter::next
			>
			{};
			}}

			#endif//BOOST_TYPEOF_ENCODE_DECODE_HPP_INCLUDED

include/boost/typeof/encode_decode_params.hpp

0 → 100644

+34 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2005 Arkadiy Vertleyb
			// 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_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED
			#define BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED

			#include <boost/preprocessor/cat.hpp>
			#include <boost/preprocessor/repetition/repeat.hpp>

			// Assumes iter0 contains initial iterator

			#define BOOST_TYPEOF_DECODE_PARAM(z, n, text) \
			typedef boost::type_of::decode_type<iter##n> decode##n; \
			typedef typename decode##n::type p##n; \
			typedef typename decode##n::iter BOOST_PP_CAT(iter, BOOST_PP_INC(n));

			#define BOOST_TYPEOF_DECODE_PARAMS(n)\
			BOOST_PP_REPEAT(n, BOOST_TYPEOF_DECODE_PARAM, ~)

			// The P0, P1, ... PN are encoded and added to V

			#define BOOST_TYPEOF_ENCODE_PARAMS_BEGIN(z, n, text)\
			typename boost::type_of::encode_type<

			#define BOOST_TYPEOF_ENCODE_PARAMS_END(z, n, text)\
			, BOOST_PP_CAT(P, n)>::type

			#define BOOST_TYPEOF_ENCODE_PARAMS(n, ID) \
			BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_BEGIN, ~) \
			typename boost::type_of::push_back<V, boost::mpl::size_t<ID> >::type \
			BOOST_PP_REPEAT(n, BOOST_TYPEOF_ENCODE_PARAMS_END, ~)

			#endif//BOOST_TYPEOF_ENCODE_DECODE_PARAMS_HPP_INCLUDED

include/boost/typeof/incr_registration_group.hpp

0 → 100644

+14 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2004, 2005 Arkadiy Vertleyb
			// Use, modification and distribution is subject to the Boost Software
			// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)

			// Inclusion of this file increments BOOST_TYPEOF_REGISTRATION_GROUP
			// This method was suggested by Paul Mensonides

			#ifdef BOOST_TYPEOF_EMULATION
			# undef BOOST_TYPEOF_REGISTRATION_GROUP

			# include <boost/preprocessor/slot/counter.hpp>
			# include BOOST_PP_UPDATE_COUNTER()
			# define BOOST_TYPEOF_REGISTRATION_GROUP BOOST_PP_COUNTER
			#endif

include/boost/typeof/int_encoding.hpp

0 → 100644

+118 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2004 Arkadiy Vertleyb
			// Use, modification and distribution is subject to the Boost Software
			// License, Version 1.0. (http://www.boost.org/LICENSE_1_0.txt)

			#ifndef BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED
			#define BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED

			#include <boost/mpl/if.hpp>
			#include <boost/mpl/size_t.hpp>
			#include <boost/config.hpp>

			namespace boost { namespace type_of {

			template<class T> struct get_unsigned
			{
			typedef T type;
			};
			template<> struct get_unsigned<signed char>
			{
			typedef unsigned char type;
			};
			template<> struct get_unsigned<char>
			{
			typedef unsigned char type;
			};
			template<> struct get_unsigned<short>
			{
			typedef unsigned short type;
			};
			template<> struct get_unsigned<int>
			{
			typedef unsigned int type;
			};
			template<> struct get_unsigned<long>
			{
			typedef unsigned long type;
			};

			//////////////////////////

			template<std::size_t n, bool Overflow>
			struct pack
			{
			BOOST_STATIC_CONSTANT(std::size_t , value=((n + 1) * 2 + (Overflow ? 1 : 0)));
			};

			template<std::size_t m>
			struct unpack
			{
			BOOST_STATIC_CONSTANT(std::size_t, value = (m / 2) - 1);
			BOOST_STATIC_CONSTANT(std::size_t, overflow = (m % 2 == 1));
			};

			////////////////////////////////

			template<class V, std::size_t n, bool overflow = (n >= 0x3fffffff)>
			struct encode_size_t : push_back<
			V,
			boost::mpl::size_t<pack<n, false>::value>
			>
			{};

			template<class V, std::size_t n>
			struct encode_size_t<V, n, true> : push_back<typename push_back<
			V,
			boost::mpl::size_t<pack<n % 0x3ffffffe, true>::value> >::type,
			boost::mpl::size_t<n / 0x3ffffffe>
			>
			{};

			template<class V, class T, T n>
			struct encode_integral : encode_size_t< V, (typename get_unsigned<T>::type)n,(((typename get_unsigned<T>::type)n)>=0x3fffffff) >
			{};

			template<class V, bool b>
			struct encode_integral<V, bool, b> : encode_size_t< V, b?1:0, false>
			{};
			///////////////////////////

			template<std::size_t n, class Iter, bool overflow>
			struct decode_size_t;

			template<std::size_t n, class Iter>
			struct decode_size_t<n, Iter, false>
			{
			BOOST_STATIC_CONSTANT(std::size_t,value = n);
			typedef Iter iter;
			};

			template<std::size_t n, class Iter>
			struct decode_size_t<n, Iter, true>
			{
			BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);

			BOOST_STATIC_CONSTANT(std::size_t,value = (std::size_t)m * 0x3ffffffe + n);
			typedef typename Iter::next iter;
			};

			template<class T, class Iter>
			struct decode_integral
			{
			typedef decode_integral<T,Iter> self_t;
			BOOST_STATIC_CONSTANT(std::size_t,m = Iter::type::value);

			BOOST_STATIC_CONSTANT(std::size_t,n = unpack<m>::value);

			BOOST_STATIC_CONSTANT(std::size_t,overflow = unpack<m>::overflow);

			typedef typename Iter::next nextpos;

			static const T value = (T)(std::size_t)decode_size_t<n, nextpos, overflow>::value;

			typedef typename decode_size_t<self_t::n, nextpos, self_t::overflow>::iter iter;
			};

			}}//namespace

			#endif//BOOST_TYPEOF_INT_ENCODING_HPP_INCLUDED

Admin message