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_t &	ecolab::classdesc::operator<< (pack_t &y, const T &x)
template<class T >
pack_t &	ecolab::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 >
T	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

enum ecolab::classdesc::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