Ejemplo n.º 1
0
void register_HttpContent_class(){

    { //::osiris::HttpContent
        typedef ::boost::python::class_< ::osiris::HttpContent > HttpContent_exposer_t;
        HttpContent_exposer_t HttpContent_exposer = HttpContent_exposer_t( "HttpContent", ::boost::python::init< >() );
        ::boost::python::scope HttpContent_scope( HttpContent_exposer );
        { //::osiris::HttpContent::getCompleted
        
            typedef boost::python::object ( *getCompleted_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getCompleted"
                , getCompleted_function_type( &getCompleted_a9f22a409da5d4d1af44a727c0e956de ) );
        
        }
        { //::osiris::HttpContent::getValid
        
            typedef boost::python::object ( *getValid_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getValid"
                , getValid_function_type( &getValid_41ceccaf277c037e1fa4462267571f11 ) );
        
        }
        { //::osiris::HttpContent::getContentEncoding
        
            typedef boost::python::object ( *getContentEncoding_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getContentEncoding"
                , getContentEncoding_function_type( &getContentEncoding_9ebf6f83bf297aa5d2ac41be02e8e03d ) );
        
        }
        { //::osiris::HttpContent::getContentType
        
            typedef boost::python::object ( *getContentType_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getContentType"
                , getContentType_function_type( &getContentType_5db5e1655caf0e18d28a208ca7bc49d3 ) );
        
        }
        { //::osiris::HttpContent::getTransferEncoding
        
            typedef boost::python::object ( *getTransferEncoding_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getTransferEncoding"
                , getTransferEncoding_function_type( &getTransferEncoding_aa883461c047cbbf5a23dd3edc54c50e ) );
        
        }
        { //::osiris::HttpContent::getContentLength
        
            typedef boost::python::object ( *getContentLength_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getContentLength"
                , getContentLength_function_type( &getContentLength_f1afae67b7701ac1262dbdb2f4291c83 ) );
        
        }
        { //::osiris::HttpContent::getBufferPtr
        
            typedef boost::python::object ( *getBufferPtr_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getBufferPtr"
                , getBufferPtr_function_type( &getBufferPtr_3a6855ece4ac75d707168ea160bf4215 ) );
        
        }
        { //::osiris::HttpContent::getContentPtr
        
            typedef boost::python::object ( *getContentPtr_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getContentPtr"
                , getContentPtr_function_type( &getContentPtr_6d2a5dce8619bf4e163d7181a842970b ) );
        
        }
        { //::osiris::HttpContent::getContent
        
            typedef boost::python::object ( *getContent_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "getContent"
                , getContent_function_type( &getContent_e1bf959a7e378a16a0dbbabb2bc430b2 ) );
        
        }
        { //::osiris::HttpContent::empty
        
            typedef boost::python::object ( *empty_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "empty"
                , empty_function_type( &empty_01d71dddd722d64fbcb92f73c80615cf ) );
        
        }
        { //::osiris::HttpContent::process
        
            typedef void ( *process_function_type )( ::osiris::HttpContent &,::osiris::byte const *,::osiris::uint32 );
            
            HttpContent_exposer.def( 
                "process"
                , process_function_type( &process_68c22ae749d5c67a7f8a2de190b84717 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("data"), ::boost::python::arg("size") ) );
        
        }
        { //::osiris::HttpContent::toString
        
            typedef boost::python::object ( *toString_function_type )( ::osiris::HttpContent const & );
            
            HttpContent_exposer.def( 
                "toString"
                , toString_function_type( &toString_0ce4d90cea03c98a196f18fec8292995 ) );
        
        }
        { //::osiris::HttpContent::setContentEncoding
        
            typedef void ( *setContentEncoding_function_type )( ::osiris::HttpContent &,::osiris::HttpContentEncoding );
            
            HttpContent_exposer.def( 
                "setContentEncoding"
                , setContentEncoding_function_type( &setContentEncoding_06b416bbfc2516971660baf8d09fdcd1 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("contentEncoding") ) );
        
        }
        { //::osiris::HttpContent::setContentLength
        
            typedef void ( *setContentLength_function_type )( ::osiris::HttpContent &,::osiris::uint32 );
            
            HttpContent_exposer.def( 
                "setContentLength"
                , setContentLength_function_type( &setContentLength_d655353b91afa8263c9aba9e43cc7c19 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("contentLength") ) );
        
        }
        { //::osiris::HttpContent::setContentType
        
            typedef void ( *setContentType_function_type )( ::osiris::HttpContent &,::std::string const & );
            
            HttpContent_exposer.def( 
                "setContentType"
                , setContentType_function_type( &setContentType_b44460f033364f13778f84fc24d215b2 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("contentType") ) );
        
        }
        { //::osiris::HttpContent::setTransferEncoding
        
            typedef void ( *setTransferEncoding_function_type )( ::osiris::HttpContent &,::osiris::HttpTransferEncoding );
            
            HttpContent_exposer.def( 
                "setTransferEncoding"
                , setTransferEncoding_function_type( &setTransferEncoding_9bd2d2bb62cd39f0579218b6c045986f )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("transferEncoding") ) );
        
        }
        { //property "contentEncoding"[fget=::osiris::HttpContent::getContentEncoding, fset=::osiris::HttpContent::setContentEncoding]
        
            typedef ::osiris::HttpContentEncoding ( ::osiris::HttpContent::*fget )(  ) const;
            typedef void ( ::osiris::HttpContent::*fset )( ::osiris::HttpContentEncoding ) ;
            
            HttpContent_exposer.add_property( 
                "contentEncoding"
                , fget( &::osiris::HttpContent::getContentEncoding )
                , fset( &::osiris::HttpContent::setContentEncoding )
                , "get\\set property, built on top of \"osiris::HttpContentEncoding osiris::HttpContent::getContentEncoding() const [member function]\" and \"void osiris::HttpContent::setContentEncoding(osiris::HttpContentEncoding contentEncoding) [member function]\"" );
        
        }
        { //property "contentType"[fget=::osiris::HttpContent::getContentType, fset=::osiris::HttpContent::setContentType]
        
            typedef ::std::string const & ( ::osiris::HttpContent::*fget )(  ) const;
            typedef void ( ::osiris::HttpContent::*fset )( ::std::string const & ) ;
            
            HttpContent_exposer.add_property( 
                "contentType"
                , ::boost::python::make_function( 
                      fget( &::osiris::HttpContent::getContentType )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , fset( &::osiris::HttpContent::setContentType )
                , "get\\set property, built on top of \"std::string const & osiris::HttpContent::getContentType() const [member function]\" and \"void osiris::HttpContent::setContentType(std::string const & contentType) [member function]\"" );
        
        }
        { //property "transferEncoding"[fget=::osiris::HttpContent::getTransferEncoding, fset=::osiris::HttpContent::setTransferEncoding]
        
            typedef ::osiris::HttpTransferEncoding ( ::osiris::HttpContent::*fget )(  ) const;
            typedef void ( ::osiris::HttpContent::*fset )( ::osiris::HttpTransferEncoding ) ;
            
            HttpContent_exposer.add_property( 
                "transferEncoding"
                , fget( &::osiris::HttpContent::getTransferEncoding )
                , fset( &::osiris::HttpContent::setTransferEncoding )
                , "get\\set property, built on top of \"osiris::HttpTransferEncoding osiris::HttpContent::getTransferEncoding() const [member function]\" and \"void osiris::HttpContent::setTransferEncoding(osiris::HttpTransferEncoding transferEncoding) [member function]\"" );
        
        }
        { //property "contentLength"[fget=::osiris::HttpContent::getContentLength, fset=::osiris::HttpContent::setContentLength]
        
            typedef ::osiris::uint32 ( ::osiris::HttpContent::*fget )(  ) const;
            typedef void ( ::osiris::HttpContent::*fset )( ::osiris::uint32 ) ;
            
            HttpContent_exposer.add_property( 
                "contentLength"
                , fget( &::osiris::HttpContent::getContentLength )
                , fset( &::osiris::HttpContent::setContentLength )
                , "get\\set property, built on top of \"osiris::uint32 osiris::HttpContent::getContentLength() const [member function]\" and \"void osiris::HttpContent::setContentLength(osiris::uint32 contentLength) [member function]\"" );
        
        }
        { //property "completed"[fget=::osiris::HttpContent::getCompleted]
        
            typedef bool ( ::osiris::HttpContent::*fget )(  ) const;
            
            HttpContent_exposer.add_property( 
                "completed"
                , fget( &::osiris::HttpContent::getCompleted )
                , "get property, built on top of \"bool osiris::HttpContent::getCompleted() const [member function]\"" );
        
        }
        { //property "valid"[fget=::osiris::HttpContent::getValid]
        
            typedef bool ( ::osiris::HttpContent::*fget )(  ) const;
            
            HttpContent_exposer.add_property( 
                "valid"
                , fget( &::osiris::HttpContent::getValid )
                , "get property, built on top of \"bool osiris::HttpContent::getValid() const [member function]\"" );
        
        }
        { //property "bufferPtr"[fget=::osiris::HttpContent::getBufferPtr]
        
            typedef ::boost::shared_ptr<osiris::Buffer> ( ::osiris::HttpContent::*fget )(  ) const;
            
            HttpContent_exposer.add_property( 
                "bufferPtr"
                , fget( &::osiris::HttpContent::getBufferPtr )
                , "get property, built on top of \"boost::shared_ptr<osiris::Buffer> osiris::HttpContent::getBufferPtr() const [member function]\"" );
        
        }
        { //property "contentPtr"[fget=::osiris::HttpContent::getContentPtr]
        
            typedef ::boost::shared_ptr<osiris::Buffer> ( ::osiris::HttpContent::*fget )(  ) const;
            
            HttpContent_exposer.add_property( 
                "contentPtr"
                , fget( &::osiris::HttpContent::getContentPtr )
                , "get property, built on top of \"boost::shared_ptr<osiris::Buffer> osiris::HttpContent::getContentPtr() const [member function]\"" );
        
        }
        { //property "content"[fget=::osiris::HttpContent::getContent]
        
            typedef ::osiris::Buffer const & ( ::osiris::HttpContent::*fget )(  ) const;
            
            HttpContent_exposer.add_property( 
                "content"
                , ::boost::python::make_function( 
                      fget( &::osiris::HttpContent::getContent )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::Buffer const & osiris::HttpContent::getContent() const [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::HttpContent > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::HttpContent >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Ejemplo n.º 2
0
void register_IPAddress_class(){

    { //::osiris::IPAddress
        typedef ::boost::python::class_< ::osiris::IPAddress > IPAddress_exposer_t;
        IPAddress_exposer_t IPAddress_exposer = IPAddress_exposer_t( "IPAddress", ::boost::python::init< >() );
        ::boost::python::scope IPAddress_scope( IPAddress_exposer );
        IPAddress_exposer.def( ::boost::python::init< ::osiris::uint8, ::osiris::uint8, ::osiris::uint8, ::osiris::uint8, ::osiris::uint32 >(( ::boost::python::arg("a"), ::boost::python::arg("b"), ::boost::python::arg("c"), ::boost::python::arg("d"), ::boost::python::arg("port") )) );
        IPAddress_exposer.def( ::boost::python::init< ::osiris::uint32, ::osiris::uint32 >(( ::boost::python::arg("ip"), ::boost::python::arg("port") )) );
        IPAddress_exposer.def( ::boost::python::init< ::osiris::IPAddress const & >(( ::boost::python::arg("second") )) );
        { //::osiris::IPAddress::getIP
        
            typedef boost::python::object ( *getIP_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "getIP"
                , getIP_function_type( &getIP_32999fbf07323c9f80e570a813bfa961 ) );
        
        }
        { //::osiris::IPAddress::getPort
        
            typedef boost::python::object ( *getPort_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "getPort"
                , getPort_function_type( &getPort_738d5dca4426fcac34cf27d9bd6e9a63 ) );
        
        }
        { //::osiris::IPAddress::isLocalAddress
        
            typedef boost::python::object ( *isLocalAddress_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "isLocalAddress"
                , isLocalAddress_function_type( &isLocalAddress_5a51fbafa82dc510d399c0257b31abcd ) );
        
        }
        { //::osiris::IPAddress::isPrivateAddress
        
            typedef boost::python::object ( *isPrivateAddress_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "isPrivateAddress"
                , isPrivateAddress_function_type( &isPrivateAddress_6b01a27198c1ea530dc0bfea70e3dbf9 ) );
        
        }
        { //::osiris::IPAddress::isAny
        
            typedef boost::python::object ( *isAny_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "isAny"
                , isAny_function_type( &isAny_edddd4d2bdbc030d3e3e09114121f4f2 ) );
        
        }
        { //::osiris::IPAddress::setEndpoint
        
            typedef boost::python::object ( *setEndpoint_function_type )( ::osiris::IPAddress &,::osiris::String const &,::osiris::uint32 );
            
            IPAddress_exposer.def( 
                "setEndpoint"
                , setEndpoint_function_type( &setEndpoint_149d86b9a54209e270da806866b57cfe )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("ip"), ::boost::python::arg("port") ) );
        
        }
        { //::osiris::IPAddress::toNative
        
            typedef boost::python::object ( *toNative_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "toNative"
                , toNative_function_type( &toNative_fe8bacf449c67715a56d6388b5e77507 ) );
        
        }
        { //::osiris::IPAddress::toString
        
            typedef boost::python::object ( *toString_function_type )( ::osiris::IPAddress const & );
            
            IPAddress_exposer.def( 
                "toString"
                , toString_function_type( &toString_fc3c99ef8ddfbf8b4a2044728058c718 ) );
        
        }
        { //::osiris::IPAddress::clear
        
            typedef void ( *clear_function_type )( ::osiris::IPAddress & );
            
            IPAddress_exposer.def( 
                "clear"
                , clear_function_type( &clear_8c276be2894f2513b34096ff62055825 ) );
        
        }
        { //::osiris::IPAddress::fromString
        
            typedef boost::python::object ( *fromString_function_type )( ::osiris::IPAddress &,::osiris::String const & );
            
            IPAddress_exposer.def( 
                "fromString"
                , fromString_function_type( &fromString_ef6b03c612b005e64e31bcd0ea9e9d48 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("ip") ) );
        
        }
        IPAddress_exposer.def( ::boost::python::self != ::boost::python::self );
        IPAddress_exposer.def( ::boost::python::self < ::boost::python::self );
        IPAddress_exposer.def( ::boost::python::self <= ::boost::python::self );
        { //::osiris::IPAddress::operator=
        
            typedef ::osiris::IPAddress & ( ::osiris::IPAddress::*assign_function_type )( ::osiris::IPAddress const & ) ;
            
            IPAddress_exposer.def( 
                "assign"
                , assign_function_type( &::osiris::IPAddress::operator= )
                , ( ::boost::python::arg("second") )
                , bp::return_self< >() );
        
        }
        IPAddress_exposer.def( ::boost::python::self == ::boost::python::self );
        { //::osiris::IPAddress::setIP
        
            typedef void ( *setIP_function_type )( ::osiris::IPAddress &,::osiris::uint32 );
            
            IPAddress_exposer.def( 
                "setIP"
                , setIP_function_type( &setIP_d0e55deba0e3c4a4e9bf44bd550fe8f8 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("ip") ) );
        
        }
        { //::osiris::IPAddress::setPort
        
            typedef void ( *setPort_function_type )( ::osiris::IPAddress &,::osiris::uint32 );
            
            IPAddress_exposer.def( 
                "setPort"
                , setPort_function_type( &setPort_76a55649e9666c068a6373719b232825 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("port") ) );
        
        }
        IPAddress_exposer.def_readonly( "ANY", ::osiris::IPAddress::ANY );
        IPAddress_exposer.def_readonly( "any_addr", ::osiris::IPAddress::any_addr );
        IPAddress_exposer.def_readonly( "any_port", ::osiris::IPAddress::any_port );
        { //property "ip"[fget=::osiris::IPAddress::getIP, fset=::osiris::IPAddress::setIP]
        
            typedef ::osiris::uint32 ( ::osiris::IPAddress::*fget )(  ) const;
            typedef void ( ::osiris::IPAddress::*fset )( ::osiris::uint32 ) ;
            
            IPAddress_exposer.add_property( 
                "ip"
                , fget( &::osiris::IPAddress::getIP )
                , fset( &::osiris::IPAddress::setIP )
                , "get\\set property, built on top of \"osiris::uint32 osiris::IPAddress::getIP() const [member function]\" and \"void osiris::IPAddress::setIP(osiris::uint32 ip) [member function]\"" );
        
        }
        { //property "port"[fget=::osiris::IPAddress::getPort, fset=::osiris::IPAddress::setPort]
        
            typedef ::osiris::uint32 ( ::osiris::IPAddress::*fget )(  ) const;
            typedef void ( ::osiris::IPAddress::*fset )( ::osiris::uint32 ) ;
            
            IPAddress_exposer.add_property( 
                "port"
                , fget( &::osiris::IPAddress::getPort )
                , fset( &::osiris::IPAddress::setPort )
                , "get\\set property, built on top of \"osiris::uint32 osiris::IPAddress::getPort() const [member function]\" and \"void osiris::IPAddress::setPort(osiris::uint32 port) [member function]\"" );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::IPAddress > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::IPAddress >, boost::shared_ptr< ::osiris::Object > >();
    }

}