plasma_effectのメモ帳的ブログのようなsomething
[PR]上記の広告は3ヶ月以上新規記事投稿のないブログに表示されています。新しい記事を書く事で広告が消えます。
#pragma once
#include"type_traits.hpp"
#include"preprocess.hpp"
namespace dcl
{
//index_tuple
template<int...>struct index_tuple{};
namespace detail
{
//get_index_next
constexpr int get_index_next(int a)
{
return (a%2==0 ? a/2 : (a-1)/2);
}
//index_next
template<class Index,int N,bool is_even>struct index_next;
template<int N,int... Nums>//even
struct index_next<dcl::index_tuple<Nums...>,N,true>
{
using type = index_tuple<Nums...,(N+Nums)...>;
};
template<int N,int... Nums>//odd
struct index_next<dcl::index_tuple<Nums...>,N,false>
{
using type = index_tuple<Nums...,(N+Nums)...,2*N>;
};
template<>//0
struct index_next<dcl::index_tuple<>,0,false>
{
using type = index_tuple<0>;
};
//index_count_impl
template<int End>struct index_count_impl
{
using type = typename index_next<
typename index_count_impl<get_index_next(End)>::type,
get_index_next(End),
End%2==0>::type;
};
template<>struct index_count_impl<0>
{
using type = index_tuple<>;
};
}
//index_count
template<size_t N>class index_count
{
public:
using type = typename detail::index_count_impl<N>::type;
};
//index_range
namespace detail
{
template<class,int,int>struct index_range_impl;
template<int... Nums,int Start,int Step>
struct index_range_impl<index_tuple<Nums...>,Start,Step>
{
using type = index_tuple<(Start+Nums*Step)...>;
};
}
template<int Start,int End,int Step=1>class index_range
{
public:
using type = typename detail::index_range_impl<
typename index_count<1+(End-Start)/Step>::type,
Start,
Step>::type;
};
//index_merge
namespace detail
{
template<class,class,class,class,class,class>struct index_merge_impl;
template<int... NumsA,int... NumsB,int... NumsC,int... NumsD,int... NumsE,int... NumsF>
struct index_merge_impl<
index_tuple<NumsA...>,
index_tuple<NumsB...>,
index_tuple<NumsC...>,
index_tuple<NumsD...>,
index_tuple<NumsE...>,
index_tuple<NumsF...>>
{
using type = index_tuple<NumsA...,NumsB...,NumsC...,NumsD...,NumsE...,NumsF...>;
};
}
template<class IndexA,class IndexB,class IndexC=index_tuple<>,class IndexD=index_tuple<>,class IndexE=index_tuple<>,class IndexF=index_tuple<>>class index_merge
{
public:
using type = typename detail::index_merge_impl<IndexA,IndexB,IndexC,IndexD,IndexE,IndexF>::type;
};
//DCL_COUNT_DOWN_USING
#define DCL_COUNT_DOWN_USING(TO,FROM)\
template<class>struct DCL_PP_CAT(impl_index_range_cat_,TO);\
template<int... Nums>struct \
DCL_PP_CAT(impl_index_range_cat_,TO)<dcl::index_tuple<Nums...>>\
{using type = FROM<Nums...>;};\
template<int N>\
using TO = typename DCL_PP_CAT(impl_index_range_cat_,TO)\
<typename dcl::index_count<N>::type>::type;
//DCL_INDEX_RANGE_USING
#define DCL_INDEX_RANGE_USING(TO,FROM)\
template<class>struct DCL_PP_CAT(impl_index_range_cat_,TO);\
template<int... Nums>struct \
DCL_PP_CAT(impl_index_range_cat_,TO)<dcl::index_tuple<Nums...>>\
{using type = FROM<Nums...>;};\
template<int Start,int End,int Step=0>\
using TO = typename DCL_PP_CAT(impl_index_range_cat_,TO)\
<typename dcl::index_range<Start,End,Step>::type>::type;
}
#pragma once
#include<type_traits>
#include<tuple>
#include<stdexcept>
namespace dyz_type_traits
{
using void_tuple = std::tuple<void*>;
void_tuple enabler;
template<class Type, class Type2, class... Types>struct all_type_equal_impl
{
static const bool value = std::is_same<Type, Type2>::value
&& all_type_equal_impl<Type, Types...>::value;
};
template<class Type, class Type2>struct all_type_equal_impl<Type, Type2>
{
static const bool value = std::is_same<Type, Type2>::value;
};
template<class Type, class... Types>class are_same
{
public:
static const bool value = all_type_equal_impl<Type, Types...>::value;
};
template<size_t... Num>struct index_tuple{};
template<size_t Max, size_t... Nums>struct index_count :index_count<Max - 1, Max, Nums...>{};
template<size_t... Nums>struct index_count<0, Nums...>
{
using type = index_tuple<0, Nums...>;
};
template<class Type, class... Types>struct type_num
{
static const int value = 1 + type_num<Types...>::value;
};
template<class Type>struct type_num<Type>
{
static const int value = 1;
};
template<class Ty>struct tuple_num;
template<class... Types>struct tuple_num<std::tuple<Types...>>
{
static const int value = type_num<Types...>::value;
};
template<class RetType, class ArgTupleTy, class FuncTy, class ArgTy>struct func_tuple_impl;
template<class RetType,class ArgTupleTy,class FuncTy,size_t... Nums>
struct func_tuple_impl<RetType, ArgTupleTy, FuncTy, index_tuple<Nums...>>
{
static RetType run(ArgTupleTy& tup, FuncTy &func)
{
return func(std::get<Nums>(tup)...);
}
};
template<class RetType,class ArgTupleTy,class FuncTy>
using func_tuple = func_tuple_impl<RetType, ArgTupleTy, FuncTy,typename index_count<tuple_num<ArgTupleTy>::value - 1>::type>;
template<class RetType, class ArgTupleTy, class FuncTy, class... FuncTypes>struct func_switch_impl
{
static RetType run(size_t switch_on,ArgTupleTy& tup, FuncTy& func, FuncTypes&... funcs)
{
return (switch_on == 0 ?
func_tuple<RetType, ArgTupleTy, FuncTy>::run(tup, func)
: func_switch_impl<RetType, ArgTupleTy, FuncTypes...>
::run(switch_on - 1, tup, funcs...));
}
};
template<class RetType, class ArgTupleTy, class FuncTy>struct func_switch_impl<RetType, ArgTupleTy, FuncTy>
{
static RetType run(size_t, ArgTupleTy& tup, FuncTy& func)
{
return func_tuple<RetType, ArgTupleTy, FuncTy>::run(tup, func);
}
};
template<class RetType,class ArgTupleTy,class... FuncTypes>
inline RetType func_switch(size_t switch_on,ArgTupleTy&tup, FuncTypes&... funcs)
{
return func_switch_impl<RetType, ArgTupleTy, FuncTypes...>::run(switch_on, tup, funcs...);
}
template<class RetTy,class... Types>inline typename std::enable_if<are_same<RetTy,Types...>::value,RetTy>::type
number_filter(size_t num, Types... nums)
{
return func_switch<RetTy>(num, std::tuple<int>(), [=](int){return nums; }...);
}
template<class Ty>inline void iterator_shift(Ty& ite, int shift)throw(std::out_of_range)
{
if (shift > 0)
{
for (int i = 0; i < shift; ++i)
{
++ite;
}
}
else
{
for (int i = 0; i > shift; --i)
{
--ite;
}
}
}
}
カレンダー
カテゴリー
フリーエリア
最新CM
最新記事
プロフィール
バーコード
ブログ内検索
P R