| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/type_erasure/any.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept, typename T = _self> class any;

        template<typename Concept, typename T>
        using any_ref = any< Concept, T & >;
        template<typename Concept, typename T>
        using any_cref = any< Concept, const T & >;
        template<typename Concept, typename T>
        using any_rvref = any< Concept, T && >;
      }
    }

### Header <boost/type_erasure/any_cast.hpp>

    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 > *);
      }
    }

### Header <boost/type_erasure/binding.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept> class binding;
      }
    }

### Header <boost/type_erasure/binding_of.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept, typename T>
          const binding< Concept > & binding_of(const any< Concept, T > &);
      }
    }

### Header <boost/type_erasure/builtin.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T = _self, typename U = const T&> struct assignable;
        template<typename T = _self> struct copy_constructible;
        template<typename T = _self> struct destructible;
        template<typename T = _self> struct typeid_;
      }
    }

### Header <boost/type_erasure/call.hpp>

    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 &&...);
      }
    }

### Header <boost/type_erasure/callable.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Sig, typename F = _self> struct callable;
      }
    }

### Header <boost/type_erasure/check_match.hpp>

    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 &&...);
      }
    }

### Header <boost/type_erasure/concept_interface.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept, typename Base, typename ID,
                 typename Enable = void>
          struct concept_interface;
      }
    }

### Header <boost/type_erasure/concept_of.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T> struct concept_of;

        template<typename T>
        using concept_of_t = typename ::boost::type_erasure::concept_of< T >::type;
      }
    }

### Header <boost/type_erasure/config.hpp>

    BOOST_TYPE_ERASURE_MAX_FUNCTIONS
    BOOST_TYPE_ERASURE_MAX_ARITY
    BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE

### Header <boost/type_erasure/constructible.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Sig> struct constructible;
      }
    }

### Header <boost/type_erasure/deduced.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Metafunction> struct deduced;
      }
    }

### Header <boost/type_erasure/derived.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T> struct derived;

        template<typename T>
        using derived_t = typename T::_boost_type_erasure_derived_type;
      }
    }

### Header <boost/type_erasure/dynamic_any_cast.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename R, typename Any> R dynamic_any_cast(Any &&);
        template<typename R, typename Any, typename Map>
          R dynamic_any_cast(Any &&, const static_binding< Map > &);
      }
    }

### Header <boost/type_erasure/dynamic_binding.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename PlaceholderList> class dynamic_binding;
      }
    }

### Header <boost/type_erasure/exception.hpp>

    namespace boost {
      namespace type_erasure {
        class bad_any_cast;
        class bad_function_call;
      }
    }

### Header <boost/type_erasure/free.hpp>

    BOOST_TYPE_ERASURE_FREE(concept_name, function_name)

### Header <boost/type_erasure/is_empty.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T> bool is_empty(const T &);
      }
    }

### Header <boost/type_erasure/is_placeholder.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T> struct is_placeholder;
      }
    }

### Header <boost/type_erasure/is_subconcept.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Sub, typename Super, typename PlaceholderMap = void>
          struct is_subconcept;
      }
    }

### Header <boost/type_erasure/iterator.hpp>

    namespace boost {
      namespace type_erasure {
        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 forward_iterator;
        template<typename Traversal, typename T = _self,
                 typename Reference = boost::use_default,
                 typename DifferenceType = std::ptrdiff_t>
          struct iterator;
        template<typename T = _self, typename Reference = boost::use_default,
                 typename DifferenceType = std::ptrdiff_t>
          struct random_access_iterator;
      }
    }

### Header <boost/type_erasure/member.hpp>

    BOOST_TYPE_ERASURE_MEMBER(concept_name, member)

### Header <boost/type_erasure/operators.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T = _self, typename U = T> struct add_assignable;
        template<typename T = _self, typename U = T, typename R = T> struct addable;
        template<typename T = _self, typename U = T> struct bitand_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct bitandable;
        template<typename T = _self, typename U = T> struct bitor_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct bitorable;
        template<typename T = _self, typename U = T> struct bitxor_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct bitxorable;
        template<typename T = _self, typename R = T> struct complementable;
        template<typename T = _self> struct decrementable;
        template<typename R, typename T = _self> struct dereferenceable;
        template<typename T = _self, typename U = T, typename R = T>
          struct dividable;
        template<typename T = _self, typename U = T> struct divide_assignable;
        template<typename T = _self, typename U = T> struct equality_comparable;
        template<typename T = _self> struct incrementable;
        template<typename Is = std::istream, typename T = _self> struct istreamable;
        template<typename T = _self, typename U = T> struct left_shift_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct left_shiftable;
        template<typename T = _self, typename U = T> struct less_than_comparable;
        template<typename T = _self, typename U = T> struct mod_assignable;
        template<typename T = _self, typename U = T, typename R = T> struct modable;
        template<typename T = _self, typename U = T, typename R = T>
          struct multipliable;
        template<typename T = _self, typename U = T> struct multiply_assignable;
        template<typename T = _self, typename R = T> struct negatable;
        template<typename Os = std::ostream, typename T = _self> struct ostreamable;
        template<typename T = _self, typename U = T> struct right_shift_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct right_shiftable;
        template<typename R, typename T = _self, typename N = std::ptrdiff_t>
          struct subscriptable;
        template<typename T = _self, typename U = T> struct subtract_assignable;
        template<typename T = _self, typename U = T, typename R = T>
          struct subtractable;
      }
    }

### Header <boost/type_erasure/param.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Any, typename T> struct as_param;

        template<typename Concept, typename T> class param;

        template<typename Any, typename T>
        using as_param_t = typename ::boost::type_erasure::as_param< Any, T >::type;
      }
    }

### Header <boost/type_erasure/placeholder.hpp>

    namespace boost {
      namespace type_erasure {
        struct _a;
        struct _b;
        struct _c;
        struct _d;
        struct _e;
        struct _f;
        struct _g;
        struct _self;
        struct placeholder;
      }
    }

### Header <boost/type_erasure/placeholder_of.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T> struct placeholder_of;

        template<typename T>
        using placeholder_of_t = typename ::boost::type_erasure::placeholder_of< T >::type;
      }
    }

### Header <boost/type_erasure/rebind_any.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Any, typename T> struct rebind_any;

        template<typename Any, typename T>
        using rebind_any_t = typename ::boost::type_erasure::rebind_any< Any, T >::type;
      }
    }

### Header <boost/type_erasure/register_binding.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept, typename Map>
          void register_binding(const static_binding< Map > &);
        template<typename Concept, typename T> void register_binding();
      }
    }

### Header <boost/type_erasure/relaxed.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Concept> struct is_relaxed;
        struct relaxed;
      }
    }

### Header <boost/type_erasure/require_match.hpp>

    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 &&...);
      }
    }

### Header <boost/type_erasure/same_type.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename T, typename U> struct same_type;
      }
    }

### Header <boost/type_erasure/static_binding.hpp>

    namespace boost {
      namespace type_erasure {
        template<typename Map> struct static_binding;
        template<typename Map> static_binding< Map > make_binding();
      }
    }

### Header <boost/type_erasure/tuple.hpp>

    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... > &);
      }
    }

### Header <boost/type_erasure/typeid_of.hpp>

    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 > &);
      }
    }