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<  ;
    typedef any<  ;
    typedef any<  ;
  }
}

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

  
    template<typename Concept> class binding;
  }
}

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

  
    template<typename T = _self> struct destructible;
    template<typename T = _self> struct copy_constructible;
    template<typename T = _self, typename U> struct assignable;
    template<typename T = _self> struct typeid_;
  }
}

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

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

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

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

  
    template<typename T> struct concept_of;

    typedef boost::type_erasure::concept_of<  ;
  }
}

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

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

  
    template<typename PlaceholderList> class dynamic_binding;
  }
}

  
    class bad_function_call;
    class bad_any_cast;
  }
}

BOOST_TYPE_ERASURE_FREE(concept_name, function_name)

  
    template<typename T>  ();
  }
}

  
    template<typename T> struct is_placeholder;
  }
}

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

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

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

  
    template<typename Concept, typename T> class param;

    template<typename Any, typename T> struct as_param;

    typedef boost::type_erasure::as_param<  ;
  }
}

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

  
    template<typename T> struct placeholder_of;

    typedef boost::type_erasure::placeholder_of<  ;
  }
}

  
    template<typename Any, typename T> struct rebind_any;

    typedef boost::type_erasure::rebind_any<  ;
  }
}

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

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

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

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

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

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

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

PrevUpHomeNext