Exemplo n.º 1
0
void register_IOptionValidator_class(){

    { //::osiris::IOptionValidator
        typedef ::boost::python::class_< IOptionValidator_wrapper, ::boost::noncopyable > IOptionValidator_exposer_t;
        IOptionValidator_exposer_t IOptionValidator_exposer = IOptionValidator_exposer_t( "IOptionValidator", ::boost::python::init< >() );
        ::boost::python::scope IOptionValidator_scope( IOptionValidator_exposer );
        { //::osiris::IOptionValidator::validate
        
            typedef bool ( ::osiris::IOptionValidator::*validate_function_type )( ::osiris::DataItem const & ) const;
            
            IOptionValidator_exposer.def( 
                "validate"
                , ( validate_function_type(&::osiris::IOptionValidator::validate) )
                , ( ::boost::python::arg("value") ) );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IOptionValidator > >();
    }

}
Exemplo n.º 2
0
void register_ID_class(){

    { //::osiris::ID
        typedef ::boost::python::class_< ID_wrapper > ID_exposer_t;
        ID_exposer_t ID_exposer = ID_exposer_t( "ID", ::boost::python::init< >() );
        ::boost::python::scope ID_scope( ID_exposer );
        ::boost::python::enum_< ::osiris::ID::IDType>("IDType")
            .value("idUnknown", ::osiris::ID::idUnknown)
            .value("idPortal", ::osiris::ID::idPortal)
            .value("idObject", ::osiris::ID::idObject)
            .value("idModule", ::osiris::ID::idModule)
            .value("idComponent", ::osiris::ID::idComponent)
            .export_values()
            ;
        { //::osiris::ID::Header
            typedef ::boost::python::class_< ::osiris::ID::Header > Header_exposer_t;
            Header_exposer_t Header_exposer = Header_exposer_t( "Header", ::boost::python::init< ::osiris::ID::IDType >(( ::boost::python::arg("type") )) );
            ::boost::python::scope Header_scope( Header_exposer );
            ::boost::python::implicitly_convertible< ::osiris::ID::IDType, ::osiris::ID::Header >();
            { //::osiris::ID::Header::getType
            
                typedef boost::python::object ( *getType_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getType"
                    , getType_function_type( &getType_3cb634128d1d758beea2b1b763818e39 ) );
            
            }
            { //::osiris::ID::Header::getFirst
            
                typedef boost::python::object ( *getFirst_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getFirst"
                    , getFirst_function_type( &getFirst_9d0ef18d4a2e202a12d0e12cbe6af64a ) );
            
            }
            { //::osiris::ID::Header::getSecond
            
                typedef boost::python::object ( *getSecond_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getSecond"
                    , getSecond_function_type( &getSecond_2071a2840a28fd7c9175dfe04b4cf2e6 ) );
            
            }
            { //::osiris::ID::Header::getThird
            
                typedef boost::python::object ( *getThird_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getThird"
                    , getThird_function_type( &getThird_67a38bca0bd4fe381fb58e179df97d83 ) );
            
            }
            { //::osiris::ID::Header::getFourth
            
                typedef boost::python::object ( *getFourth_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getFourth"
                    , getFourth_function_type( &getFourth_39e93cc6c71d52d1aef3f25ac8ca05db ) );
            
            }
            { //::osiris::ID::Header::getValue
            
                typedef boost::python::object ( *getValue_function_type )( ::osiris::ID::Header const & );
                
                Header_exposer.def( 
                    "getValue"
                    , getValue_function_type( &getValue_36b44b39697fa40ef12535dbb67a07b2 ) );
            
            }
            { //::osiris::ID::Header::setFirst
            
                typedef void ( *setFirst_function_type )( ::osiris::ID::Header &,::osiris::byte );
                
                Header_exposer.def( 
                    "setFirst"
                    , setFirst_function_type( &setFirst_d43fa481bf77d2567a4d94a4093af298 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
            
            }
            { //::osiris::ID::Header::setSecond
            
                typedef void ( *setSecond_function_type )( ::osiris::ID::Header &,::osiris::byte );
                
                Header_exposer.def( 
                    "setSecond"
                    , setSecond_function_type( &setSecond_08fd38d1a62c013068407d5616d6af04 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
            
            }
            { //::osiris::ID::Header::setThird
            
                typedef void ( *setThird_function_type )( ::osiris::ID::Header &,::osiris::byte );
                
                Header_exposer.def( 
                    "setThird"
                    , setThird_function_type( &setThird_753c6c5f8d0e91719d5100475d06dc07 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
            
            }
            { //property "first"[fget=::osiris::ID::Header::getFirst, fset=::osiris::ID::Header::setFirst]
            
                typedef ::osiris::byte ( ::osiris::ID::Header::*fget )(  ) const;
                typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
                
                Header_exposer.add_property( 
                    "first"
                    , fget( &::osiris::ID::Header::getFirst )
                    , fset( &::osiris::ID::Header::setFirst )
                    , "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getFirst() const [member function]\" and \"void osiris::ID::Header::setFirst(osiris::byte value) [member function]\"" );
            
            }
            { //property "second"[fget=::osiris::ID::Header::getSecond, fset=::osiris::ID::Header::setSecond]
            
                typedef ::osiris::byte ( ::osiris::ID::Header::*fget )(  ) const;
                typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
                
                Header_exposer.add_property( 
                    "second"
                    , fget( &::osiris::ID::Header::getSecond )
                    , fset( &::osiris::ID::Header::setSecond )
                    , "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getSecond() const [member function]\" and \"void osiris::ID::Header::setSecond(osiris::byte value) [member function]\"" );
            
            }
            { //property "third"[fget=::osiris::ID::Header::getThird, fset=::osiris::ID::Header::setThird]
            
                typedef ::osiris::byte ( ::osiris::ID::Header::*fget )(  ) const;
                typedef void ( ::osiris::ID::Header::*fset )( ::osiris::byte ) ;
                
                Header_exposer.add_property( 
                    "third"
                    , fget( &::osiris::ID::Header::getThird )
                    , fset( &::osiris::ID::Header::setThird )
                    , "get\\set property, built on top of \"osiris::byte osiris::ID::Header::getThird() const [member function]\" and \"void osiris::ID::Header::setThird(osiris::byte value) [member function]\"" );
            
            }
            { //property "type"[fget=::osiris::ID::Header::getType]
            
                typedef ::osiris::ID::IDType ( ::osiris::ID::Header::*fget )(  ) const;
                
                Header_exposer.add_property( 
                    "type"
                    , fget( &::osiris::ID::Header::getType )
                    , "get property, built on top of \"osiris::ID::IDType osiris::ID::Header::getType() const [member function]\"" );
            
            }
            { //property "fourth"[fget=::osiris::ID::Header::getFourth]
            
                typedef ::osiris::byte ( ::osiris::ID::Header::*fget )(  ) const;
                
                Header_exposer.add_property( 
                    "fourth"
                    , fget( &::osiris::ID::Header::getFourth )
                    , "get property, built on top of \"osiris::byte osiris::ID::Header::getFourth() const [member function]\"" );
            
            }
            { //property "value"[fget=::osiris::ID::Header::getValue]
            
                typedef ::osiris::uint32 ( ::osiris::ID::Header::*fget )(  ) const;
                
                Header_exposer.add_property( 
                    "value"
                    , fget( &::osiris::ID::Header::getValue )
                    , "get property, built on top of \"osiris::uint32 osiris::ID::Header::getValue() const [member function]\"" );
            
            }
        }
        ID_exposer.def( ::boost::python::init< ::std::string const & >(( ::boost::python::arg("id") )) );
        ::boost::python::implicitly_convertible< ::std::string const &, ::osiris::ID >();
        ID_exposer.def( ::boost::python::init< ::osiris::ID const & >(( ::boost::python::arg("second") )) );
        { //::osiris::ID::getHeader
        
            typedef boost::python::object ( *getHeader_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "getHeader"
                , getHeader_function_type( &ID_wrapper::getHeader ) );
        
        }
        { //::osiris::ID::getString
        
            typedef boost::python::object ( *getString_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "getString"
                , getString_function_type( &ID_wrapper::getString ) );
        
        }
        { //::osiris::ID::getType
        
            typedef boost::python::object ( *getType_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "getType"
                , getType_function_type( &ID_wrapper::getType ) );
        
        }
        { //::osiris::ID::empty
        
            typedef boost::python::object ( *empty_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "empty"
                , empty_function_type( &ID_wrapper::empty ) );
        
        }
        { //::osiris::ID::toWide
        
            typedef boost::python::object ( *toWide_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "toWide"
                , toWide_function_type( &ID_wrapper::toWide ) );
        
        }
        { //::osiris::ID::toUTF16
        
            typedef boost::python::object ( *toUTF16_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "toUTF16"
                , toUTF16_function_type( &ID_wrapper::toUTF16 ) );
        
        }
        { //::osiris::ID::getHash
        
            typedef boost::python::object ( *getHash_function_type )( ::osiris::ID const & );
            
            ID_exposer.def( 
                "getHash"
                , getHash_function_type( &ID_wrapper::getHash ) );
        
        }
        { //::osiris::ID::clear
        
            typedef void ( *clear_function_type )( ::osiris::ID & );
            
            ID_exposer.def( 
                "clear"
                , clear_function_type( &ID_wrapper::clear ) );
        
        }
        { //::osiris::ID::getValidationType
        
            typedef ::osiris::ID::IDType ( ID_wrapper::*getValidationType_function_type )(  ) const;
            
            ID_exposer.def( 
                "getValidationType"
                , getValidationType_function_type( &ID_wrapper::default_getValidationType ) );
        
        }
        { //::osiris::ID::generateID
        
            typedef ::std::string ( *generateID_function_type )( ::osiris::ID::Header const &,::std::string const & );
            
            ID_exposer.def( 
                "generateID"
                , generateID_function_type( &ID_wrapper::generateID )
                , ( ::boost::python::arg("header"), ::boost::python::arg("hash") ) );
        
        }
        { //::osiris::ID::assign
        
            typedef boost::python::object ( *assign_function_type )( ::osiris::ID &,::std::string const & );
            
            ID_exposer.def( 
                "assign"
                , assign_function_type( &ID_wrapper::assign )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("id") ) );
        
        }
        { //::osiris::ID::operator=
        
            typedef ::osiris::ID & ( ::osiris::ID::*assign_function_type )( ::std::string const & ) ;
            
            ID_exposer.def( 
                "assign"
                , assign_function_type( &::osiris::ID::operator= )
                , ( ::boost::python::arg("id") )
                , bp::return_self< >() );
        
        }
        { //::osiris::ID::standardiseID
        
            typedef ::std::string ( *standardiseID_function_type )( ::std::string const & );
            
            ID_exposer.def( 
                "standardiseID"
                , standardiseID_function_type( &ID_wrapper::standardiseID )
                , ( ::boost::python::arg("id") ) );
        
        }
        { //::osiris::ID::validate
        
            typedef bool ( ::osiris::ID::*validate_function_type )( bool ) const;
            typedef bool ( ID_wrapper::*default_validate_function_type )( bool ) const;
            
            ID_exposer.def( 
                "validate"
                , validate_function_type(&::osiris::ID::validate)
                , default_validate_function_type(&ID_wrapper::default_validate)
                , ( ::boost::python::arg("allow_null") ) );
        
        }
        ID_exposer.def_readonly( "HASH_SIZE", ::osiris::ID::HASH_SIZE );
        ID_exposer.def_readonly( "HEADER_SIZE", ::osiris::ID::HEADER_SIZE );
        ID_exposer.def_readonly( "SIZE", ::osiris::ID::SIZE );
        ID_exposer.staticmethod( "generateID" );
        ID_exposer.staticmethod( "standardiseID" );
        { //property "header"[fget=::osiris::ID::getHeader]
        
            typedef ::osiris::ID::Header const & ( ::osiris::ID::*fget )(  ) const;
            
            ID_exposer.add_property( 
                "header"
                , ::boost::python::make_function( 
                      fget( &::osiris::ID::getHeader )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::ID::Header const & osiris::ID::getHeader() const [member function]\"" );
        
        }
        { //property "string"[fget=::osiris::ID::getString]
        
            typedef ::std::string const & ( ::osiris::ID::*fget )(  ) const;
            
            ID_exposer.add_property( 
                "string"
                , ::boost::python::make_function( 
                      fget( &::osiris::ID::getString )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"std::string const & osiris::ID::getString() const [member function]\"" );
        
        }
        { //property "type"[fget=::osiris::ID::getType]
        
            typedef ::osiris::ID::IDType ( ::osiris::ID::*fget )(  ) const;
            
            ID_exposer.add_property( 
                "type"
                , fget( &::osiris::ID::getType )
                , "get property, built on top of \"osiris::ID::IDType osiris::ID::getType() const [member function]\"" );
        
        }
        { //property "hash"[fget=::osiris::ID::getHash]
        
            typedef ::std::string ( ::osiris::ID::*fget )(  ) const;
            
            ID_exposer.add_property( 
                "hash"
                , fget( &::osiris::ID::getHash )
                , "get property, built on top of \"std::string osiris::ID::getHash() const [member function]\"" );
        
        }
    }

}