TCL_obj_base.h File Reference

TCL access descriptor. More...

#include "tcl++.h"
#include "pack_base.h"
#include "pack_stl.h"
#include "ref.h"
#include "error.h"
#include "accessor.h"
#include "isa_base.h"
#include "function.h"
#include <iostream>
#include <sstream>
#include <string>
#include "TCL_obj_base.cd"
Include dependency graph for TCL_obj_base.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  ecolab::TCLObjRef
 RAII TCL_Obj ref. More...
 
class  ecolab::TCL_args
 Represent arguments to TCL commands. More...
 
struct  ecolab::member_entry_base
 
struct  ecolab::member_entry_base::TypeInfoLess
 
struct  ecolab::TCL_obj_checkr_base
 
struct  classdesc::TCL_obj_t
 TCL_obj descriptor object. More...
 
struct  classdesc_access::access_pack< classdesc::TCL_obj_t >
 
struct  classdesc_access::access_unpack< classdesc::TCL_obj_t >
 
struct  classdesc_access::access_TCL_obj< T >
 
struct  classdesc_access::access_TCL_obj< const T >
 
struct  ecolab::classdesc::enable_if_c< bool, type >
 
struct  ecolab::classdesc::enable_if_c< false, T >
 
struct  ecolab::classdesc::enable_if< Cond, T >
 controlled template specialisation: stolen from boost::enable_if. More...
 
struct  ecolab::classdesc::conditional< C, True, F >
 
struct  ecolab::classdesc::conditional< false, True, F >
 
struct  ecolab::classdesc::dummy< int >
 
struct  ecolab::classdesc::is_sequence< T >
 determines if T is a standard sequence container More...
 
struct  ecolab::classdesc::is_sequence< std::vector< T, A > >
 
struct  ecolab::classdesc::is_sequence< std::deque< T, A > >
 
struct  ecolab::classdesc::is_sequence< std::list< T, A > >
 
struct  ecolab::classdesc::is_sequence< const T >
 
struct  ecolab::classdesc::is_string< T >
 determines if this is a string More...
 
struct  ecolab::classdesc::is_string< std::basic_string< T > >
 
struct  ecolab::classdesc::is_string< const T >
 
struct  ecolab::classdesc::is_associative_container< T >
 determines if T is a standard associative container More...
 
struct  ecolab::classdesc::is_associative_container< std::set< T, C, A > >
 
struct  ecolab::classdesc::is_associative_container< std::map< K, V, C, A > >
 
struct  ecolab::classdesc::is_associative_container< std::multiset< T, C, A > >
 
struct  ecolab::classdesc::is_associative_container< std::multimap< K, V, C, A > >
 
struct  ecolab::classdesc::is_associative_container< const T >
 
struct  ecolab::classdesc::is_container< T >
 determines if T is a container More...
 
struct  ecolab::classdesc::Not< T >
 
struct  ecolab::classdesc::And< A, B >
 
struct  ecolab::classdesc::Or< A, B >
 
struct  ecolab::classdesc::Eq< X, Y >
 
struct  ecolab::classdesc::is_dca< T >
 has default constructor, and is copiable More...
 
struct  ecolab::classdesc::is_rvalue< T >
 can a temporary of type T be constructed and passed to an argument More...
 
struct  ecolab::classdesc::is_rvalue< T & >
 
struct  ecolab::classdesc::is_rvalue< const T & >
 
struct  ecolab::classdesc::exception
 base class for exceptions thrown by classdesc More...
 
struct  ecolab::classdesc::tn< T >
 
struct  ecolab::classdesc::tn< T * >
 
struct  ecolab::classdesc::tn< shared_ptr< T > >
 
struct  ecolab::classdesc::tn< std::vector< T, A > >
 
struct  ecolab::classdesc::tn< std::list< T, A > >
 
struct  ecolab::classdesc::tn< std::deque< T, A > >
 
struct  ecolab::classdesc::tn< std::set< T, C, A > >
 
struct  ecolab::classdesc::tn< std::map< K, V, C, A > >
 
struct  ecolab::classdesc::tn< std::pair< K, V > >
 
struct  ecolab::classdesc::EnumKey
 enum symbol handling More...
 
