Boost C++ Libraries Home Libraries People FAQ More

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/dynamic_any_cast.hpp>
Header <boost/type_erasure/dynamic_binding.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/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/register_binding.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>

  
    template<typename Concept, typename T = _self> class any;

    template<typename Concept, typename T> class any<, >;
    template<typename Concept, typename T> class any<, >;
    template<typename Concept, typename T> class any<, >;

    typedef any< Concept, T & > ;
    typedef any< Concept, const T & > ;
    typedef any< Concept, T && > ;
  }
}

  
    template<typename T, typename Concept, typename Tag> 
      T (any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T (const any< Concept, Tag > &);
    template<typename T, typename Concept, typename Tag> 
      T (any< Concept, Tag > *);
    template<typename T, typename Concept, typename Tag> 
      T (const any< Concept, Tag > *);
  }
}

  
    template<typename Concept> class binding;
  }
}

  
    template<typename Concept, typename T> 
      const binding< Concept > & (const any< Concept, T > &);
  }
}

  
    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_;
  }
}

  
    template<typename Concept, typename Op,  U> 
       (const binding< Concept > &, const Op &, U &&...);
    template<typename Op,  U>  (const Op &, U &&...);
  }
}

  
    template<typename Sig, typename F = _self> struct callable;
  }
}

  
    template<typename Concept, typename Op,  U> 
      bool (const binding< Concept > &, const Op &, U &&...);
    template<typename Op,  U> bool (const Op &, U &&...);
  }
}

  
    template<typename Concept, typename Base, typename ID, 
             typename Enable = void> 
      struct concept_interface;
  }
}

  
    template<typename T> struct concept_of;

    typedef typename ::boost::type_erasure::concept_of< T >:: ;
  }
}

BOOST_TYPE_ERASURE_MAX_FUNCTIONS
BOOST_TYPE_ERASURE_MAX_ARITY
BOOST_TYPE_ERASURE_MAX_TUPLE_SIZE

  
    template<typename Sig> struct constructible;
  }
}

  
    template<typename Metafunction> struct deduced;
  }
}

  
    template<typename T> struct derived;

    typedef typename  ;
  }
}

  
    template<typename R, typename Any> R (Any &&);
    template<typename R, typename Any, typename Map> 
      R (Any &&, const static_binding< Map > &);
  }
}

  
    template<typename PlaceholderList> class dynamic_binding;
  }
}

  
    class bad_any_cast;
    class bad_function_call;
  }
}

BOOST_TYPE_ERASURE_FREE(concept_name, function_name)

  
    template<typename T> bool (const T &);
  }
}

  
    template<typename T> struct is_placeholder;
  }
}

  
    template<typename Sub, typename Super, typename PlaceholderMap = void> 
      struct is_subconcept;
  }
}

  
    template<typename T = _self, typename Reference, 
             typename DifferenceType> 
      struct bidirectional_iterator;
    template<typename T = _self, typename Reference, 
             typename DifferenceType> 
      struct forward_iterator;
    template<typename Traversal, typename T = _self, 
             typename Reference, 
             typename DifferenceType> 
      struct iterator;
    template<typename T = _self, typename Reference, 
             typename DifferenceType> 
      struct random_access_iterator;
  }
}

  
    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, 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, 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> struct subscriptable;
    template<typename T = _self, typename U = T> struct subtract_assignable;
    template<typename T = _self, typename U = T, typename R = T> 
      struct subtractable;
  }
}

  
    template<typename Any, typename T> struct as_param;

    template<typename Concept, typename T> class param;

    typedef typename ::boost::type_erasure::as_param< Any, T >:: ;
  }
}

  
    struct _a;
    struct _b;
    struct _c;
    struct _d;
    struct _e;
    struct _f;
    struct _g;
    struct _self;
    struct placeholder;
  }
}

  
    template<typename T> struct placeholder_of;

    typedef typename ::boost::type_erasure::placeholder_of< T >:: ;
  }
}

  
    template<typename Any, typename T> struct rebind_any;

    typedef typename ::boost::type_erasure::rebind_any< Any, T >:: ;
  }
}

  
    template<typename Concept, typename Map> 
      void (const static_binding< Map > &);
    template<typename Concept, typename T> void ();
  }
}

  
    template<typename Concept> struct is_relaxed;
    struct relaxed;
  }
}

  
    template<typename Concept, typename Op,  U> 
      void (const binding< Concept > &, const Op &, U &&...);
    template<typename Op,  U> void (const Op &, U &&...);
  }
}

  
    template<typename T, typename U> struct same_type;
  }
}

  
    template<typename Map> struct static_binding;
    template<typename Map> static_binding< Map > ();
  }
}

  
    template<typename Concept,  T> class tuple;
    template< N, typename Concept,  T> 
      any< Concept, TN > & (tuple< Concept, );
    template< N, typename Concept,  T> 
      const any< Concept, TN > & (const tuple< Concept, );
  }
}

  
    template<typename Concept, typename T> 
      const  (const any< Concept, T > &);
    template<typename T, typename Concept> 
      const  (const binding< Concept > &);
  }
}

PrevUpHomeNext