Esempio n. 1
0
void register_File_class(){

    { //::osiris::File
        typedef ::boost::python::class_< File_wrapper, ::boost::python::bases< ::osiris::IStream >, ::boost::noncopyable > File_exposer_t;
        File_exposer_t File_exposer = File_exposer_t( "File", ::boost::python::init< >() );
        ::boost::python::scope File_scope( File_exposer );
        ::boost::python::enum_< ::osiris::File::OpenFlags>("OpenFlags")
            .value("ofRead", ::osiris::File::ofRead)
            .value("ofWrite", ::osiris::File::ofWrite)
            .value("ofReadWrite", ::osiris::File::ofReadWrite)
            .value("ofNoTruncate", ::osiris::File::ofNoTruncate)
            .value("ofBinary", ::osiris::File::ofBinary)
            .value("ofText", ::osiris::File::ofText)
            .export_values()
            ;
        File_exposer.def( ::boost::python::init< ::osiris::String const &, ::osiris::uint32 >(( ::boost::python::arg("filename"), ::boost::python::arg("flags") )) );
        { //::osiris::File::getHandle
        
            typedef boost::python::object ( *getHandle_function_type )( ::osiris::File const & );
            
            File_exposer.def( 
                "getHandle"
                , getHandle_function_type( &File_wrapper::getHandle ) );
        
        }
        { //::osiris::File::open
        
            typedef bool ( ::osiris::File::*open_function_type )( ::osiris::String const &,::osiris::uint32 ) ;
            typedef bool ( File_wrapper::*default_open_function_type )( ::osiris::String const &,::osiris::uint32 ) ;
            
            File_exposer.def( 
                "open"
                , open_function_type(&::osiris::File::open)
                , default_open_function_type(&File_wrapper::default_open)
                , ( ::boost::python::arg("filename"), ::boost::python::arg("flags") ) );
        
        }
        { //::osiris::File::is_open
        
            typedef bool ( ::osiris::File::*is_open_function_type )(  ) const;
            typedef bool ( File_wrapper::*default_is_open_function_type )(  ) const;
            
            File_exposer.def( 
                "is_open"
                , is_open_function_type(&::osiris::File::is_open)
                , default_is_open_function_type(&File_wrapper::default_is_open) );
        
        }
        { //::osiris::File::close
        
            typedef bool ( ::osiris::File::*close_function_type )(  ) ;
            typedef bool ( File_wrapper::*default_close_function_type )(  ) ;
            
            File_exposer.def( 
                "close"
                , close_function_type(&::osiris::File::close)
                , default_close_function_type(&File_wrapper::default_close) );
        
        }
        { //::osiris::File::read
        
            typedef ::osiris::uint32 ( ::osiris::File::*read_function_type )( void *,::osiris::uint32 ) const;
            typedef ::osiris::uint32 ( File_wrapper::*default_read_function_type )( void *,::osiris::uint32 ) const;
            
            File_exposer.def( 
                "read"
                , read_function_type(&::osiris::File::read)
                , default_read_function_type(&File_wrapper::default_read)
                , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) );
        
        }
        { //::osiris::File::write
        
            typedef ::osiris::uint32 ( ::osiris::File::*write_function_type )( void const *,::osiris::uint32 ) ;
            typedef ::osiris::uint32 ( File_wrapper::*default_write_function_type )( void const *,::osiris::uint32 ) ;
            
            File_exposer.def( 
                "write"
                , write_function_type(&::osiris::File::write)
                , default_write_function_type(&File_wrapper::default_write)
                , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) );
        
        }
        { //::osiris::File::seek
        
            typedef bool ( ::osiris::File::*seek_function_type )( ::osiris::uint64,::osiris::SeekPosition ) const;
            typedef bool ( File_wrapper::*default_seek_function_type )( ::osiris::uint64,::osiris::SeekPosition ) const;
            
            File_exposer.def( 
                "seek"
                , seek_function_type(&::osiris::File::seek)
                , default_seek_function_type(&File_wrapper::default_seek)
                , ( ::boost::python::arg("offset"), ::boost::python::arg("from") ) );
        
        }
        { //::osiris::File::position
        
            typedef ::osiris::uint64 ( ::osiris::File::*position_function_type )(  ) const;
            typedef ::osiris::uint64 ( File_wrapper::*default_position_function_type )(  ) const;
            
            File_exposer.def( 
                "position"
                , position_function_type(&::osiris::File::position)
                , default_position_function_type(&File_wrapper::default_position) );
        
        }
        { //::osiris::File::size
        
            typedef ::osiris::uint64 ( ::osiris::File::*size_function_type )(  ) const;
            typedef ::osiris::uint64 ( File_wrapper::*default_size_function_type )(  ) const;
            
            File_exposer.def( 
                "size"
                , size_function_type(&::osiris::File::size)
                , default_size_function_type(&File_wrapper::default_size) );
        
        }
        { //::osiris::File::flush
        
            typedef bool ( ::osiris::File::*flush_function_type )(  ) ;
            typedef bool ( File_wrapper::*default_flush_function_type )(  ) ;
            
            File_exposer.def( 
                "flush"
                , flush_function_type(&::osiris::File::flush)
                , default_flush_function_type(&File_wrapper::default_flush) );
        
        }
        { //::osiris::File::eof
        
            typedef bool ( ::osiris::File::*eof_function_type )(  ) const;
            typedef bool ( File_wrapper::*default_eof_function_type )(  ) const;
            
            File_exposer.def( 
                "eof"
                , eof_function_type(&::osiris::File::eof)
                , default_eof_function_type(&File_wrapper::default_eof) );
        
        }
        { //::osiris::File::getStats
        
            typedef boost::python::object ( *getStats_function_type )( ::osiris::File const &,::boost::posix_time::ptime *,::boost::posix_time::ptime *,::boost::posix_time::ptime * );
            
            File_exposer.def( 
                "getStats"
                , getStats_function_type( &File_wrapper::getStats )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("timeCreation"), ::boost::python::arg("timeLastModify")=(nullptr), ::boost::python::arg("timeLastAccess")=(nullptr) ) );
        
        }
        { //::osiris::IStream::peek
        
            typedef ::osiris::uint32 ( ::osiris::IStream::*peek_function_type )( void *,::osiris::uint32 ) const;
            typedef ::osiris::uint32 ( File_wrapper::*default_peek_function_type )( void *,::osiris::uint32 ) const;
            
            File_exposer.def( 
                "peek"
                , peek_function_type(&::osiris::IStream::peek)
                , default_peek_function_type(&File_wrapper::default_peek)
                , ( ::boost::python::arg("v"), ::boost::python::arg("size") ) );
        
        }
        { //property "handle"[fget=::osiris::File::getHandle]
        
            typedef ::FILE * ( ::osiris::File::*fget )(  ) const;
            
            File_exposer.add_property( 
                "handle"
                , ::boost::python::make_function( 
                      fget( &::osiris::File::getHandle )
                    , bp::return_value_policy< bp::reference_existing_object >() ) 
                , "get property, built on top of \"FILE * osiris::File::getHandle() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::File > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::File >, boost::shared_ptr< ::boost::noncopyable_::noncopyable > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::File >, boost::shared_ptr< ::osiris::Object > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::TextFile >, boost::shared_ptr< ::osiris::File > >();
    }

}
Esempio 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 > >();
    }

}
Esempio n. 3
0
void register_IDbStatement_class(){

    { //::osiris::IDbStatement
        typedef ::boost::python::class_< IDbStatement_wrapper, ::boost::noncopyable > IDbStatement_exposer_t;
        IDbStatement_exposer_t IDbStatement_exposer = IDbStatement_exposer_t( "IDbStatement", ::boost::python::init< >() );
        ::boost::python::scope IDbStatement_scope( IDbStatement_exposer );
        { //::osiris::IDbStatement::getParameters
        
            typedef boost::python::object ( *getParameters_function_type )( ::osiris::IDbStatement const & );
            
            IDbStatement_exposer.def( 
                "getParameters"
                , getParameters_function_type( &IDbStatement_wrapper::getParameters ) );
        
        }
        { //::osiris::IDbStatement::addParameter
        
            typedef boost::python::object ( *addParameter_function_type )( ::osiris::IDbStatement & );
            
            IDbStatement_exposer.def( 
                "addParameter"
                , addParameter_function_type( &IDbStatement_wrapper::addParameter ) );
        
        }
        { //::osiris::IDbStatement::execute
        
            typedef void ( *execute_function_type )( ::osiris::IDbStatement & );
            
            IDbStatement_exposer.def( 
                "execute"
                , execute_function_type( &IDbStatement_wrapper::execute ) );
        
        }
        { //::osiris::IDbStatement::neededParameters
        
            typedef ::osiris::uint32 ( ::osiris::IDbStatement::*neededParameters_function_type )(  ) ;
            
            IDbStatement_exposer.def( 
                "neededParameters"
                , ( neededParameters_function_type(&::osiris::IDbStatement::neededParameters) ) );
        
        }
        { //::osiris::IDbStatement::close
        
            typedef void ( ::osiris::IDbStatement::*close_function_type )(  ) ;
            
            IDbStatement_exposer.def( 
                "close"
                , ( close_function_type(&::osiris::IDbStatement::close) ) );
        
        }
        { //::osiris::IDbStatement::run
        
            typedef void ( IDbStatement_wrapper::*run_function_type )(  ) ;
            
            IDbStatement_exposer.def( 
                "run"
                , run_function_type( &IDbStatement_wrapper::run ) );
        
        }
        { //::osiris::IDbStatement::createParameter
        
            typedef ::boost::shared_ptr< osiris::IDbParameter > ( IDbStatement_wrapper::*createParameter_function_type )( ::osiris::uint32 ) ;
            
            IDbStatement_exposer.def( 
                "createParameter"
                , createParameter_function_type( &IDbStatement_wrapper::createParameter )
                , ( ::boost::python::arg("index") ) );
        
        }
        { //::osiris::IDbStatement::getParameter
        
            typedef boost::python::object ( *getParameter_function_type )( ::osiris::IDbStatement const &,::osiris::uint32 );
            
            IDbStatement_exposer.def( 
                "getParameter"
                , getParameter_function_type( &IDbStatement_wrapper::getParameter )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("index") ) );
        
        }
        { //property "parameters"[fget=::osiris::IDbStatement::getParameters]
        
            typedef ::std::deque<boost::shared_ptr<osiris::IDbParameter>, osiris::StdAllocator<boost::shared_ptr<osiris::IDbParameter>, osiris::SysAllocator<boost::shared_ptr<osiris::IDbParameter> > > > const & ( ::osiris::IDbStatement::*fget )(  ) const;
            
            IDbStatement_exposer.add_property( 
                "parameters"
                , ::boost::python::make_function( 
                      fget( &::osiris::IDbStatement::getParameters )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"std::deque<boost::shared_ptr<osiris::IDbParameter>, osiris::StdAllocator<boost::shared_ptr<osiris::IDbParameter>, osiris::SysAllocator<boost::shared_ptr<osiris::IDbParameter> > > > const & osiris::IDbStatement::getParameters() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IDbStatement > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IDbStatement >, boost::shared_ptr< ::osiris::Object > >();
    }

}