class  ecolab::classdesc::EnumKeys< T >
 
class  ecolab::classdesc::EnumKeys< T >::Siterator
 
class  ecolab::classdesc::EnumKeys< T >::Viterator
 
class  ecolab::classdesc::Enum_handle< T >
 
class  ecolab::classdesc::is_array
 
class  ecolab::classdesc::is_const_static
 
class  ecolab::classdesc::is_node
 
class  ecolab::classdesc::is_treenode
 
class  ecolab::classdesc::is_graphnode
 
struct  ecolab::classdesc::dummy_functional< T >
 
struct  ecolab::classdesc::NonConstKeyValueType< TT >
 helper for unpacking into map value_types More...
 
struct  ecolab::classdesc::NonConstKeyValueType< std::pair< const K, V > >
 
struct  ecolab::classdesc::ExcludeClass< T >
 
struct  ecolab::classdesc::ExcludeFundamental< T >
 
struct  ecolab::classdesc::Exclude< T >
 
struct  ecolab::classdesc::Exclude< T * >
 
struct  ecolab::classdesc::Exclude< bool >
 
struct  ecolab::classdesc::NullDescriptor< action_t >
 helper for constructing null descriptors More...
 
struct  ecolab::classdesc::base_cast< B >
 
class  ecolab::classdesc::pack_error
 
struct  ecolab::classdesc::basic_type
 
struct  ecolab::classdesc::Basic_Type< T >
 
struct  ecolab::classdesc::PtrStoreBase
 
struct  ecolab::classdesc::PtrStore< T >
 
class  ecolab::classdesc::PtrStoreRef
 
class  ecolab::classdesc::pack_t
 
class  ecolab::classdesc::BinStream
 
struct  ecolab::classdesc::BinStreamT< Pack >
 
struct  ecolab::classdesc::unserialisable< T >
 
struct  ecolab::classdesc::pack_supported< T >
 
struct  ecolab::classdesc_access::access_pack< T >
 class to allow access to private members More...
 
struct  ecolab::classdesc_access::access_unpack< T >
 class to allow access to private members More...
 
struct  ecolab::classdesc_access::access_pack< T * >
 
struct  ecolab::classdesc_access::access_unpack< T * >
 
struct  ecolab::classdesc_access::access_pack< classdesc::unserialisable< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::unserialisable< T > >
 
struct  ecolab::classdesc_access::access_pack< classdesc::Exclude< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::Exclude< T > >
 
struct  ecolab::classdesc::sequence< T >
 
struct  ecolab::classdesc::associative_container< T >
 
struct  ecolab::classdesc::Value_Type< C >
 
struct  ecolab::classdesc::Value_Type< std::map< K, V, C, A > >
 
struct  ecolab::classdesc::Value_Type< std::multimap< K, V, C, A > >
 
class  ecolab::classdesc::Iterator< T >
 
class  ecolab::classdesc::Iterator< const T >
 
struct  ecolab::classdesc_access::access_pack< classdesc::sequence< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::sequence< T > >
 
struct  ecolab::classdesc_access::access_pack< classdesc::associative_container< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::associative_container< T > >
 
struct  ecolab::classdesc_access::access_pack< classdesc::Iterator< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::Iterator< T > >
 
struct  ecolab::classdesc_access::access_pack< std::basic_string< cT, t, A > >
 
struct  ecolab::classdesc_access::access_unpack< std::basic_string< cT, t, A > >
 
struct  ecolab::classdesc_access::access_pack< std::pair< A, B > >
 
struct  ecolab::classdesc_access::access_unpack< std::pair< A, B > >
 
struct  ecolab::classdesc::Alloc< T >
 
struct  ecolab::classdesc::Alloc< T * >
 
struct  ecolab::classdesc::functional::Arity< F >
 Arity::V (or ::value) is the number of arguments of More...
 
struct  ecolab::classdesc::functional::Return< F >
 Return::T (or ::type) is the return type of F More...
 
struct  ecolab::classdesc::functional::is_member_function_ptr< F >
 is_member_function_ptr::value is true if F is a member function pointer More...
 
