Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

Reference

Header <boost/type_erasure/any.hpp>
Header <boost/type_erasure/any_cast.hpp>
Header <boost/type_erasure/binding.hpp>
Header <boost/type_erasure/binding_of.hpp>
Header <boost/type_erasure/builtin.hpp>
Header <boost/type_erasure/call.hpp>
Header <boost/type_erasure/callable.hpp>
Header <boost/type_erasure/check_match.hpp>
Header <boost/type_erasure/concept_interface.hpp>
Header <boost/type_erasure/concept_of.hpp>
Header <boost/type_erasure/config.hpp>
Header <boost/type_erasure/constructible.hpp>
Header <boost/type_erasure/deduced.hpp>
Header <boost/type_erasure/derived.hpp>
Header <boost/type_erasure/exception.hpp>
Header <boost/type_erasure/free.hpp>
Header <boost/type_erasure/is_empty.hpp>
Header <boost/type_erasure/is_placeholder.hpp>
Header <boost/type_erasure/is_subconcept.hpp>
Header <boost/type_erasure/iterator.hpp>
Header <boost/type_erasure/member.hpp>
Header <boost/type_erasure/operators.hpp>
Header <boost/type_erasure/param.hpp>
Header <boost/type_erasure/placeholder.hpp>
Header <boost/type_erasure/placeholder_of.hpp>
Header <boost/type_erasure/rebind_any.hpp>
Header <boost/type_erasure/relaxed.hpp>
Header <boost/type_erasure/require_match.hpp>
Header <boost/type_erasure/same_type.hpp>
Header <boost/type_erasure/static_binding.hpp>
Header <boost/type_erasure/tuple.hpp>
Header <boost/type_erasure/typeid_of.hpp>
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 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 T = _self> struct copy_constructible;
    template<typename T = _self> struct typeid_;
  }
}
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;
  }
}

BOOST_TYPE_ERASURE_MAX_FUNCTIONS
BOOST_TYPE_ERASURE_MAX_ARITY
BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE
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 {
    class bad_function_call;
    class bad_any_cast;
  }
}

BOOST_TYPE_ERASURE_FREE(qualified_name, function_name, N)
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;
  }
}

BOOST_TYPE_ERASURE_MEMBER(qualified_name, member, N)
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 Map> struct static_binding;
    template<typename Map> static_binding< Map > make_binding();
  }
}
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 > &);
  }
}

PrevUpHomeNext