Exemplo n.º 1
0
void register_OMLEmoticon_class(){

    { //::osiris::OMLEmoticon
        typedef ::boost::python::class_< ::osiris::OMLEmoticon, ::boost::noncopyable > OMLEmoticon_exposer_t;
        OMLEmoticon_exposer_t OMLEmoticon_exposer = OMLEmoticon_exposer_t( "OMLEmoticon", ::boost::python::init< ::osiris::String const &, ::osiris::String const & >(( ::boost::python::arg("code"), ::boost::python::arg("name") )) );
        ::boost::python::scope OMLEmoticon_scope( OMLEmoticon_exposer );
        { //::osiris::OMLEmoticon::getCode
        
            typedef boost::python::object ( *getCode_function_type )( ::osiris::OMLEmoticon const & );
            
            OMLEmoticon_exposer.def( 
                "getCode"
                , getCode_function_type( &getCode_e9678af792082f1908fa860dfacb86a6 ) );
        
        }
        { //::osiris::OMLEmoticon::getName
        
            typedef boost::python::object ( *getName_function_type )( ::osiris::OMLEmoticon const & );
            
            OMLEmoticon_exposer.def( 
                "getName"
                , getName_function_type( &getName_0ef9029696fd7c04f2360fa3ecc4b7df ) );
        
        }
        { //property "code"[fget=::osiris::OMLEmoticon::getCode]
        
            typedef ::osiris::String const & ( ::osiris::OMLEmoticon::*fget )(  ) const;
            
            OMLEmoticon_exposer.add_property( 
                "code"
                , ::boost::python::make_function( 
                      fget( &::osiris::OMLEmoticon::getCode )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::String const & osiris::OMLEmoticon::getCode() const [member function]\"" );
        
        }
        { //property "name"[fget=::osiris::OMLEmoticon::getName]
        
            typedef ::osiris::String const & ( ::osiris::OMLEmoticon::*fget )(  ) const;
            
            OMLEmoticon_exposer.add_property( 
                "name"
                , ::boost::python::make_function( 
                      fget( &::osiris::OMLEmoticon::getName )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::String const & osiris::OMLEmoticon::getName() const [member function]\"" );
        
        }
    }

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

    {   //::osiris::IsisEndpoint
        typedef ::boost::python::class_< ::osiris::IsisEndpoint, ::boost::noncopyable > IsisEndpoint_exposer_t;
        IsisEndpoint_exposer_t IsisEndpoint_exposer = IsisEndpoint_exposer_t( "IsisEndpoint", ::boost::python::init< ::osiris::UniqueID const &, ::osiris::UniqueID const & >(( ::boost::python::arg("portalID"), ::boost::python::arg("povID") )) );
        ::boost::python::scope IsisEndpoint_scope( IsisEndpoint_exposer );
        {   //::osiris::IsisEndpoint::getActiveConnection

            typedef boost::python::object ( *getActiveConnection_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getActiveConnection"
                , getActiveConnection_function_type( &getActiveConnection_5c215cc9e6902f5630b5352756c4c588 ) );

        }
        {   //::osiris::IsisEndpoint::getName

            typedef boost::python::object ( *getName_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getName"
                , getName_function_type( &getName_3ac2e5037aae07c266b94fa2d31f36aa ) );

        }
        {   //::osiris::IsisEndpoint::getUrl

            typedef boost::python::object ( *getUrl_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getUrl"
                , getUrl_function_type( &getUrl_7ac0472b92bea982ca4ab123b4482d98 ) );

        }
        {   //::osiris::IsisEndpoint::getEnabled

            typedef boost::python::object ( *getEnabled_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getEnabled"
                , getEnabled_function_type( &getEnabled_ce68bb4512869331d5ae1a87b204f0b1 ) );

        }
        {   //::osiris::IsisEndpoint::getPassword

            typedef boost::python::object ( *getPassword_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getPassword"
                , getPassword_function_type( &getPassword_45d633e3916d8c969f507895db1fb54e ) );

        }
        {   //::osiris::IsisEndpoint::getLastEvent

            typedef boost::python::object ( *getLastEvent_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getLastEvent"
                , getLastEvent_function_type( &getLastEvent_d07e0a5ba6985e74bd5b9ceb3075a1f1 ) );

        }
        {   //::osiris::IsisEndpoint::isValid

            typedef boost::python::object ( *isValid_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "isValid"
                , isValid_function_type( &isValid_fddeaa97245366239197c6bc03176ef6 ) );

        }
        {   //::osiris::IsisEndpoint::getIsisOptions

            typedef boost::python::object ( *getIsisOptions_function_type )( ::osiris::IsisEndpoint const & );

            IsisEndpoint_exposer.def(
                "getIsisOptions"
                , getIsisOptions_function_type( &getIsisOptions_400af9f3841307d7552da34674e998c6 ) );

        }
        {   //::osiris::IsisEndpoint::close

            typedef void ( *close_function_type )( ::osiris::IsisEndpoint & );

            IsisEndpoint_exposer.def(
                "close"
                , close_function_type( &close_5d516c25c853d496f943c590d819f396 ) );

        }
        {   //::osiris::IsisEndpoint::canStart

            typedef boost::python::object ( *canStart_function_type )( ::osiris::IsisEndpoint & );

            IsisEndpoint_exposer.def(
                "canStart"
                , canStart_function_type( &canStart_a6507f1ce1b9cb3b1d940307f5252d86 ) );

        }
        {   //::osiris::IsisEndpoint::matchUrl

            typedef boost::python::object ( *matchUrl_function_type )( ::osiris::IsisEndpoint &,::osiris::HttpUrl const & );

            IsisEndpoint_exposer.def(
                "matchUrl"
                , matchUrl_function_type( &matchUrl_49f5a47c6531fe64ec9cd6848475ab5c )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("url") ) );

        }
        {   //::osiris::IsisEndpoint::parseSystemInformation

            typedef void ( *parseSystemInformation_function_type )( ::osiris::IsisEndpoint &,::boost::shared_ptr<osiris::XMLNode> );

            IsisEndpoint_exposer.def(
                "parseSystemInformation"
                , parseSystemInformation_function_type( &parseSystemInformation_8bbb276dd0313f83d4c465a3fa8555c9 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("root") ) );

        }
        {   //::osiris::IsisEndpoint::setEnabled

            typedef void ( *setEnabled_function_type )( ::osiris::IsisEndpoint &,bool );

            IsisEndpoint_exposer.def(
                "setEnabled"
                , setEnabled_function_type( &setEnabled_e6fae3d82204015b4f7f6e6f018e0e34 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("enabled") ) );

        }
        {   //::osiris::IsisEndpoint::setLastEvent

            typedef void ( *setLastEvent_function_type )( ::osiris::IsisEndpoint &,::osiris::String const & );

            IsisEndpoint_exposer.def(
                "setLastEvent"
                , setLastEvent_function_type( &setLastEvent_a1055dd72306b14be76285482e1d48f7 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("lastEvent") ) );

        }
        {   //::osiris::IsisEndpoint::setName

            typedef void ( *setName_function_type )( ::osiris::IsisEndpoint &,::osiris::String const & );

            IsisEndpoint_exposer.def(
                "setName"
                , setName_function_type( &setName_7a9d3b36a1141fca4b41cece4309fe72 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );

        }
        {   //::osiris::IsisEndpoint::setPassword

            typedef void ( *setPassword_function_type )( ::osiris::IsisEndpoint &,::osiris::String const & );

            IsisEndpoint_exposer.def(
                "setPassword"
                , setPassword_function_type( &setPassword_cc726213351b6d49b08c4aa93436fc64 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("password") ) );

        }
        {   //::osiris::IsisEndpoint::setUrl

            typedef void ( *setUrl_function_type )( ::osiris::IsisEndpoint &,::osiris::HttpUrl const & );

            IsisEndpoint_exposer.def(
                "setUrl"
                , setUrl_function_type( &setUrl_4be48cbe77c055f26febb988868c68f3 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("url") ) );

        }
        {   //::osiris::IsisEndpoint::update

            typedef void ( *update_function_type )( ::osiris::IsisEndpoint &,::boost::shared_ptr<osiris::ConnectionsManager> );

            IsisEndpoint_exposer.def(
                "update"
                , update_function_type( &update_a258c26965165ef581962c1e7ee374f8 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("connectionsManager") ) );

        }
        {   //property "name"[fget=::osiris::IsisEndpoint::getName, fset=::osiris::IsisEndpoint::setName]

            typedef ::osiris::String ( ::osiris::IsisEndpoint::*fget )(  ) const;
            typedef void ( ::osiris::IsisEndpoint::*fset )( ::osiris::String const & ) ;

            IsisEndpoint_exposer.add_property(
                "name"
                , fget( &::osiris::IsisEndpoint::getName )
                , fset( &::osiris::IsisEndpoint::setName )
                , "get\\set property, built on top of \"osiris::String osiris::IsisEndpoint::getName() const [member function]\" and \"void osiris::IsisEndpoint::setName(osiris::String const & name) [member function]\"" );

        }
        {   //property "url"[fget=::osiris::IsisEndpoint::getUrl, fset=::osiris::IsisEndpoint::setUrl]

            typedef ::osiris::HttpUrl ( ::osiris::IsisEndpoint::*fget )(  ) const;
            typedef void ( ::osiris::IsisEndpoint::*fset )( ::osiris::HttpUrl const & ) ;

            IsisEndpoint_exposer.add_property(
                "url"
                , fget( &::osiris::IsisEndpoint::getUrl )
                , fset( &::osiris::IsisEndpoint::setUrl )
                , "get\\set property, built on top of \"osiris::HttpUrl osiris::IsisEndpoint::getUrl() const [member function]\" and \"void osiris::IsisEndpoint::setUrl(osiris::HttpUrl const & url) [member function]\"" );

        }
        {   //property "enabled"[fget=::osiris::IsisEndpoint::getEnabled, fset=::osiris::IsisEndpoint::setEnabled]

            typedef bool ( ::osiris::IsisEndpoint::*fget )(  ) const;
            typedef void ( ::osiris::IsisEndpoint::*fset )( bool ) ;

            IsisEndpoint_exposer.add_property(
                "enabled"
                , fget( &::osiris::IsisEndpoint::getEnabled )
                , fset( &::osiris::IsisEndpoint::setEnabled )
                , "get\\set property, built on top of \"bool osiris::IsisEndpoint::getEnabled() const [member function]\" and \"void osiris::IsisEndpoint::setEnabled(bool enabled) [member function]\"" );

        }
        {   //property "password"[fget=::osiris::IsisEndpoint::getPassword, fset=::osiris::IsisEndpoint::setPassword]

            typedef ::osiris::String ( ::osiris::IsisEndpoint::*fget )(  ) const;
            typedef void ( ::osiris::IsisEndpoint::*fset )( ::osiris::String const & ) ;

            IsisEndpoint_exposer.add_property(
                "password"
                , fget( &::osiris::IsisEndpoint::getPassword )
                , fset( &::osiris::IsisEndpoint::setPassword )
                , "get\\set property, built on top of \"osiris::String osiris::IsisEndpoint::getPassword() const [member function]\" and \"void osiris::IsisEndpoint::setPassword(osiris::String const & password) [member function]\"" );

        }
        {   //property "lastEvent"[fget=::osiris::IsisEndpoint::getLastEvent, fset=::osiris::IsisEndpoint::setLastEvent]

            typedef ::osiris::String ( ::osiris::IsisEndpoint::*fget )(  ) const;
            typedef void ( ::osiris::IsisEndpoint::*fset )( ::osiris::String const & ) ;

            IsisEndpoint_exposer.add_property(
                "lastEvent"
                , fget( &::osiris::IsisEndpoint::getLastEvent )
                , fset( &::osiris::IsisEndpoint::setLastEvent )
                , "get\\set property, built on top of \"osiris::String osiris::IsisEndpoint::getLastEvent() const [member function]\" and \"void osiris::IsisEndpoint::setLastEvent(osiris::String const & lastEvent) [member function]\"" );

        }
        {   //property "activeConnection"[fget=::osiris::IsisEndpoint::getActiveConnection]

            typedef ::boost::shared_ptr<osiris::IsisConnection> ( ::osiris::IsisEndpoint::*fget )(  ) const;

            IsisEndpoint_exposer.add_property(
                "activeConnection"
                , fget( &::osiris::IsisEndpoint::getActiveConnection )
                , "get property, built on top of \"boost::shared_ptr<osiris::IsisConnection> osiris::IsisEndpoint::getActiveConnection() const [member function]\"" );

        }
        {   //property "isisOptions"[fget=::osiris::IsisEndpoint::getIsisOptions]

            typedef ::osiris::XMLOptions const & ( ::osiris::IsisEndpoint::*fget )(  ) const;

            IsisEndpoint_exposer.add_property(
                "isisOptions"
                , ::boost::python::make_function(
                    fget( &::osiris::IsisEndpoint::getIsisOptions )
                    , bp::return_value_policy< bp::copy_const_reference >() )
                , "get property, built on top of \"osiris::XMLOptions const & osiris::IsisEndpoint::getIsisOptions() const [member function]\"" );

        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IsisEndpoint > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IsisEndpoint >, boost::shared_ptr< ::osiris::enable_this_ptr< osiris::IsisEndpoint > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IsisEndpoint >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Exemplo n.º 3
0
void register_IdePathway_class(){

    { //::osiris::IdePathway
        typedef ::boost::python::class_< ::osiris::IdePathway > IdePathway_exposer_t;
        IdePathway_exposer_t IdePathway_exposer = IdePathway_exposer_t( "IdePathway", ::boost::python::init< >() );
        ::boost::python::scope IdePathway_scope( IdePathway_exposer );
        { //::osiris::IdePathway::Path
            typedef ::boost::python::class_< ::osiris::IdePathway::Path, ::boost::noncopyable > Path_exposer_t;
            Path_exposer_t Path_exposer = Path_exposer_t( "Path", ::boost::python::init< ::osiris::String const &, ::osiris::String const &, ::osiris::String const &, ::boost::python::optional< ::osiris::String const & > >(( ::boost::python::arg("name"), ::boost::python::arg("href"), ::boost::python::arg("id"), ::boost::python::arg("type")=osiris::String::EMPTY )) );
            ::boost::python::scope Path_scope( Path_exposer );
            { //::osiris::IdePathway::Path::getName
            
                typedef boost::python::object ( *getName_function_type )( ::osiris::IdePathway::Path const & );
                
                Path_exposer.def( 
                    "getName"
                    , getName_function_type( &getName_8433ebd067855f6f6bf88ff9dd558ab2 ) );
            
            }
            { //::osiris::IdePathway::Path::getHref
            
                typedef boost::python::object ( *getHref_function_type )( ::osiris::IdePathway::Path const & );
                
                Path_exposer.def( 
                    "getHref"
                    , getHref_function_type( &getHref_1a0252908b4a8807b88123b24bbe3511 ) );
            
            }
            { //::osiris::IdePathway::Path::getID
            
                typedef boost::python::object ( *getID_function_type )( ::osiris::IdePathway::Path const & );
                
                Path_exposer.def( 
                    "getID"
                    , getID_function_type( &getID_6a2110e5630944f8ac9326492ceafa6c ) );
            
            }
            { //::osiris::IdePathway::Path::exportXML
            
                typedef void ( *exportXML_function_type )( ::osiris::IdePathway::Path const &,::boost::shared_ptr<osiris::XMLNode> );
                
                Path_exposer.def( 
                    "exportXML"
                    , exportXML_function_type( &exportXML_543077b7e725562755dee943582abfc1 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("node") ) );
            
            }
            { //::osiris::IdePathway::Path::setHref
            
                typedef void ( *setHref_function_type )( ::osiris::IdePathway::Path &,::osiris::String const & );
                
                Path_exposer.def( 
                    "setHref"
                    , setHref_function_type( &setHref_3b7c5feea710c5f0da77ac3e3a40c322 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("href") ) );
            
            }
            { //::osiris::IdePathway::Path::setID
            
                typedef void ( *setID_function_type )( ::osiris::IdePathway::Path &,::osiris::UniqueID const & );
                
                Path_exposer.def( 
                    "setID"
                    , setID_function_type( &setID_00eaf444ac900407b0fb81c61b5ae908 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("id") ) );
            
            }
            { //::osiris::IdePathway::Path::setName
            
                typedef void ( *setName_function_type )( ::osiris::IdePathway::Path &,::osiris::String const & );
                
                Path_exposer.def( 
                    "setName"
                    , setName_function_type( &setName_919aa98ef71512c7da70b05b1a39ca87 )
                    , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
            
            }
            { //property "name"[fget=::osiris::IdePathway::Path::getName, fset=::osiris::IdePathway::Path::setName]
            
                typedef ::osiris::String const & ( ::osiris::IdePathway::Path::*fget )(  ) const;
                typedef void ( ::osiris::IdePathway::Path::*fset )( ::osiris::String const & ) ;
                
                Path_exposer.add_property( 
                    "name"
                    , ::boost::python::make_function( 
                          fget( &::osiris::IdePathway::Path::getName )
                        , bp::return_value_policy< bp::copy_const_reference >() ) 
                    , fset( &::osiris::IdePathway::Path::setName )
                    , "get\\set property, built on top of \"osiris::String const & osiris::IdePathway::Path::getName() const [member function]\" and \"void osiris::IdePathway::Path::setName(osiris::String const & name) [member function]\"" );
            
            }
            { //property "href"[fget=::osiris::IdePathway::Path::getHref, fset=::osiris::IdePathway::Path::setHref]
            
                typedef ::osiris::String const & ( ::osiris::IdePathway::Path::*fget )(  ) const;
                typedef void ( ::osiris::IdePathway::Path::*fset )( ::osiris::String const & ) ;
                
                Path_exposer.add_property( 
                    "href"
                    , ::boost::python::make_function( 
                          fget( &::osiris::IdePathway::Path::getHref )
                        , bp::return_value_policy< bp::copy_const_reference >() ) 
                    , fset( &::osiris::IdePathway::Path::setHref )
                    , "get\\set property, built on top of \"osiris::String const & osiris::IdePathway::Path::getHref() const [member function]\" and \"void osiris::IdePathway::Path::setHref(osiris::String const & href) [member function]\"" );
            
            }
            { //property "id"[fget=::osiris::IdePathway::Path::getID, fset=::osiris::IdePathway::Path::setID]
            
                typedef ::osiris::UniqueID const & ( ::osiris::IdePathway::Path::*fget )(  ) const;
                typedef void ( ::osiris::IdePathway::Path::*fset )( ::osiris::UniqueID const & ) ;
                
                Path_exposer.add_property( 
                    "id"
                    , ::boost::python::make_function( 
                          fget( &::osiris::IdePathway::Path::getID )
                        , bp::return_value_policy< bp::copy_const_reference >() ) 
                    , fset( &::osiris::IdePathway::Path::setID )
                    , "get\\set property, built on top of \"osiris::UniqueID const & osiris::IdePathway::Path::getID() const [member function]\" and \"void osiris::IdePathway::Path::setID(osiris::UniqueID const & id) [member function]\"" );
            
            }
            ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IdePathway::Path > >();
            ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IdePathway::Path >, boost::shared_ptr< ::osiris::Object > >();
            ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IdePathway::Path >, boost::shared_ptr< ::osiris::AllocWrapper< osiris::Object, osiris::SysAllocator< osiris::Object > > > >();
        }
        { //::osiris::IdePathway::add
        
            typedef void ( *add_function_type )( ::osiris::IdePathway &,::osiris::String const &,::osiris::String const & );
            
            IdePathway_exposer.def( 
                "add"
                , add_function_type( &add_cd172717620ace362d03a6f0b79e680f )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name"), ::boost::python::arg("href") ) );
        
        }
        { //::osiris::IdePathway::add
        
            typedef void ( *add_function_type )( ::osiris::IdePathway &,::osiris::String const &,::osiris::String const &,::osiris::UniqueID const & );
            
            IdePathway_exposer.def( 
                "add"
                , add_function_type( &add_b5489ac576272269d19b300d514d61ab )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name"), ::boost::python::arg("href"), ::boost::python::arg("id") ) );
        
        }
        { //::osiris::IdePathway::add
        
            typedef void ( *add_function_type )( ::osiris::IdePathway &,::boost::shared_ptr<osiris::IPortalDatabase>,::boost::shared_ptr<osiris::EntitiesEntity>,::osiris::ObjectsRenderMode );
            
            IdePathway_exposer.def( 
                "add"
                , add_function_type( &add_8f6b3dbcd2118ba9684888736d27fb11 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("database"), ::boost::python::arg("entity"), ::boost::python::arg("mode") ) );
        
        }
        { //::osiris::IdePathway::add
        
            typedef void ( *add_function_type )( ::osiris::IdePathway &,::boost::shared_ptr<osiris::IdePathway::Path> );
            
            IdePathway_exposer.def( 
                "add"
                , add_function_type( &add_ace7198b13a32b47eeb3e5bd60245467 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IdePathway::exportXML
        
            typedef void ( *exportXML_function_type )( ::osiris::IdePathway const &,::boost::shared_ptr<osiris::XMLNode> );
            
            IdePathway_exposer.def( 
                "exportXML"
                , exportXML_function_type( &exportXML_f6f117bfb66685bf8676c608a5ef1fe5 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("node") ) );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IdePathway > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IdePathway >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Exemplo n.º 4
0
void register_IHttpServer_class(){

    { //::osiris::IHttpServer
        typedef ::boost::python::class_< IHttpServer_wrapper, ::boost::python::bases< ::osiris::IServer >, ::boost::noncopyable > IHttpServer_exposer_t;
        IHttpServer_exposer_t IHttpServer_exposer = IHttpServer_exposer_t( "IHttpServer", ::boost::python::init< ::std::string const &, ::boost::python::optional< bool, ::osiris::uint32, ::boost::optional< unsigned int > > >(( ::boost::python::arg("name"), ::boost::python::arg("allowRemoteConnections")=(bool)(false), ::boost::python::arg("sessionDuration")=(::osiris::uint32)(30), ::boost::python::arg("workerThreadsCount")=boost::none )) );
        ::boost::python::scope IHttpServer_scope( IHttpServer_exposer );
        { //::osiris::IHttpServer::getName
        
            typedef boost::python::object ( *getName_function_type )( ::osiris::IHttpServer const & );
            
            IHttpServer_exposer.def( 
                "getName"
                , getName_function_type( &IHttpServer_wrapper::getName ) );
        
        }
        { //::osiris::IHttpServer::getRootDirectory
        
            typedef boost::python::object ( *getRootDirectory_function_type )( ::osiris::IHttpServer const & );
            
            IHttpServer_exposer.def( 
                "getRootDirectory"
                , getRootDirectory_function_type( &IHttpServer_wrapper::getRootDirectory ) );
        
        }
        { //::osiris::IHttpServer::getAllowRemoteConnections
        
            typedef boost::python::object ( *getAllowRemoteConnections_function_type )( ::osiris::IHttpServer const & );
            
            IHttpServer_exposer.def( 
                "getAllowRemoteConnections"
                , getAllowRemoteConnections_function_type( &IHttpServer_wrapper::getAllowRemoteConnections ) );
        
        }
        { //::osiris::IHttpServer::getDefaultDirectory
        
            typedef boost::python::object ( *getDefaultDirectory_function_type )( ::osiris::IHttpServer const & );
            
            IHttpServer_exposer.def( 
                "getDefaultDirectory"
                , getDefaultDirectory_function_type( &IHttpServer_wrapper::getDefaultDirectory ) );
        
        }
        { //::osiris::IHttpServer::getSessionsDuration
        
            typedef boost::python::object ( *getSessionsDuration_function_type )( ::osiris::IHttpServer const & );
            
            IHttpServer_exposer.def( 
                "getSessionsDuration"
                , getSessionsDuration_function_type( &IHttpServer_wrapper::getSessionsDuration ) );
        
        }
        { //::osiris::IHttpServer::getRequestMutex
        
            typedef boost::python::object ( *getRequestMutex_function_type )( ::osiris::IHttpServer & );
            
            IHttpServer_exposer.def( 
                "getRequestMutex"
                , getRequestMutex_function_type( &IHttpServer_wrapper::getRequestMutex ) );
        
        }
        { //::osiris::IHttpServer::addResourceLocation
        
            typedef boost::python::object ( *addResourceLocation_function_type )( ::osiris::IHttpServer &,::osiris::String const &,::osiris::String const & );
            
            IHttpServer_exposer.def( 
                "addResourceLocation"
                , addResourceLocation_function_type( &IHttpServer_wrapper::addResourceLocation )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IHttpServer::peekHttpBuffer
        
            typedef boost::python::object ( *peekHttpBuffer_function_type )( ::osiris::IHttpServer & );
            
            IHttpServer_exposer.def( 
                "peekHttpBuffer"
                , peekHttpBuffer_function_type( &IHttpServer_wrapper::peekHttpBuffer ) );
        
        }
        { //::osiris::IHttpServer::processRequest
        
            typedef bool ( ::osiris::IHttpServer::*processRequest_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            typedef bool ( IHttpServer_wrapper::*default_processRequest_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            
            IHttpServer_exposer.def( 
                "processRequest"
                , processRequest_function_type(&::osiris::IHttpServer::processRequest)
                , default_processRequest_function_type(&IHttpServer_wrapper::default_processRequest)
                , ( ::boost::python::arg("session"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IHttpServer::getSessionState
        
            typedef ::boost::shared_ptr< osiris::HttpSessionState > ( ::osiris::IHttpServer::*getSessionState_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            typedef ::boost::shared_ptr< osiris::HttpSessionState > ( IHttpServer_wrapper::*default_getSessionState_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            
            IHttpServer_exposer.def( 
                "getSessionState"
                , getSessionState_function_type(&::osiris::IHttpServer::getSessionState)
                , default_getSessionState_function_type(&IHttpServer_wrapper::default_getSessionState)
                , ( ::boost::python::arg("session"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IHttpServer::onIdle
        
            typedef bool ( IHttpServer_wrapper::*onIdle_function_type )(  ) ;
            
            IHttpServer_exposer.def( 
                "onIdle"
                , onIdle_function_type( &IHttpServer_wrapper::default_onIdle ) );
        
        }
        { //::osiris::IHttpServer::addDirectory
        
            typedef boost::python::object ( *addDirectory_function_type )( ::osiris::IHttpServer &,::boost::shared_ptr<osiris::IHttpDirectory> );
            
            IHttpServer_exposer.def( 
                "addDirectory"
                , addDirectory_function_type( &IHttpServer_wrapper::addDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory") ) );
        
        }
        { //::osiris::IHttpServer::getDirectory
        
            typedef boost::python::object ( *getDirectory_function_type )( ::osiris::IHttpServer const &,::osiris::String const & );
            
            IHttpServer_exposer.def( 
                "getDirectory"
                , getDirectory_function_type( &IHttpServer_wrapper::getDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IHttpServer::hasDirectory
        
            typedef boost::python::object ( *hasDirectory_function_type )( ::osiris::IHttpServer const &,::osiris::String const & );
            
            IHttpServer_exposer.def( 
                "hasDirectory"
                , hasDirectory_function_type( &IHttpServer_wrapper::hasDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IHttpServer::onAccept
        
            typedef bool ( IHttpServer_wrapper::*onAccept_function_type )( ::boost::shared_ptr< osiris::IConnection > ) ;
            
            IHttpServer_exposer.def( 
                "onAccept"
                , onAccept_function_type( &IHttpServer_wrapper::default_onAccept )
                , ( ::boost::python::arg("connection") ) );
        
        }
        { //::osiris::IHttpServer::removeDirectory
        
            typedef boost::python::object ( *removeDirectory_function_type )( ::osiris::IHttpServer &,::boost::shared_ptr<osiris::IHttpDirectory> );
            
            IHttpServer_exposer.def( 
                "removeDirectory"
                , removeDirectory_function_type( &IHttpServer_wrapper::removeDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory") ) );
        
        }
        { //::osiris::IHttpServer::setAllowRemoteConnections
        
            typedef void ( *setAllowRemoteConnections_function_type )( ::osiris::IHttpServer &,bool );
            
            IHttpServer_exposer.def( 
                "setAllowRemoteConnections"
                , setAllowRemoteConnections_function_type( &IHttpServer_wrapper::setAllowRemoteConnections )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("allow") ) );
        
        }
        { //::osiris::IHttpServer::setDefaultDirectory
        
            typedef void ( *setDefaultDirectory_function_type )( ::osiris::IHttpServer &,::osiris::String const & );
            
            IHttpServer_exposer.def( 
                "setDefaultDirectory"
                , setDefaultDirectory_function_type( &IHttpServer_wrapper::setDefaultDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory") ) );
        
        }
        { //::osiris::IHttpServer::setSessionsDuration
        
            typedef void ( *setSessionsDuration_function_type )( ::osiris::IHttpServer &,::osiris::TimeDuration const & );
            
            IHttpServer_exposer.def( 
                "setSessionsDuration"
                , setSessionsDuration_function_type( &IHttpServer_wrapper::setSessionsDuration )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("duration") ) );
        
        }
        { //::osiris::IServer::bind
        
            typedef bool ( ::osiris::IServer::*bind_function_type )( ::osiris::String const &,::osiris::uint32 ) ;
            typedef bool ( IHttpServer_wrapper::*default_bind_function_type )( ::osiris::String const &,::osiris::uint32 ) ;
            
            IHttpServer_exposer.def( 
                "bind"
                , bind_function_type(&::osiris::IServer::bind)
                , default_bind_function_type(&IHttpServer_wrapper::default_bind)
                , ( ::boost::python::arg("bindIP")=(osiris::String::EMPTY), ::boost::python::arg("port")=(::osiris::uint32)(0) ) );
        
        }
        { //::osiris::IServer::createConnection
        
            typedef ::boost::shared_ptr< osiris::IConnection > ( IHttpServer_wrapper::*createConnection_function_type )(  ) ;
            
            IHttpServer_exposer.def( 
                "createConnection"
                , createConnection_function_type( &IHttpServer_wrapper::createConnection ) );
        
        }
        { //::osiris::IServer::onEnter
        
            typedef bool ( IHttpServer_wrapper::*onEnter_function_type )(  ) ;
            
            IHttpServer_exposer.def( 
                "onEnter"
                , onEnter_function_type( &IHttpServer_wrapper::default_onEnter ) );
        
        }
        { //::osiris::IServer::stop
        
            typedef void ( ::osiris::IServer::*stop_function_type )(  ) ;
            typedef void ( IHttpServer_wrapper::*default_stop_function_type )(  ) ;
            
            IHttpServer_exposer.def( 
                "stop"
                , stop_function_type(&::osiris::IServer::stop)
                , default_stop_function_type(&IHttpServer_wrapper::default_stop) );
        
        }
        { //property "allowRemoteConnections"[fget=::osiris::IHttpServer::getAllowRemoteConnections, fset=::osiris::IHttpServer::setAllowRemoteConnections]
        
            typedef bool ( ::osiris::IHttpServer::*fget )(  ) const;
            typedef void ( ::osiris::IHttpServer::*fset )( bool ) ;
            
            IHttpServer_exposer.add_property( 
                "allowRemoteConnections"
                , fget( &::osiris::IHttpServer::getAllowRemoteConnections )
                , fset( &::osiris::IHttpServer::setAllowRemoteConnections )
                , "get\\set property, built on top of \"bool osiris::IHttpServer::getAllowRemoteConnections() const [member function]\" and \"void osiris::IHttpServer::setAllowRemoteConnections(bool allow) [member function]\"" );
        
        }
        { //property "defaultDirectory"[fget=::osiris::IHttpServer::getDefaultDirectory, fset=::osiris::IHttpServer::setDefaultDirectory]
        
            typedef ::osiris::String ( ::osiris::IHttpServer::*fget )(  ) const;
            typedef void ( ::osiris::IHttpServer::*fset )( ::osiris::String const & ) ;
            
            IHttpServer_exposer.add_property( 
                "defaultDirectory"
                , fget( &::osiris::IHttpServer::getDefaultDirectory )
                , fset( &::osiris::IHttpServer::setDefaultDirectory )
                , "get\\set property, built on top of \"osiris::String osiris::IHttpServer::getDefaultDirectory() const [member function]\" and \"void osiris::IHttpServer::setDefaultDirectory(osiris::String const & directory) [member function]\"" );
        
        }
        { //property "sessionsDuration"[fget=::osiris::IHttpServer::getSessionsDuration, fset=::osiris::IHttpServer::setSessionsDuration]
        
            typedef ::osiris::TimeDuration const & ( ::osiris::IHttpServer::*fget )(  ) const;
            typedef void ( ::osiris::IHttpServer::*fset )( ::osiris::TimeDuration const & ) ;
            
            IHttpServer_exposer.add_property( 
                "sessionsDuration"
                , ::boost::python::make_function( 
                      fget( &::osiris::IHttpServer::getSessionsDuration )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::IHttpServer::setSessionsDuration )
                , "get\\set property, built on top of \"osiris::TimeDuration const & osiris::IHttpServer::getSessionsDuration() const [member function]\" and \"void osiris::IHttpServer::setSessionsDuration(osiris::TimeDuration const & duration) [member function]\"" );
        
        }
        { //property "name"[fget=::osiris::IHttpServer::getName]
        
            typedef ::std::string const & ( ::osiris::IHttpServer::*fget )(  ) const;
            
            IHttpServer_exposer.add_property( 
                "name"
                , ::boost::python::make_function( 
                      fget( &::osiris::IHttpServer::getName )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"std::string const & osiris::IHttpServer::getName() const [member function]\"" );
        
        }
        { //property "rootDirectory"[fget=::osiris::IHttpServer::getRootDirectory]
        
            typedef ::boost::shared_ptr<osiris::IHttpDirectory> ( ::osiris::IHttpServer::*fget )(  ) const;
            
            IHttpServer_exposer.add_property( 
                "rootDirectory"
                , fget( &::osiris::IHttpServer::getRootDirectory )
                , "get property, built on top of \"boost::shared_ptr<osiris::IHttpDirectory> osiris::IHttpServer::getRootDirectory() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IHttpServer > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::IServer > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::NetworkService > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::enable_this_ptr< osiris::NetworkService > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::Thread > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::boost::noncopyable_::noncopyable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::IRunnable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpServer >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Exemplo n.º 5
0
void register_IdeAccount_class(){

    { //::osiris::IdeAccount
        typedef ::boost::python::class_< ::osiris::IdeAccount, ::boost::noncopyable > IdeAccount_exposer_t;
        IdeAccount_exposer_t IdeAccount_exposer = IdeAccount_exposer_t( "IdeAccount", ::boost::python::init< ::boost::shared_ptr< osiris::DataAccount > >(( ::boost::python::arg("account") )) );
        ::boost::python::scope IdeAccount_scope( IdeAccount_exposer );
        ::boost::python::implicitly_convertible< ::boost::shared_ptr< osiris::DataAccount >, ::osiris::IdeAccount >();
        { //::osiris::IdeAccount::getAccount
        
            typedef boost::python::object ( *getAccount_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getAccount"
                , getAccount_function_type( &getAccount_81a7959660e76fbae82ba66de471c7e4 ) );
        
        }
        { //::osiris::IdeAccount::getID
        
            typedef boost::python::object ( *getID_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getID"
                , getID_function_type( &getID_0e0acb33b9f4db8ebe527a9882150e6d ) );
        
        }
        { //::osiris::IdeAccount::getName
        
            typedef boost::python::object ( *getName_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getName"
                , getName_function_type( &getName_8dfe4c11dc829d738415eaba89567839 ) );
        
        }
        { //::osiris::IdeAccount::getSkinID
        
            typedef boost::python::object ( *getSkinID_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getSkinID"
                , getSkinID_function_type( &getSkinID_6156637fd2e490834fe324051e858875 ) );
        
        }
        { //::osiris::IdeAccount::getLanguage
        
            typedef boost::python::object ( *getLanguage_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getLanguage"
                , getLanguage_function_type( &getLanguage_db20b926f30ae6409e825cfbcdc725b4 ) );
        
        }
        { //::osiris::IdeAccount::hasLanguage
        
            typedef boost::python::object ( *hasLanguage_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "hasLanguage"
                , hasLanguage_function_type( &hasLanguage_b11ece8646a0b5a67af7b1f4f1941fa5 ) );
        
        }
        { //::osiris::IdeAccount::getDeleted
        
            typedef boost::python::object ( *getDeleted_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getDeleted"
                , getDeleted_function_type( &getDeleted_275f23072682b1fca083a53c78a6768b ) );
        
        }
        { //::osiris::IdeAccount::getViewMode
        
            typedef boost::python::object ( *getViewMode_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getViewMode"
                , getViewMode_function_type( &getViewMode_98d29313367d7f861bae8611f2fbd1f0 ) );
        
        }
        { //::osiris::IdeAccount::getRealPassword
        
            typedef boost::python::object ( *getRealPassword_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getRealPassword"
                , getRealPassword_function_type( &getRealPassword_d53598a3acadaa31368300343fb195e9 ) );
        
        }
        { //::osiris::IdeAccount::getLastAccessDate
        
            typedef boost::python::object ( *getLastAccessDate_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getLastAccessDate"
                , getLastAccessDate_function_type( &getLastAccessDate_e990670d71b3b5daa641b42a04079b21 ) );
        
        }
        { //::osiris::IdeAccount::getReferenceDate
        
            typedef boost::python::object ( *getReferenceDate_function_type )( ::osiris::IdeAccount const & );
            
            IdeAccount_exposer.def( 
                "getReferenceDate"
                , getReferenceDate_function_type( &getReferenceDate_59cd64530a087aecc437bfd24f12085a ) );
        
        }
        { //::osiris::IdeAccount::setDeleted
        
            typedef void ( *setDeleted_function_type )( ::osiris::IdeAccount &,bool );
            
            IdeAccount_exposer.def( 
                "setDeleted"
                , setDeleted_function_type( &setDeleted_b4ae39b903f379b56443ccba25462e35 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("deleted") ) );
        
        }
        { //::osiris::IdeAccount::setLanguage
        
            typedef void ( *setLanguage_function_type )( ::osiris::IdeAccount &,::osiris::String const & );
            
            IdeAccount_exposer.def( 
                "setLanguage"
                , setLanguage_function_type( &setLanguage_61a9177a427acbf11546e9892d7c93ed )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("language") ) );
        
        }
        { //::osiris::IdeAccount::setLastAccessDate
        
            typedef void ( *setLastAccessDate_function_type )( ::osiris::IdeAccount &,::osiris::DateTime const & );
            
            IdeAccount_exposer.def( 
                "setLastAccessDate"
                , setLastAccessDate_function_type( &setLastAccessDate_53e47fb793a8eca66b10bb15f6fc329e )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("date") ) );
        
        }
        { //::osiris::IdeAccount::setName
        
            typedef void ( *setName_function_type )( ::osiris::IdeAccount &,::osiris::String const & );
            
            IdeAccount_exposer.def( 
                "setName"
                , setName_function_type( &setName_7e0f0196bb506cd98d780b9957335c89 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IdeAccount::setRealPassword
        
            typedef boost::python::object ( *setRealPassword_function_type )( ::osiris::IdeAccount &,::osiris::String const & );
            
            IdeAccount_exposer.def( 
                "setRealPassword"
                , setRealPassword_function_type( &setRealPassword_4b0a43e67c44fcfaf6525a5c62198247 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("password") ) );
        
        }
        { //::osiris::IdeAccount::setReferenceDate
        
            typedef void ( *setReferenceDate_function_type )( ::osiris::IdeAccount &,::osiris::DateTime const & );
            
            IdeAccount_exposer.def( 
                "setReferenceDate"
                , setReferenceDate_function_type( &setReferenceDate_db89e02c3ee13a79f2b257d46505d5e4 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("date") ) );
        
        }
        { //::osiris::IdeAccount::setSkin
        
            typedef void ( *setSkin_function_type )( ::osiris::IdeAccount &,::osiris::UniqueID const & );
            
            IdeAccount_exposer.def( 
                "setSkin"
                , setSkin_function_type( &setSkin_3eedd8cad4d9c2aa06f811d0c145a2df )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("id") ) );
        
        }
        { //::osiris::IdeAccount::setViewMode
        
            typedef void ( *setViewMode_function_type )( ::osiris::IdeAccount &,::osiris::DataViewMode );
            
            IdeAccount_exposer.def( 
                "setViewMode"
                , setViewMode_function_type( &setViewMode_b6f13a21a963298e5a758881d863a5ad )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("mode") ) );
        
        }
        { //property "name"[fget=::osiris::IdeAccount::getName, fset=::osiris::IdeAccount::setName]
        
            typedef ::osiris::String const & ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( ::osiris::String const & ) ;
            
            IdeAccount_exposer.add_property( 
                "name"
                , ::boost::python::make_function( 
                      fget( &::osiris::IdeAccount::getName )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::IdeAccount::setName )
                , "get\\set property, built on top of \"osiris::String const & osiris::IdeAccount::getName() const [member function]\" and \"void osiris::IdeAccount::setName(osiris::String const & name) [member function]\"" );
        
        }
        { //property "language"[fget=::osiris::IdeAccount::getLanguage, fset=::osiris::IdeAccount::setLanguage]
        
            typedef ::osiris::String ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( ::osiris::String const & ) ;
            
            IdeAccount_exposer.add_property( 
                "language"
                , fget( &::osiris::IdeAccount::getLanguage )
                , fset( &::osiris::IdeAccount::setLanguage )
                , "get\\set property, built on top of \"osiris::String osiris::IdeAccount::getLanguage() const [member function]\" and \"void osiris::IdeAccount::setLanguage(osiris::String const & language) [member function]\"" );
        
        }
        { //property "deleted"[fget=::osiris::IdeAccount::getDeleted, fset=::osiris::IdeAccount::setDeleted]
        
            typedef bool ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( bool ) ;
            
            IdeAccount_exposer.add_property( 
                "deleted"
                , fget( &::osiris::IdeAccount::getDeleted )
                , fset( &::osiris::IdeAccount::setDeleted )
                , "get\\set property, built on top of \"bool osiris::IdeAccount::getDeleted() const [member function]\" and \"void osiris::IdeAccount::setDeleted(bool deleted) [member function]\"" );
        
        }
        { //property "viewMode"[fget=::osiris::IdeAccount::getViewMode, fset=::osiris::IdeAccount::setViewMode]
        
            typedef ::osiris::DataViewMode ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( ::osiris::DataViewMode ) ;
            
            IdeAccount_exposer.add_property( 
                "viewMode"
                , fget( &::osiris::IdeAccount::getViewMode )
                , fset( &::osiris::IdeAccount::setViewMode )
                , "get\\set property, built on top of \"osiris::DataViewMode osiris::IdeAccount::getViewMode() const [member function]\" and \"void osiris::IdeAccount::setViewMode(osiris::DataViewMode mode) [member function]\"" );
        
        }
        { //property "lastAccessDate"[fget=::osiris::IdeAccount::getLastAccessDate, fset=::osiris::IdeAccount::setLastAccessDate]
        
            typedef ::osiris::DateTime const & ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( ::osiris::DateTime const & ) ;
            
            IdeAccount_exposer.add_property( 
                "lastAccessDate"
                , ::boost::python::make_function( 
                      fget( &::osiris::IdeAccount::getLastAccessDate )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::IdeAccount::setLastAccessDate )
                , "get\\set property, built on top of \"osiris::DateTime const & osiris::IdeAccount::getLastAccessDate() const [member function]\" and \"void osiris::IdeAccount::setLastAccessDate(osiris::DateTime const & date) [member function]\"" );
        
        }
        { //property "referenceDate"[fget=::osiris::IdeAccount::getReferenceDate, fset=::osiris::IdeAccount::setReferenceDate]
        
            typedef ::osiris::DateTime const & ( ::osiris::IdeAccount::*fget )(  ) const;
            typedef void ( ::osiris::IdeAccount::*fset )( ::osiris::DateTime const & ) ;
            
            IdeAccount_exposer.add_property( 
                "referenceDate"
                , ::boost::python::make_function( 
                      fget( &::osiris::IdeAccount::getReferenceDate )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::IdeAccount::setReferenceDate )
                , "get\\set property, built on top of \"osiris::DateTime const & osiris::IdeAccount::getReferenceDate() const [member function]\" and \"void osiris::IdeAccount::setReferenceDate(osiris::DateTime const & date) [member function]\"" );
        
        }
        { //property "account"[fget=::osiris::IdeAccount::getAccount]
        
            typedef ::boost::shared_ptr<osiris::DataAccount> ( ::osiris::IdeAccount::*fget )(  ) const;
            
            IdeAccount_exposer.add_property( 
                "account"
                , fget( &::osiris::IdeAccount::getAccount )
                , "get property, built on top of \"boost::shared_ptr<osiris::DataAccount> osiris::IdeAccount::getAccount() const [member function]\"" );
        
        }
        { //property "id"[fget=::osiris::IdeAccount::getID]
        
            typedef ::osiris::String const & ( ::osiris::IdeAccount::*fget )(  ) const;
            
            IdeAccount_exposer.add_property( 
                "id"
                , ::boost::python::make_function( 
                      fget( &::osiris::IdeAccount::getID )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::String const & osiris::IdeAccount::getID() const [member function]\"" );
        
        }
        { //property "skinID"[fget=::osiris::IdeAccount::getSkinID]
        
            typedef ::osiris::UniqueID ( ::osiris::IdeAccount::*fget )(  ) const;
            
            IdeAccount_exposer.add_property( 
                "skinID"
                , fget( &::osiris::IdeAccount::getSkinID )
                , "get property, built on top of \"osiris::UniqueID osiris::IdeAccount::getSkinID() const [member function]\"" );
        
        }
        { //property "realPassword"[fget=::osiris::IdeAccount::getRealPassword]
        
            typedef ::osiris::String const & ( ::osiris::IdeAccount::*fget )(  ) const;
            
            IdeAccount_exposer.add_property( 
                "realPassword"
                , ::boost::python::make_function( 
                      fget( &::osiris::IdeAccount::getRealPassword )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::String const & osiris::IdeAccount::getRealPassword() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IdeAccount > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IdeAccount >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Exemplo n.º 6
0
void register_IHttpDirectory_class(){

    { //::osiris::IHttpDirectory
        typedef ::boost::python::class_< IHttpDirectory_wrapper, ::boost::noncopyable > IHttpDirectory_exposer_t;
        IHttpDirectory_exposer_t IHttpDirectory_exposer = IHttpDirectory_exposer_t( "IHttpDirectory", ::boost::python::init< ::osiris::String const & >(( ::boost::python::arg("name") )) );
        ::boost::python::scope IHttpDirectory_scope( IHttpDirectory_exposer );
        ::boost::python::enum_< ::osiris::IHttpDirectory::Restrictions>("Restrictions")
            .value("drNone", ::osiris::IHttpDirectory::drNone)
            .value("drLocal", ::osiris::IHttpDirectory::drLocal)
            .export_values()
            ;
        { //::osiris::IHttpDirectory::isActive
        
            typedef boost::python::object ( *isActive_function_type )( ::osiris::IHttpDirectory const & );
            
            IHttpDirectory_exposer.def( 
                "isActive"
                , isActive_function_type( &IHttpDirectory_wrapper::isActive ) );
        
        }
        { //::osiris::IHttpDirectory::getRestriction
        
            typedef boost::python::object ( *getRestriction_function_type )( ::osiris::IHttpDirectory const & );
            
            IHttpDirectory_exposer.def( 
                "getRestriction"
                , getRestriction_function_type( &IHttpDirectory_wrapper::getRestriction ) );
        
        }
        { //::osiris::IHttpDirectory::getName
        
            typedef boost::python::object ( *getName_function_type )( ::osiris::IHttpDirectory const & );
            
            IHttpDirectory_exposer.def( 
                "getName"
                , getName_function_type( &IHttpDirectory_wrapper::getName ) );
        
        }
        { //::osiris::IHttpDirectory::getParent
        
            typedef boost::python::object ( *getParent_function_type )( ::osiris::IHttpDirectory const & );
            
            IHttpDirectory_exposer.def( 
                "getParent"
                , getParent_function_type( &IHttpDirectory_wrapper::getParent ) );
        
        }
        { //::osiris::IHttpDirectory::getPath
        
            typedef boost::python::object ( *getPath_function_type )( ::osiris::IHttpDirectory const & );
            
            IHttpDirectory_exposer.def( 
                "getPath"
                , getPath_function_type( &IHttpDirectory_wrapper::getPath ) );
        
        }
        { //::osiris::IHttpDirectory::createSessionState
        
            typedef ::boost::shared_ptr< osiris::HttpSessionState > ( ::osiris::IHttpDirectory::*createSessionState_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::TimeDuration const & ) const;
            typedef ::boost::shared_ptr< osiris::HttpSessionState > ( IHttpDirectory_wrapper::*default_createSessionState_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::TimeDuration const & ) const;
            
            IHttpDirectory_exposer.def( 
                "createSessionState"
                , createSessionState_function_type(&::osiris::IHttpDirectory::createSessionState)
                , default_createSessionState_function_type(&IHttpDirectory_wrapper::default_createSessionState)
                , ( ::boost::python::arg("session"), ::boost::python::arg("duration") ) );
        
        }
        { //::osiris::IHttpDirectory::process
        
            typedef bool ( ::osiris::IHttpDirectory::*process_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            typedef bool ( IHttpDirectory_wrapper::*default_process_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            
            IHttpDirectory_exposer.def( 
                "process"
                , process_function_type(&::osiris::IHttpDirectory::process)
                , default_process_function_type(&IHttpDirectory_wrapper::default_process)
                , ( ::boost::python::arg("session"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IHttpDirectory::handle
        
            typedef bool ( IHttpDirectory_wrapper::*handle_function_type )( ::boost::shared_ptr< osiris::HttpSession >,::osiris::HttpPath const & ) ;
            
            IHttpDirectory_exposer.def( 
                "handle"
                , handle_function_type( &IHttpDirectory_wrapper::handle )
                , ( ::boost::python::arg("session"), ::boost::python::arg("path") ) );
        
        }
        { //::osiris::IHttpDirectory::addDirectory
        
            typedef boost::python::object ( *addDirectory_function_type )( ::osiris::IHttpDirectory &,::boost::shared_ptr<osiris::IHttpDirectory> );
            
            IHttpDirectory_exposer.def( 
                "addDirectory"
                , addDirectory_function_type( &IHttpDirectory_wrapper::addDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory") ) );
        
        }
        { //::osiris::IHttpDirectory::getDirectory
        
            typedef boost::python::object ( *getDirectory_function_type )( ::osiris::IHttpDirectory const &,::osiris::String const & );
            
            IHttpDirectory_exposer.def( 
                "getDirectory"
                , getDirectory_function_type( &IHttpDirectory_wrapper::getDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IHttpDirectory::getSessionCookie
        
            typedef ::osiris::String ( ::osiris::IHttpDirectory::*getSessionCookie_function_type )( ::boost::shared_ptr< osiris::HttpSession > ) const;
            typedef ::osiris::String ( IHttpDirectory_wrapper::*default_getSessionCookie_function_type )( ::boost::shared_ptr< osiris::HttpSession > ) const;
            
            IHttpDirectory_exposer.def( 
                "getSessionCookie"
                , getSessionCookie_function_type(&::osiris::IHttpDirectory::getSessionCookie)
                , default_getSessionCookie_function_type(&IHttpDirectory_wrapper::default_getSessionCookie)
                , ( ::boost::python::arg("session") ) );
        
        }
        { //::osiris::IHttpDirectory::hasDirectory
        
            typedef boost::python::object ( *hasDirectory_function_type )( ::osiris::IHttpDirectory const &,::osiris::String const & );
            
            IHttpDirectory_exposer.def( 
                "hasDirectory"
                , hasDirectory_function_type( &IHttpDirectory_wrapper::hasDirectory )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IHttpDirectory::isAccessible
        
            typedef bool ( ::osiris::IHttpDirectory::*isAccessible_function_type )( ::boost::shared_ptr< osiris::HttpSession > ) ;
            typedef bool ( IHttpDirectory_wrapper::*default_isAccessible_function_type )( ::boost::shared_ptr< osiris::HttpSession > ) ;
            
            IHttpDirectory_exposer.def( 
                "isAccessible"
                , isAccessible_function_type(&::osiris::IHttpDirectory::isAccessible)
                , default_isAccessible_function_type(&IHttpDirectory_wrapper::default_isAccessible)
                , ( ::boost::python::arg("session") ) );
        
        }
        { //::osiris::IHttpDirectory::removeDirectory
        
            typedef boost::python::object ( *removeDirectory_function_type )( ::osiris::IHttpDirectory &,::boost::shared_ptr<osiris::IHttpDirectory> );
            
            IHttpDirectory_exposer.def( 
                "removeDirectory"
                , removeDirectory_function_type( &IHttpDirectory_wrapper::removeDirectory_ec6e674ac47645d3f33925238eb4fa81 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("directory") ) );
        
        }
        { //::osiris::IHttpDirectory::removeDirectory
        
            typedef boost::python::object ( *removeDirectory_function_type )( ::osiris::IHttpDirectory &,::osiris::String const & );
            
            IHttpDirectory_exposer.def( 
                "removeDirectory"
                , removeDirectory_function_type( &IHttpDirectory_wrapper::removeDirectory_964e6fdc00c45b9783c4e5c9f62d01b8 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::IHttpDirectory::setActive
        
            typedef void ( *setActive_function_type )( ::osiris::IHttpDirectory &,bool );
            
            IHttpDirectory_exposer.def( 
                "setActive"
                , setActive_function_type( &IHttpDirectory_wrapper::setActive )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("active") ) );
        
        }
        { //::osiris::IHttpDirectory::setRestriction
        
            typedef void ( *setRestriction_function_type )( ::osiris::IHttpDirectory &,::osiris::IHttpDirectory::Restrictions );
            
            IHttpDirectory_exposer.def( 
                "setRestriction"
                , setRestriction_function_type( &IHttpDirectory_wrapper::setRestriction )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("restriction") ) );
        
        }
        { //property "restriction"[fget=::osiris::IHttpDirectory::getRestriction, fset=::osiris::IHttpDirectory::setRestriction]
        
            typedef ::osiris::IHttpDirectory::Restrictions ( ::osiris::IHttpDirectory::*fget )(  ) const;
            typedef void ( ::osiris::IHttpDirectory::*fset )( ::osiris::IHttpDirectory::Restrictions ) ;
            
            IHttpDirectory_exposer.add_property( 
                "restriction"
                , fget( &::osiris::IHttpDirectory::getRestriction )
                , fset( &::osiris::IHttpDirectory::setRestriction )
                , "get\\set property, built on top of \"osiris::IHttpDirectory::Restrictions osiris::IHttpDirectory::getRestriction() const [member function]\" and \"void osiris::IHttpDirectory::setRestriction(osiris::IHttpDirectory::Restrictions restriction) [member function]\"" );
        
        }
        { //property "name"[fget=::osiris::IHttpDirectory::getName]
        
            typedef ::osiris::String const & ( ::osiris::IHttpDirectory::*fget )(  ) const;
            
            IHttpDirectory_exposer.add_property( 
                "name"
                , ::boost::python::make_function( 
                      fget( &::osiris::IHttpDirectory::getName )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::String const & osiris::IHttpDirectory::getName() const [member function]\"" );
        
        }
        { //property "parent"[fget=::osiris::IHttpDirectory::getParent]
        
            typedef ::boost::shared_ptr<osiris::IHttpDirectory> ( ::osiris::IHttpDirectory::*fget )(  ) const;
            
            IHttpDirectory_exposer.add_property( 
                "parent"
                , fget( &::osiris::IHttpDirectory::getParent )
                , "get property, built on top of \"boost::shared_ptr<osiris::IHttpDirectory> osiris::IHttpDirectory::getParent() const [member function]\"" );
        
        }
        { //property "path"[fget=::osiris::IHttpDirectory::getPath]
        
            typedef ::osiris::HttpPath ( ::osiris::IHttpDirectory::*fget )(  ) const;
            
            IHttpDirectory_exposer.add_property( 
                "path"
                , fget( &::osiris::IHttpDirectory::getPath )
                , "get property, built on top of \"osiris::HttpPath osiris::IHttpDirectory::getPath() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IHttpDirectory > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpDirectory >, boost::shared_ptr< ::boost::noncopyable_::noncopyable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpDirectory >, boost::shared_ptr< ::osiris::Object > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IHttpDirectory >, boost::shared_ptr< ::osiris::enable_this_ptr< osiris::IHttpDirectory > > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpDirectoryCallback >, boost::shared_ptr< ::osiris::IHttpDirectory > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpVirtualDirectory >, boost::shared_ptr< ::osiris::IHttpDirectory > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpRootDirectory >, boost::shared_ptr< ::osiris::IHttpDirectory > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpPhysicalDirectory >, boost::shared_ptr< ::osiris::IHttpDirectory > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpEnumeratedDirectoryCallback >, boost::shared_ptr< ::osiris::IHttpDirectory > >();
    }

}
Exemplo n.º 7
0
void register_PathHybridization_class(){

    { //::ompl::geometric::PathHybridization
        typedef bp::class_< ompl::geometric::PathHybridization > PathHybridization_exposer_t;
        PathHybridization_exposer_t PathHybridization_exposer = PathHybridization_exposer_t( "PathHybridization", bp::init< ompl::base::SpaceInformationPtr const & >(( bp::arg("si") )) );
        bp::scope PathHybridization_scope( PathHybridization_exposer );
        bp::implicitly_convertible< ompl::base::SpaceInformationPtr const &, ompl::geometric::PathHybridization >();
        { //::ompl::geometric::PathHybridization::clear
        
            typedef void ( ::ompl::geometric::PathHybridization::*clear_function_type)(  ) ;
            
            PathHybridization_exposer.def( 
                "clear"
                , clear_function_type( &::ompl::geometric::PathHybridization::clear ) );
        
        }
        { //::ompl::geometric::PathHybridization::computeHybridPath
        
            typedef void ( ::ompl::geometric::PathHybridization::*computeHybridPath_function_type)(  ) ;
            
            PathHybridization_exposer.def( 
                "computeHybridPath"
                , computeHybridPath_function_type( &::ompl::geometric::PathHybridization::computeHybridPath ) );
        
        }
        { //::ompl::geometric::PathHybridization::getHybridPath
        
            typedef ::ompl::base::PathPtr const & ( ::ompl::geometric::PathHybridization::*getHybridPath_function_type)(  ) const;
            
            PathHybridization_exposer.def( 
                "getHybridPath"
                , getHybridPath_function_type( &::ompl::geometric::PathHybridization::getHybridPath )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::ompl::geometric::PathHybridization::getName
        
            typedef ::std::string const & ( ::ompl::geometric::PathHybridization::*getName_function_type)(  ) const;
            
            PathHybridization_exposer.def( 
                "getName"
                , getName_function_type( &::ompl::geometric::PathHybridization::getName )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::ompl::geometric::PathHybridization::matchPaths
        
            typedef void ( ::ompl::geometric::PathHybridization::*matchPaths_function_type)( ::ompl::geometric::PathGeometric const &,::ompl::geometric::PathGeometric const &,double,::std::vector< int > &,::std::vector< int > & ) const;
            
            PathHybridization_exposer.def( 
                "matchPaths"
                , matchPaths_function_type( &::ompl::geometric::PathHybridization::matchPaths )
                , ( bp::arg("p"), bp::arg("q"), bp::arg("gapCost"), bp::arg("indexP"), bp::arg("indexQ") ) );
        
        }
        { //::ompl::geometric::PathHybridization::pathCount
        
            typedef ::std::size_t ( ::ompl::geometric::PathHybridization::*pathCount_function_type)(  ) const;
            
            PathHybridization_exposer.def( 
                "pathCount"
                , pathCount_function_type( &::ompl::geometric::PathHybridization::pathCount ) );
        
        }
        { //::ompl::geometric::PathHybridization::recordPath
        
            typedef unsigned int ( ::ompl::geometric::PathHybridization::*recordPath_function_type)( ::ompl::base::PathPtr const &,bool ) ;
            
            PathHybridization_exposer.def( 
                "recordPath"
                , recordPath_function_type( &::ompl::geometric::PathHybridization::recordPath )
                , ( bp::arg("pp"), bp::arg("matchAcrossGaps") ) );
        
        }
        PathHybridization_exposer.def("__str__", &__str__);
    }

}
void register_ShapeAttribute_class(){

    { //::osgSim::ShapeAttribute
        typedef bp::class_< osgSim::ShapeAttribute > ShapeAttribute_exposer_t;
        ShapeAttribute_exposer_t ShapeAttribute_exposer = ShapeAttribute_exposer_t( "ShapeAttribute", bp::init< >() );
        bp::scope ShapeAttribute_scope( ShapeAttribute_exposer );
        bp::enum_< osgSim::ShapeAttribute::Type>("Type")
            .value("UNKNOWN", osgSim::ShapeAttribute::UNKNOWN)
            .value("INTEGER", osgSim::ShapeAttribute::INTEGER)
            .value("DOUBLE", osgSim::ShapeAttribute::DOUBLE)
            .value("STRING", osgSim::ShapeAttribute::STRING)
            .export_values()
            ;
        ShapeAttribute_exposer.def( bp::init< char const * >(( bp::arg("name") )) );
        bp::implicitly_convertible< char const *, osgSim::ShapeAttribute >();
        ShapeAttribute_exposer.def( bp::init< char const *, int >(( bp::arg("name"), bp::arg("value") )) );
        ShapeAttribute_exposer.def( bp::init< char const *, double >(( bp::arg("name"), bp::arg("value") )) );
        ShapeAttribute_exposer.def( bp::init< char const *, char const * >(( bp::arg("name"), bp::arg("value") ), "\n Note, ShapeAttribute takes a copy of both name and value, the calling code should manage its own clean up of the original strings.\n") );
        ShapeAttribute_exposer.def( bp::init< osgSim::ShapeAttribute const & >(( bp::arg("sa") )) );
        { //::osgSim::ShapeAttribute::compare
        
            typedef int ( ::osgSim::ShapeAttribute::*compare_function_type)( ::osgSim::ShapeAttribute const & ) const;
            
            ShapeAttribute_exposer.def( 
                "compare"
                , compare_function_type( &::osgSim::ShapeAttribute::compare )
                , ( bp::arg("sa") )
                , "\n return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs.\n" );
        
        }
        { //::osgSim::ShapeAttribute::getDouble
        
            typedef double ( ::osgSim::ShapeAttribute::*getDouble_function_type)(  ) const;
            
            ShapeAttribute_exposer.def( 
                "getDouble"
                , getDouble_function_type( &::osgSim::ShapeAttribute::getDouble )
                , "\n Get the attribute data as a double.\n" );
        
        }
        { //::osgSim::ShapeAttribute::getInt
        
            typedef int ( ::osgSim::ShapeAttribute::*getInt_function_type)(  ) const;
            
            ShapeAttribute_exposer.def( 
                "getInt"
                , getInt_function_type( &::osgSim::ShapeAttribute::getInt )
                , "\n Get the attribute data as an int.\n" );
        
        }
        { //::osgSim::ShapeAttribute::getName
        
            typedef ::std::string const & ( ::osgSim::ShapeAttribute::*getName_function_type)(  ) const;
            
            ShapeAttribute_exposer.def( 
                "getName"
                , getName_function_type( &::osgSim::ShapeAttribute::getName )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "\n Get the attribute name.\n" );
        
        }
        { //::osgSim::ShapeAttribute::getString
        
            typedef char const * ( ::osgSim::ShapeAttribute::*getString_function_type)(  ) const;
            
            ShapeAttribute_exposer.def( 
                "getString"
                , getString_function_type( &::osgSim::ShapeAttribute::getString )
                , "\n Get the attribute data as a string.\n" );
        
        }
        { //::osgSim::ShapeAttribute::getType
        
            typedef ::osgSim::ShapeAttribute::Type ( ::osgSim::ShapeAttribute::*getType_function_type)(  ) const;
            
            ShapeAttribute_exposer.def( 
                "getType"
                , getType_function_type( &::osgSim::ShapeAttribute::getType )
                , "\n Get the attribute data type.\n" );
        
        }
        ShapeAttribute_exposer.def( bp::self != bp::self );
        ShapeAttribute_exposer.def( bp::self < bp::self );
        { //::osgSim::ShapeAttribute::operator=
        
            typedef ::osgSim::ShapeAttribute & ( ::osgSim::ShapeAttribute::*assign_function_type)( ::osgSim::ShapeAttribute const & ) ;
            
            ShapeAttribute_exposer.def( 
                "assign"
                , assign_function_type( &::osgSim::ShapeAttribute::operator= )
                , ( bp::arg("sa") )
                , bp::return_self< >() );
        
        }
        ShapeAttribute_exposer.def( bp::self == bp::self );
        { //::osgSim::ShapeAttribute::setName
        
            typedef void ( ::osgSim::ShapeAttribute::*setName_function_type)( ::std::string const & ) ;
            
            ShapeAttribute_exposer.def( 
                "setName"
                , setName_function_type( &::osgSim::ShapeAttribute::setName )
                , ( bp::arg("name") )
                , "\n Set the attribute name.\n" );
        
        }
        { //::osgSim::ShapeAttribute::setValue
        
            typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( int ) ;
            
            ShapeAttribute_exposer.def( 
                "setValue"
                , setValue_function_type( &::osgSim::ShapeAttribute::setValue )
                , ( bp::arg("value") )
                , "\n Set an integer attribute data.\n" );
        
        }
        { //::osgSim::ShapeAttribute::setValue
        
            typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( double ) ;
            
            ShapeAttribute_exposer.def( 
                "setValue"
                , setValue_function_type( &::osgSim::ShapeAttribute::setValue )
                , ( bp::arg("value") )
                , "\n Set a double attribute data.\n" );
        
        }
        { //::osgSim::ShapeAttribute::setValue
        
            typedef void ( ::osgSim::ShapeAttribute::*setValue_function_type)( char const * ) ;
            
            ShapeAttribute_exposer.def( 
                "setValue"
                , setValue_function_type( &::osgSim::ShapeAttribute::setValue )
                , ( bp::arg("value") )
                , "\n Set a string attribute data.\n" );
        
        }
    }

}
Exemplo n.º 9
0
void register_XMLAttribute_class(){

    { //::osiris::XMLAttribute
        typedef ::boost::python::class_< ::osiris::XMLAttribute, ::boost::noncopyable > XMLAttribute_exposer_t;
        XMLAttribute_exposer_t XMLAttribute_exposer = XMLAttribute_exposer_t( "XMLAttribute", ::boost::python::init< ::osiris::XMLNode &, ::osiris::String const &, ::osiris::String const & >(( ::boost::python::arg("node"), ::boost::python::arg("name"), ::boost::python::arg("value") )) );
        ::boost::python::scope XMLAttribute_scope( XMLAttribute_exposer );
        { //::osiris::XMLAttribute::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttribute & );
            
            XMLAttribute_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_8ad4208f5cf271289dbc24b579febfe2 ) );
        
        }
        { //::osiris::XMLAttribute::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttribute const & );
            
            XMLAttribute_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_8f4db62d18a7a733b4fcfa494e187972 ) );
        
        }
        { //::osiris::XMLAttribute::getName
        
            typedef boost::python::object ( *getName_function_type )( ::osiris::XMLAttribute const & );
            
            XMLAttribute_exposer.def( 
                "getName"
                , getName_function_type( &getName_acfc0eea1e952eb43ca254ea514881e3 ) );
        
        }
        { //::osiris::XMLAttribute::getValue
        
            typedef boost::python::object ( *getValue_function_type )( ::osiris::XMLAttribute const & );
            
            XMLAttribute_exposer.def( 
                "getValue"
                , getValue_function_type( &getValue_8d07e6f4788c147b71884a3b95968270 ) );
        
        }
        { //::osiris::XMLAttribute::setName
        
            typedef void ( *setName_function_type )( ::osiris::XMLAttribute &,::osiris::String const & );
            
            XMLAttribute_exposer.def( 
                "setName"
                , setName_function_type( &setName_d67b3a373b0013675b94eedc00db89d1 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLAttribute::setValue
        
            typedef void ( *setValue_function_type )( ::osiris::XMLAttribute &,::osiris::String const & );
            
            XMLAttribute_exposer.def( 
                "setValue"
                , setValue_function_type( &setValue_5b5d4093a4a0ebca7bb2bf34bca1e191 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("value") ) );
        
        }
        { //property "name"[fget=::osiris::XMLAttribute::getName, fset=::osiris::XMLAttribute::setName]
        
            typedef ::osiris::String const & ( ::osiris::XMLAttribute::*fget )(  ) const;
            typedef void ( ::osiris::XMLAttribute::*fset )( ::osiris::String const & ) ;
            
            XMLAttribute_exposer.add_property( 
                "name"
                , ::boost::python::make_function( 
                      fget( &::osiris::XMLAttribute::getName )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::XMLAttribute::setName )
                , "get\\set property, built on top of \"osiris::String const & osiris::XMLAttribute::getName() const [member function]\" and \"void osiris::XMLAttribute::setName(osiris::String const & name) [member function]\"" );
        
        }
        { //property "value"[fget=::osiris::XMLAttribute::getValue, fset=::osiris::XMLAttribute::setValue]
        
            typedef ::osiris::String const & ( ::osiris::XMLAttribute::*fget )(  ) const;
            typedef void ( ::osiris::XMLAttribute::*fset )( ::osiris::String const & ) ;
            
            XMLAttribute_exposer.add_property( 
                "value"
                , ::boost::python::make_function( 
                      fget( &::osiris::XMLAttribute::getValue )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::XMLAttribute::setValue )
                , "get\\set property, built on top of \"osiris::String const & osiris::XMLAttribute::getValue() const [member function]\" and \"void osiris::XMLAttribute::setValue(osiris::String const & value) [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::XMLAttribute > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::XMLAttribute >, boost::shared_ptr< ::osiris::Object > >();
    }

}