struct  ecolab::classdesc::functional::is_const_method< F >
 is_const_method::value is true if F is a pointer to a const method More...
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< F >
 is_nonmember_function_ptr::value is true if F is an ordinary function pointer More...
 
struct  ecolab::classdesc::functional::is_function< F >
 
struct  ecolab::classdesc::functional::AllArgs< F, Pred, arity >
 
struct  ecolab::classdesc::functional::Arg< F, int >
 
class  ecolab::classdesc::functional::bound_method< C, M >
 
struct  ecolab::classdesc::functional::Fdummy< T >
 
struct  ecolab::classdesc::functional::Arity< bound_method< C, M > >
 
struct  ecolab::classdesc::functional::Return< bound_method< C, M > >
 
struct  ecolab::classdesc::functional::Arg< bound_method< C, M >, i >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 0 >
 
struct  ecolab::classdesc::functional::Arity< R(*)()>
 
struct  ecolab::classdesc::functional::Return< R(*)()>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)()>
 
struct  ecolab::classdesc::functional::Return< R(C::*)()>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)() const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)() const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)()>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)() const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)() const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)()>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)()>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)()>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)()>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)()>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)() const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)() const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)() const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)() const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1) const, 1 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 1 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2) const, 2 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 2 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3) const, 3 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 3 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4) const, 4 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 4 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5) const, 5 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 5 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 5 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6) const, 6 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 6 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5, A6)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 5 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 6 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const, 7 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 7 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5, A6, A7)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 5 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 6 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 7 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const, 8 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 8 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 5 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 6 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 7 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 8 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 9 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9), 9 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const, 9 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 9 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const >::Arg< i >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 1 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 1 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 2 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 2 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 3 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 3 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 4 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 4 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 5 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 5 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 6 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 6 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 7 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 7 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 8 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 8 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 9 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 9 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 9 >
 
struct  ecolab::classdesc::functional::Arg< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 10 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10), 10 >
 
struct  ecolab::classdesc::functional::Arg< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const, 10 >
 
struct  ecolab::classdesc::functional::AllArgs< F, P, 10 >
 
