namespace boost {
namespace type_erasure {
template<typename Sig> struct constructible;
template<typename T> struct destructible;
template<typename T, typename U> struct assignable;
template<typename Concept, typename T = _self> class any;
template<typename Concept, typename T> class any<Concept, T &>;
template<typename Concept, typename T> class any<Concept, const T &>;
template<typename Concept, typename T> class any<Concept, T &&>;
}
}
namespace boost {
namespace type_erasure {
template<typename T, typename Concept, typename Tag>
T any_cast(any< Concept, Tag > &);
template<typename T, typename Concept, typename Tag>
T any_cast(const any< Concept, Tag > &);
template<typename T, typename Concept, typename Tag>
T any_cast(any< Concept, Tag > *);
template<typename T, typename Concept, typename Tag>
T any_cast(const any< Concept, Tag > *);
}
}
namespace boost {
namespace type_erasure {
template<typename P> class dynamic_binding;
template<typename Concept> class binding;
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename T>
const binding< Concept > & binding_of(const any< Concept, T > &);
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename Op, class... U>
unspecified call(const binding< Concept > &, const Op &, U &&...);
template<typename Op, class... U> unspecified call(const Op &, U &&...);
}
}
namespace boost {
namespace type_erasure {
template<typename Sig, typename F = _self> struct callable;
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename Op, class... U>
bool check_match(const binding< Concept > &, const Op &, U &&...);
template<typename Op, class... U> bool check_match(const Op &, U &&...);
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename Base, typename ID,
typename Enable = void>
struct concept_interface;
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename T> class param;
template<typename T> struct concept_of;
}
}
namespace boost {
namespace type_erasure {
template<typename Metafunction> struct deduced;
}
}
namespace boost {
namespace type_erasure {
template<typename T> struct derived;
}
}
namespace boost {
namespace type_erasure {
template<typename T> bool is_empty(const T &);
}
}
namespace boost {
namespace type_erasure {
template<typename T> struct is_placeholder;
}
}
namespace boost {
namespace type_erasure {
template<typename Sub, typename Super, typename PlaceholderMap = void>
struct is_subconcept;
}
}
namespace boost {
namespace type_erasure {
template<typename Traversal, typename T = _self,
typename Reference = ::boost::use_default,
typename DifferenceType = ::std::ptrdiff_t,
typename ValueType = typename deduced<iterator_value_type<T> >::type>
struct iterator;
template<typename T = _self, typename Reference = boost::use_default,
typename DifferenceType = std::ptrdiff_t>
struct forward_iterator;
template<typename T = _self, typename Reference = boost::use_default,
typename DifferenceType = std::ptrdiff_t>
struct bidirectional_iterator;
template<typename T = _self, typename Reference = boost::use_default,
typename DifferenceType = std::ptrdiff_t>
struct random_access_iterator;
}
}
namespace boost {
namespace type_erasure {
template<typename T = _self> struct incrementable;
template<typename T = _self> struct decrementable;
template<typename T = _self, typename R = T> struct complementable;
template<typename T = _self, typename R = T> struct negatable;
template<typename R, typename T = _self> struct dereferenceable;
template<typename T = _self, typename U = T, typename R = T> struct addable;
template<typename T = _self, typename U = T, typename R = T>
struct subtractable;
template<typename T = _self, typename U = T, typename R = T>
struct multipliable;
template<typename T = _self, typename U = T, typename R = T>
struct dividable;
template<typename T = _self, typename U = T, typename R = T> struct modable;
template<typename T = _self, typename U = T, typename R = T>
struct left_shiftable;
template<typename T = _self, typename U = T, typename R = T>
struct right_shiftable;
template<typename T = _self, typename U = T, typename R = T>
struct bitandable;
template<typename T = _self, typename U = T, typename R = T>
struct bitorable;
template<typename T = _self, typename U = T, typename R = T>
struct bitxorable;
template<typename T = _self, typename U = T> struct add_assignable;
template<typename T = _self, typename U = T> struct subtract_assignable;
template<typename T = _self, typename U = T> struct multiply_assignable;
template<typename T = _self, typename U = T> struct divide_assignable;
template<typename T = _self, typename U = T> struct mod_assignable;
template<typename T = _self, typename U = T> struct left_shift_assignable;
template<typename T = _self, typename U = T> struct right_shift_assignable;
template<typename T = _self, typename U = T> struct bitand_assignable;
template<typename T = _self, typename U = T> struct bitor_assignable;
template<typename T = _self, typename U = T> struct bitxor_assignable;
template<typename T = _self, typename U = T> struct equality_comparable;
template<typename T = _self, typename U = T> struct less_than_comparable;
template<typename R, typename T = _self, typename N = std::ptrdiff_t>
struct subscriptable;
template<typename Os = std::ostream, typename T = _self> struct ostreamable;
template<typename Is = std::istream, typename T = _self> struct istreamable;
}
}
namespace boost {
namespace type_erasure {
template<typename Any, typename T> struct as_param;
}
}
namespace boost {
namespace type_erasure {
struct placeholder;
struct _a;
struct _b;
struct _c;
struct _d;
struct _e;
struct _f;
struct _g;
struct _self;
}
}
namespace boost {
namespace type_erasure {
template<typename T> struct placeholder_of;
}
}
namespace boost {
namespace type_erasure {
template<typename Any, typename T> struct rebind_any;
}
}
namespace boost {
namespace type_erasure {
template<typename T> struct is_relaxed;
struct relaxed;
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename Op, class... U>
void require_match(const binding< Concept > &, const Op &, U &&...);
template<typename Op, class... U> void require_match(const Op &, U &&...);
}
}
namespace boost {
namespace type_erasure {
template<typename T, typename U> struct same_type;
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, class... T> class tuple;
template<int N, typename Concept, class... T>
any< Concept, TN > & get(tuple< Concept, T...> &);
template<int N, typename Concept, class... T>
const any< Concept, TN > & get(const tuple< Concept, T...> &);
}
}
namespace boost {
namespace type_erasure {
template<typename Concept, typename T>
const std::type_info & typeid_of(const any< Concept, T > &);
template<typename T, typename Concept>
const std::type_info & typeid_of(const binding< Concept > &);
}
}