static constexpr bool builtin_only = true;

inline bool is_pure() const { return true; }

// all types are builtin, perform lookup on constuction

const uniform_type_info* data[sizeof...(T)];

types_array_impl() : data{ta_util<cppa_tinf, true, T>::get()...} { }

inline const uniform_type_info* operator[](size_t p) const {

return data[p];

}

typedef const uniform_type_info* const* const_iterator;

inline const_iterator begin() const { return std::begin(data); }

inline const_iterator end() const { return std::end(data); }

: tinfo_data{ta_util<std_tinf,util::is_builtin<T>::value,T>::get()...} {

bool static_init[sizeof...(T)] = { !std::is_same<T,anything>::value

&& util::is_builtin<T>::value ... };

for (size_t i = 0; i < sizeof...(T); ++i) {

if (static_init[i]) {

data[i].store(uniform_typeid(*(tinfo_data[i])),

std::memory_order_relaxed);

}

}

auto result = pairs.load();

if (result == nullptr) {

auto parr = new const uniform_type_info*[sizeof...(T)];

for (size_t i = 0; i < sizeof...(T); ++i) {

parr[i] = (*this)[i];

}

if (!pairs.compare_exchange_weak(result, parr, std::memory_order_relaxed)) {

delete[] parr;

}

else {

result = parr;

}

}

return result;

util::is_builtin>::value,

T...> {

static constexpr size_t size = sizeof...(T);

typedef util::type_list<T...> types;

typedef typename util::tl_filter_not<types, is_anything>::type

filtered_types;

static constexpr size_t filtered_size = util::tl_size<filtered_types>::value;

inline bool has_values() const { return false; }