struct  ecolab::classdesc::functional::Arity< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::Return< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::Arity< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::Return< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::is_member_function_ptr< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::is_const_method< R(C::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::is_nonmember_function_ptr< R(*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::bound_method< C, R(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >::Arg< i >
 
class  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >
 
struct  ecolab::classdesc::functional::bound_method< C, void(D::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const >::Arg< i >
 
class  ecolab::classdesc::functional::binder1st< F, X, Arity >
 
class  ecolab::classdesc::functional::binder1st< F, X, 0 >
 
struct  ecolab::classdesc::functional::Arity< binder1st< F, X, A > >
 
struct  ecolab::classdesc::functional::Return< binder1st< F, X, A > >
 
class  ecolab::classdesc::ref< T >
 
struct  ecolab::classdesc::Alloc< classdesc::ref< T > >
 
struct  ecolab::classdesc_access::access_pack< classdesc::ref< T > >
 
struct  ecolab::classdesc_access::access_unpack< classdesc::ref< T > >
 
class  ecolab::ref< T >
 
class  ecolab::TCL_obj_ref< T >
 a slightly safer way of referring to registered objects than bare pointers More...
 
class  ecolab::ref< T >
 
struct  ecolab::member_entry< T >
 
struct  ecolab::member_entry< const classdesc::Enum_handle< T > >
 
struct  ecolab::member_entry< const classdesc::Enum_handle< const T > >
 
struct  ecolab::member_entry< const T >
 
struct  ecolab::member_entry< ecolab::TCL_obj_ref< T > >
 
struct  ecolab::member_entry< T * >
 
struct  ecolab::member_entry< void * >
 
struct  ecolab::member_entry< const void * >
 
struct  ecolab::member_entry< void >
 
struct  ecolab::TCL_obj_functor< C, T >
 
struct  ecolab::TCL_obj_functor< const C, T >
 
struct  ecolab::TCL_obj_functor< C, void >
 
struct  ecolab::BoundMethodCallable< B >
 whether B's method is callable due to the rules of const-correctness, or due to having lvalue arguments More...
 
struct  ecolab::BoundMethodCallable< functional::bound_method< C, M > >
 
class  ecolab::NewTCL_obj_functor< C, M >
 
class  ecolab::NewTCL_static_functor< F >
 
struct  classdesc_access::access_TCL_obj< ecolab::ref< T > >
 
struct  classdesc_access::access_TCL_obj< classdesc::shared_ptr< T > >
 
struct  classdesc_access::access_TCL_obj< classdesc::Enum_handle< T > >
 
struct  ecolab::TCL_accessor< F >
 for accessors (overloaded getter/setters that pretend to be attributes) More...
 
struct  ecolab::TCL_accessor< const F >
 const version - only getter is called More...
 
struct  ecolab::is_map< T >
 distinguish between maps and sets based on value_type of container More...
 
struct  classdesc_access::access_TCL_obj< ecolab::Accessor< T, G, S > >
 

Namespaces

 ecolab
 _OPENMP
 
 classdesc
 Contains definitions related to classdesc functionality.
 
 classdesc_access
 Contains access_* structs, and nothing else. These structs are used to gain access to private members.
 
 classdesc::functional
 contains code generated by functiondb.sh that defines functional attributes.
 

Macros

#define TCL_OBJ_DBG(x)
 
#define declare(name, typename, tcl_name)
 

Typedefs

typedef std::map< string, classdesc::shared_ptr< member_entry_base > > ecolab::TCL_obj_hash
 
typedef std::map< std::string, int > ecolab::classdesc::SVMap
 
typedef std::map< int, std::string > ecolab::classdesc::VSMap
 
typedef pack_t ecolab::classdesc::unpack_t
 
typedef pack_t ecolab::classdesc::xdr_pack
 

Enumerations

enum  ecolab::classdesc::Ptr_flag { DEFAULT, GRAPH, TREE }
 

Functions

template<class T >
void ecolab::ensure_exists (T *&x)
 
int ecolab::TCL_proc (ClientData cd, Tcl_Interp *interp, int argc, CONST84 char **argv)
 
int ecolab::TCL_oproc (ClientData cd, Tcl_Interp *interp, int argc, Tcl_Obj *const argv[])
 
void ecolab::TCL_delete (ClientData cd)
 
void ecolab::TCL_cmd_data_delete (ClientData cd)
 
template<class T >
TCL_args & ecolab::operator>> (TCL_args &a, T &x)
 
template<>
TCL_args & ecolab::operator>> (TCL_args &a, char *&x)
 
template<>
TCL_args & ecolab::operator>> (TCL_args &a, const char *&x)
 
void ecolab::parallel (TCL_args args)
 parallel declarator support for TCL_args
 
TCL_obj_hash & ecolab::TCL_obj_properties ()
 
void ecolab::eraseAllNamesStartingWith (const string &name)
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &, const string &, T &)
 
template<class T >
void ecolab::TCL_obj_onbase (TCL_obj_t &, const string &, T &)
 
template<class T >
std::string ecolab::classdesc::typeName ()
 
template<class T >
const EnumKeys< T > & ecolab::classdesc::enum_keys ()
 
template<class T >
enable_if< is_enum< T >, std::ostream & >::T ecolab::classdesc::operator<< (std::ostream &o, T x)
 
template<class T >
std::istream & ecolab::classdesc::operator>> (std::istream &i, Enum_handle< T > &x)
 
template<class T >
std::ostream & ecolab::classdesc::operator<< (std::ostream &o, Enum_handle< T > x)
 
template<class T >
Enum_handle< T > ecolab::classdesc::enum_handle (T &x)
 
std::string ecolab::classdesc::tail (const string &x)
 
std::string ecolab::classdesc::head (const string &x)
 
template<class T >
string ecolab::classdesc::basename ()
 returns a valid identifier to append to the descriptor of a base class
 
template<class T >
int ecolab::classdesc::deepCmp (const T &x, const T &y)
 deep comparison of two serialisable items
 
template<class T >
bool ecolab::classdesc::deepEq (const T &x, const T &y)
 deep equality of two serialisable items
 
template<class T >
pack_tecolab::classdesc::operator<< (pack_t &y, const T &x)
 
template<class T >
pack_tecolab::classdesc::operator>> (pack_t &y, T &x)
 
template<class T >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, is_treenode dum, const T *const &arg)
 serialise a tree (or DAG)
 
template<class T >
void ecolab::classdesc::unpack (unpack_t &targ, const string &desc, is_treenode dum, T *&arg)
 unserialise a tree. More...
 
template<class T >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, is_graphnode dum, const T &arg)
 serialise a graph structure More...
 
template<class T >
void ecolab::classdesc::unpack (pack_t &targ, const string &desc, is_graphnode dum, T &arg)
 unserialise a graph structure More...
 
template<class T >
void ecolab::classdesc::pack_onbase (pack_t &x, const string &d, T &a)
 
template<class T >
void ecolab::classdesc::unpack_onbase (unpack_t &x, const string &d, T &a)
 
template<class T >
enable_if< Not< pack_supported< T > >, void >::T ecolab::classdesc::pack (pack_t &buf, const string &desc, T &arg)
 
template<class T >
enable_if< Not< pack_supported< T > >, void >::T ecolab::classdesc::unpack (unpack_t &buf, const string &desc, T &arg)
 
template<class T >
enable_if< is_fundamental< T >, void >::T ecolab::classdesc::pack (pack_t &targ, const string &, T &arg)
 
template<class T >
enable_if< is_fundamental< T >, void >::T ecolab::classdesc::pack (pack_t &targ, const string &, const T &arg)
 
template<class T >
enable_if< is_fundamental< T >, void >::T ecolab::classdesc::unpack (unpack_t &targ, const string &, T &arg)
 
template<class T >
enable_if< is_fundamental< T >, void >::T ecolab::classdesc::unpack (unpack_t &targ, const string &, const T &)
 
template<class T >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, is_array, T &arg, int dims, size_t ncopies,...)
 
template<class T >
void ecolab::classdesc::unpack (unpack_t &targ, const string &desc, is_array, T &arg, int dims, size_t ncopies,...)
 
void ecolab::classdesc::pack (pack_t &targ, const string &, is_array, char &arg, int dims, size_t ncopies,...)
 
void ecolab::classdesc::unpack (unpack_t &targ, const string &, is_array, char &arg, int dims, size_t ncopies,...)
 
template<class C , class T >
void ecolab::classdesc::pack (pack_t &, const string &, C &, T)
 
template<class C , class T >
void ecolab::classdesc::unpack (unpack_t &, const string &, C &, T)
 
template<class C , class R , class A1 >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, R(C::*&arg)(A1))
 
template<class C , class R , class A1 >
void ecolab::classdesc::unpack (pack_t &targ, const string &desc, R(C::*&arg)(A1))
 
template<class T >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, is_const_static i, T t)
 const static support. No need to stream
 
template<class T >
void ecolab::classdesc::unpack (pack_t &targ, const string &desc, is_const_static i, T t)
 
template<class T , class U >
void ecolab::classdesc::pack (pack_t &, const string &, is_const_static, const T &, U)
 
template<class T , class U >
void ecolab::classdesc::unpack (pack_t &targ, const string &desc, is_const_static i, const T &, U)
 
template<class E >
void ecolab::classdesc::pack (pack_t &targ, const string &desc, Enum_handle< E > a)
 
template<class E >
void ecolab::classdesc::unpack (pack_t &targ, const string &desc, Enum_handle< E > a)
 
template<class A1 , class A2 , class R >
void ecolab::pack (classdesc::pack_t &targ, const classdesc::string &desc, std::binary_function< A1, A2, R > &arg)
 
template<class A1 , class A2 , class R >
void ecolab::unpack (classdesc::pack_t &targ, const classdesc::string &desc, std::binary_function< A1, A2, R > &arg)
 
template<class A , class R >
void ecolab::pack (classdesc::pack_t &targ, const classdesc::string &desc, std::unary_function< A, R > &arg)
 
template<class A , class R >
void ecolab::unpack (classdesc::pack_t &targ, const classdesc::string &desc, std::unary_function< A, R > &arg)
 
template<class C >
classdesc::enable_if< classdesc::is_container< C > >::T ecolab::pack (classdesc::pack_t &b, const classdesc::string &d, typename C::iterator &a)
 
template<class C >
classdesc::enable_if< classdesc::is_container< C > >::T ecolab::unpack (classdesc::pack_t &b, const classdesc::string &d, typename C::iterator &a)
 
template<class T >
void ecolab::classdesc::pack_graph (pack_t &buf, T &arg)
 
template<class T >
void ecolab::classdesc::unpack_graph (pack_t &buf, T &arg)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 0 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 0 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 1 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 1 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 2 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 2 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 3 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 3 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 4 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 4 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 5 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 5 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 6 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 6 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 7 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 7 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 8 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 8 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 9 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 9 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 10 > >, typename Return< F >::T >::T ecolab::classdesc::functional::apply_nonvoid_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class Args >
enable_if< And< AllArgs< F, is_rvalue >, Eq< Arity< F >::value, 10 > >, void >::T ecolab::classdesc::functional::apply_void_fn (F f, Args &a, Fdummy< F > dum=0)
 
template<class F , class X >
binder1st< F, X, Arity< F >::V-1 > ecolab::classdesc::functional::bind1st (const F &f, const X &x, dummy< 0 > dum=0)
 
template<class O , class M >
enable_if< is_member_function_pointer< M >, bound_method< O, M > >::T ecolab::classdesc::functional::bind1st (const M &member, O &obj, dummy< 1 > dum=0)
 
template<class F , class Args >
enable_if< Not< is_void< typename Return< F >::T > >, void >::T ecolab::classdesc::functional::apply (typename Return< F >::T *r, F f, const Args &args, dummy< 0 > d=0)
 
template<class F , class Args >
enable_if< is_void< typename Return< F >::T >, void >::T ecolab::classdesc::functional::apply (void *r, F f, Args &args, dummy< 1 > d=0)
 
template<class T >
void ecolab::std::swap (classdesc::ref< T > &x, classdesc::ref< T > &y)
 
template<class T , class CharT , class Traits >
enable_if< And< Not< is_enum< T > >, Not< is_container< T > > >, std::basic_istream< CharT, Traits > & >::T ecolab::operator>> (std::basic_istream< CharT, Traits > &x, T &y)
 
template<class T , class CharT , class Traits >
enable_if< is_sequence< T >, std::basic_istream< CharT, Traits > & >::T ecolab::operator>> (std::basic_istream< CharT, Traits > &x, T &y)
 
template<class T , class CharT , class Traits >
enable_if< is_associative_container< T >, std::basic_istream< CharT, Traits > & >::T ecolab::operator>> (std::basic_istream< CharT, Traits > &x, T &y)
 
template<class T , class CharT , class Traits >
enable_if< is_enum< T >, std::basic_istream< CharT, Traits > & >::T ecolab::operator>> (std::basic_istream< CharT, Traits > &x, T &y)
 
template<class T , class CharT , class Traits >
std::basic_istream< CharT, Traits > & ecolab::operator>> (std::basic_istream< CharT, Traits > &, ref< T > &y)
 
template<class T >
void ecolab::TCL_obj_register (const TCL_obj_t &targ, const string &desc, T &arg, bool base=false)
 
void ecolab::TCL_obj_deregister (const string &desc)
 
template<class T >
void ecolab::TCL_obj_custom_register (const string &desc, T &arg)
 a 'hook' to allow registrations to occur for TCL_objects (overriding base classes)
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, classdesc::is_array ia, T &arg, int dims,...)
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, classdesc::is_const_static s, const T &t)
 
template<class T , class U >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, classdesc::is_const_static s, const T &t, U u)
 const static method support
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, classdesc::is_treenode dum, T &arg)
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, classdesc::is_graphnode dum, T &arg)
 
template<class B , class A >
enable_if< And< Not< is_void< typename Return< B >::T > >, BoundMethodCallable< B > >, void >::T ecolab::newTCL_obj_functor_proc (B bm, A args, dummy< 0 > x=0)
 
template<class B , class A >
enable_if< And< is_void< typename Return< B >::T >, BoundMethodCallable< B > >, void >::T ecolab::newTCL_obj_functor_proc (B bm, A args, dummy< 1 > x=0)
 
template<class B , class A >
enable_if< Not< BoundMethodCallable< B > >, void >::T ecolab::newTCL_obj_functor_proc (B bm, A args, dummy< 2 > x=0)
 
template<class C , class M >
enable_if< is_member_function_pointer< M >, void >::T ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &c, M m)
 
template<class C , class M >
enable_if< functional::is_nonmember_function_ptr< M >, void >::T ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &c, M m)
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(C::*arg)(int, const char **))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(C::*arg)(int, char **))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(*arg)(int argc, const char **))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(*arg)(int argc, char **))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(C::*arg)(TCL_args))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(*arg)(TCL_args))
 
template<class C , class T >
void ecolab::TCL_obj (TCL_obj_t &targ, const string &desc, C &obj, T(*arg)(const TCL_args &))
 
template<class T >
void ecolab::TCL_obj (TCL_obj_t &t, const string &d, const Enum_handle< T > &a)
 
template<>
std::string ecolab::classdesc::typeName< bool > ()
 a string representation of the type
 
template<>
std::string ecolab::classdesc::typeName< char > ()
 
template<>
std::string ecolab::classdesc::typeName< short > ()
 
template<>
std::string ecolab::classdesc::typeName< int > ()
 
template<>
std::string ecolab::classdesc::typeName< long > ()
 
template<>
std::string ecolab::classdesc::typeName< signed char > ()
 
template<>
std::string ecolab::classdesc::typeName< unsigned char > ()
 
template<>
std::string ecolab::classdesc::typeName< unsigned short > ()
 
template<>
std::string ecolab::classdesc::typeName< unsigned int > ()
 
template<>
std::string ecolab::classdesc::typeName< unsigned long > ()
 
template<>
std::string ecolab::classdesc::typeName< float > ()
 
template<>
std::string ecolab::classdesc::typeName< double > ()
 
template<>
std::string ecolab::classdesc::typeName< long double > ()
 
template<>
std::string ecolab::classdesc::typeName< std::string > ()
 
template<>
std::string ecolab::classdesc::typeName< std::wstring > ()
 
template<class T , class U >
enable_if< is_integral< U >, T * >::T ecolab::classdesc::operator+ (U x, Exclude< T *> y)
 
template<class T >
std::ptrdiff_t ecolab::classdesc::operator- (const T *x, const Exclude< T *> y)
 
template<class T >
std::ptrdiff_t ecolab::classdesc::operator- (T *x, const Exclude< T *> y)
 
template<class T , class U >
ecolab::classdesc::mod (T x, U y)
 
template<class U >
float ecolab::classdesc::mod (float x, U y)
 
template<class U >
double ecolab::classdesc::mod (double x, U y)
 

Variables

classdesc::TCL_obj_t ecolab::null_TCL_obj
 a null TCL_obj_t suitable for nothing if needed.
 

Detailed Description

TCL access descriptor.

Macro Definition Documentation

◆ declare

#define declare (   name,
  typename,
  tcl_name 
)
Value:
typename *name##_entry; \
if (TCL_obj_properties().count(const_cast<char*>(tcl_name))==0) \
throw error("%s does not exist!",tcl_name); \
name##_entry=TCL_obj_properties()[tcl_name]->memberPtrCasted<typename>(); \
if (!name##_entry) \
throw error("Incorrect argument %s assigned to %s",tcl_name,#name); \
typename& name=*name##_entry;

Enumeration Type Documentation

◆ Ptr_flag

What to do with pointers: throw an exception, use graphnode or treenode algorithm)

Function Documentation

◆ pack()

template<class T >
void ecolab::classdesc::pack ( pack_t targ,
const string &  desc,
is_graphnode  dum,
const T &  arg 
)
inline

serialise a graph structure

can contain cycles

◆ unpack() [1/2]

template<class T >
void ecolab::classdesc::unpack ( unpack_t targ,
const string &  desc,
is_treenode  dum,
T *&  arg 
)
inline

unserialise a tree.

Serialised DAGs will be converted to a tree

◆ unpack() [2/2]

template<class T >
void ecolab::classdesc::unpack ( pack_t targ,
const string &  desc,
is_graphnode  dum,
T &  arg 
)
inline

unserialise a graph structure

can contain cycles