Beispiel #1
0
void register_Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__class(){

    { //::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >
        typedef bp::class_< xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn > > Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer_t;
        Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer_t Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer = Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer_t( "Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater_", bp::init< >() );
        bp::scope Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__scope( Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer );
        { //::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::AddKey
        
            typedef xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn > exported_class_t;
            typedef void ( exported_class_t::*add_key_function_type )( float const &,::xfx::Quaternion const & ) ;
            
            Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer.def( 
                "add_key"
                , add_key_function_type( &::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::AddKey )
                , ( bp::arg("t"), bp::arg("key") ) );
        
        }
        { //::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::Clear
        
            typedef xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn > exported_class_t;
            typedef void ( exported_class_t::*clear_function_type )(  ) ;
            
            Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer.def( 
                "clear"
                , clear_function_type( &::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::Clear ) );
        
        }
        { //::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::Key
        
            typedef xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn > exported_class_t;
            typedef ::xfx::Quaternion ( exported_class_t::*key_function_type )( float const & ) const;
            
            Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer.def( 
                "key"
                , key_function_type( &::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::Key )
                , ( bp::arg("t") ) );
        
        }
        { //::xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn >::ParseEnvelope
        
            typedef xfx::Envelope< xfx::Quaternion, float, xfx::QuaternionLerpFn > exported_class_t;
            typedef boost::python::tuple ( *parse_envelope_function_type )( unsigned int,::std::basic_string<char,std::char_traits<char>,std::allocator<char> > const & );
            
            Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer.def( 
                "parse_envelope"
                , parse_envelope_function_type( &ParseEnvelope_b09124bed6e3bece73e36205d0c41807 )
                , ( bp::arg("pos"), bp::arg("str") ) );
        
        }
        Envelope_less__xfx_scope_Quaternion_comma__float_comma__xfx_scope_QuaternionLerpFn__greater__exposer.staticmethod( "parse_envelope" );
        bp::register_ptr_to_python< boost::shared_ptr< xfx::Envelope<xfx::Quaternion, float, xfx::QuaternionLerpFn> const > >( );
        bp::implicitly_convertible< boost::shared_ptr< xfx::Envelope<xfx::Quaternion, float, xfx::QuaternionLerpFn> >, boost::shared_ptr< xfx::Envelope<xfx::Quaternion, float, xfx::QuaternionLerpFn> const > >( );
    }

}
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__);
    }

}
Beispiel #3
0
void register_XMLAttributes_class(){

    { //::osiris::XMLAttributes
        typedef ::boost::python::class_< ::osiris::XMLAttributes > XMLAttributes_exposer_t;
        XMLAttributes_exposer_t XMLAttributes_exposer = XMLAttributes_exposer_t( "XMLAttributes", ::boost::python::init< ::osiris::XMLNode & >(( ::boost::python::arg("node") )) );
        ::boost::python::scope XMLAttributes_scope( XMLAttributes_exposer );
        ::boost::python::implicitly_convertible< ::osiris::XMLNode &, ::osiris::XMLAttributes >();
        { //::osiris::XMLAttributes::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttributes & );
            
            XMLAttributes_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_4e57c0c8f9b0f179513dbc4a9f5d4c90 ) );
        
        }
        { //::osiris::XMLAttributes::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLAttributes const & );
            
            XMLAttributes_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_c7ca0ab9de3bad23f457972b89ccd4bc ) );
        
        }
        { //::osiris::XMLAttributes::empty
        
            typedef boost::python::object ( *empty_function_type )( ::osiris::XMLAttributes const & );
            
            XMLAttributes_exposer.def( 
                "empty"
                , empty_function_type( &empty_b69603b713f1a8a59c2ffc4b6c71ff93 ) );
        
        }
        { //::osiris::XMLAttributes::size
        
            typedef boost::python::object ( *size_function_type )( ::osiris::XMLAttributes const & );
            
            XMLAttributes_exposer.def( 
                "size"
                , size_function_type( &size_97d3881c48560de9a0f1e73dafa6a53e ) );
        
        }
        { //::osiris::XMLAttributes::set
        
            typedef void ( *set_function_type )( ::osiris::XMLAttributes &,::osiris::String const &,::osiris::String const & );
            
            XMLAttributes_exposer.def( 
                "set"
                , set_function_type( &set_1e63dd0dc5475b37dd70f5a51470babd )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name"), ::boost::python::arg("value") ) );
        
        }
        { //::osiris::XMLAttributes::clear
        
            typedef void ( *clear_function_type )( ::osiris::XMLAttributes & );
            
            XMLAttributes_exposer.def( 
                "clear"
                , clear_function_type( &clear_bbd254cd8250d6049df9feeec423473d ) );
        
        }
        { //::osiris::XMLAttributes::exists
        
            typedef boost::python::object ( *exists_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & );
            
            XMLAttributes_exposer.def( 
                "exists"
                , exists_function_type( &exists_9b7ddaa903c86a33882aca33647d86d9 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLAttributes::find
        
            typedef boost::python::object ( *find_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & );
            
            XMLAttributes_exposer.def( 
                "find"
                , find_function_type( &find_981dbb4e0c25761bece5c543ec955f9e )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLAttributes::find
        
            typedef boost::python::object ( *find_function_type )( ::osiris::XMLAttributes const &,::size_t );
            
            XMLAttributes_exposer.def( 
                "find"
                , find_function_type( &find_f566384adab53722dbbf56f49e0e8597 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("index") ) );
        
        }
        { //::osiris::XMLAttributes::get
        
            typedef boost::python::object ( *get_function_type )( ::osiris::XMLAttributes const &,::osiris::String const & );
            
            XMLAttributes_exposer.def( 
                "get"
                , get_function_type( &get_8341dbbadae2779456a992562f1485db )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLAttributes::remove
        
            typedef void ( *remove_function_type )( ::osiris::XMLAttributes &,::osiris::String const & );
            
            XMLAttributes_exposer.def( 
                "remove"
                , remove_function_type( &remove_13651ce1619d4c347a785c48f2131d08 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::XMLAttributes > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::XMLAttributes >, boost::shared_ptr< ::osiris::Object > >();
    }

}
Beispiel #4
0
void register_ID_class(){

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

}
Beispiel #5
0
void register_XMLNodes_class(){

    { //::osiris::XMLNodes
        typedef ::boost::python::class_< ::osiris::XMLNodes > XMLNodes_exposer_t;
        XMLNodes_exposer_t XMLNodes_exposer = XMLNodes_exposer_t( "XMLNodes", ::boost::python::init< ::osiris::XMLNode & >(( ::boost::python::arg("node") )) );
        ::boost::python::scope XMLNodes_scope( XMLNodes_exposer );
        ::boost::python::implicitly_convertible< ::osiris::XMLNode &, ::osiris::XMLNodes >();
        { //::osiris::XMLNodes::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLNodes & );
            
            XMLNodes_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_3c633a1bb16d579f7abf6110df71d721 ) );
        
        }
        { //::osiris::XMLNodes::getNode
        
            typedef boost::python::object ( *getNode_function_type )( ::osiris::XMLNodes const & );
            
            XMLNodes_exposer.def( 
                "getNode"
                , getNode_function_type( &getNode_daf4419d80b8c9cfb243f96979a92cdb ) );
        
        }
        { //::osiris::XMLNodes::empty
        
            typedef boost::python::object ( *empty_function_type )( ::osiris::XMLNodes const & );
            
            XMLNodes_exposer.def( 
                "empty"
                , empty_function_type( &empty_d6f364c3672fcc6f04fe4087a7cff73e ) );
        
        }
        { //::osiris::XMLNodes::size
        
            typedef boost::python::object ( *size_function_type )( ::osiris::XMLNodes const & );
            
            XMLNodes_exposer.def( 
                "size"
                , size_function_type( &size_6cf4aca395fedde0d05627dc43eb66e8 ) );
        
        }
        { //::osiris::XMLNodes::clear
        
            typedef void ( *clear_function_type )( ::osiris::XMLNodes & );
            
            XMLNodes_exposer.def( 
                "clear"
                , clear_function_type( &clear_37afb558d4f0e2634c0bd84d7accca3b ) );
        
        }
        { //::osiris::XMLNodes::add
        
            typedef boost::python::object ( *add_function_type )( ::osiris::XMLNodes &,::boost::shared_ptr<osiris::XMLNode> );
            
            XMLNodes_exposer.def( 
                "add"
                , add_function_type( &add_cc461580a7929bbf7b77bb62a19d9b46 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("node") ) );
        
        }
        { //::osiris::XMLNodes::add
        
            typedef boost::python::object ( *add_function_type )( ::osiris::XMLNodes &,::osiris::String const & );
            
            XMLNodes_exposer.def( 
                "add"
                , add_function_type( &add_4288f2b3474a2847113027f42b9138cd )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLNodes::find
        
            typedef boost::python::object ( *find_function_type )( ::osiris::XMLNodes const &,::osiris::String const & );
            
            XMLNodes_exposer.def( 
                "find"
                , find_function_type( &find_13d9ed344d6873adbf9fbf0a24e90f81 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        { //::osiris::XMLNodes::find
        
            typedef boost::python::object ( *find_function_type )( ::osiris::XMLNodes const &,::size_t );
            
            XMLNodes_exposer.def( 
                "find"
                , find_function_type( &find_e3efa947e75c0e8a612bda6c31ff76b7 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("index") ) );
        
        }
        { //::osiris::XMLNodes::push_back
        
            typedef void ( *push_back_function_type )( ::osiris::XMLNodes &,::boost::shared_ptr<osiris::XMLNode> );
            
            XMLNodes_exposer.def( 
                "push_back"
                , push_back_function_type( &push_back_5f0c30a5290d41cf8b4f172e76b30811 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("node") ) );
        
        }
        { //::osiris::XMLNodes::push_front
        
            typedef void ( *push_front_function_type )( ::osiris::XMLNodes &,::boost::shared_ptr<osiris::XMLNode> );
            
            XMLNodes_exposer.def( 
                "push_front"
                , push_front_function_type( &push_front_362aeeb061ba2e1ed764a5e5da8f94d8 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("node") ) );
        
        }
        { //::osiris::XMLNodes::remove
        
            typedef void ( *remove_function_type )( ::osiris::XMLNodes &,::osiris::String const & );
            
            XMLNodes_exposer.def( 
                "remove"
                , remove_function_type( &remove_4108151c8681839513623ecbbb533189 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("name") ) );
        
        }
        ::boost::python::register_ptr_to_python< boost::shared_ptr< ::osiris::XMLNodes > >();
        ::boost::python::implicitly_convertible< boost::shared_ptr< ::osiris::XMLNodes >, boost::shared_ptr< ::osiris::Object > >();
    }

}
void register_buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__class(){

    { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >
        typedef bp::class_< osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > > buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t;
        buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer = buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer_t( "buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater_", "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n", bp::init< >("\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n") );
        bp::scope buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__scope( buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer );
        buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( bp::init< unsigned int >(( bp::arg("size") ), "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n") );
        bp::implicitly_convertible< unsigned int, osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > >();
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::clear
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef void ( exported_class_t::*clear_function_type )(  ) ;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "clear"
                , clear_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::clear ) );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::empty
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef bool ( exported_class_t::*empty_function_type )(  ) const;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "empty"
                , empty_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::empty ) );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator=
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef ::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > & ( exported_class_t::*assign_function_type )( ::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > const & ) ;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "assign"
                , assign_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator= )
                , ( bp::arg("rhs") )
                , bp::return_self< >()
                , "\n Implements a simple buffered value for values that need to be buffered on\n a per graphics context basis.\n" );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[]
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef ::osg::ref_ptr< osg::Program::PerContextProgram > & ( exported_class_t::*__getitem___function_type )( unsigned int ) ;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "__getitem__"
                , __getitem___function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[] )
                , ( bp::arg("pos") )
                , bp::return_internal_reference< >() );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[]
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef ::osg::ref_ptr< osg::Program::PerContextProgram > ( exported_class_t::*__getitem___function_type )( unsigned int ) const;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "__getitem__"
                , __getitem___function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::operator[] )
                , ( bp::arg("pos") ) );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::resize
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef void ( exported_class_t::*resize_function_type )( unsigned int ) ;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "resize"
                , resize_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::resize )
                , ( bp::arg("newSize") ) );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::setAllElementsTo
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef void ( exported_class_t::*setAllElementsTo_function_type )( ::osg::ref_ptr< osg::Program::PerContextProgram > const & ) ;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "setAllElementsTo"
                , setAllElementsTo_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::setAllElementsTo )
                , ( bp::arg("t") ) );
        
        }
        { //::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::size
        
            typedef osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > > exported_class_t;
            typedef unsigned int ( exported_class_t::*size_function_type )(  ) const;
            
            buffered_value_less__osg_scope_ref_ptr_less__osg_scope_Program_scope_PerContextProgram__greater___greater__exposer.def( 
                "size"
                , size_function_type( &::osg::buffered_value< osg::ref_ptr< osg::Program::PerContextProgram > >::size ) );
        
        }
    }

}
Beispiel #7
0
void register_LanguageResult_class(){

    { //::osiris::LanguageResult
        typedef ::boost::python::class_< ::osiris::LanguageResult > LanguageResult_exposer_t;
        LanguageResult_exposer_t LanguageResult_exposer = LanguageResult_exposer_t( "LanguageResult", ::boost::python::init< >() );
        ::boost::python::scope LanguageResult_scope( LanguageResult_exposer );
        LanguageResult_exposer.def( ::boost::python::init< ::std::string const &, ::osiris::StringCollection< osiris::String, osiris::StringCollectionTraits< osiris::String > > const & >(( ::boost::python::arg("id"), ::boost::python::arg("params") )) );
        LanguageResult_exposer.def( ::boost::python::init< ::std::string const &, ::std::string const &, ::osiris::DataItem const & >(( ::boost::python::arg("id"), ::boost::python::arg("key1"), ::boost::python::arg("val1") )) );
        LanguageResult_exposer.def( ::boost::python::init< ::std::string const &, ::std::string const &, ::osiris::DataItem const &, ::std::string const &, ::osiris::DataItem const & >(( ::boost::python::arg("id"), ::boost::python::arg("key1"), ::boost::python::arg("val1"), ::boost::python::arg("key2"), ::boost::python::arg("val2") )) );
        LanguageResult_exposer.def( ::boost::python::init< ::std::string const &, ::std::string const &, ::osiris::DataItem const &, ::std::string const &, ::osiris::DataItem const &, ::std::string const &, ::osiris::DataItem const & >(( ::boost::python::arg("id"), ::boost::python::arg("key1"), ::boost::python::arg("val1"), ::boost::python::arg("key2"), ::boost::python::arg("val2"), ::boost::python::arg("key3"), ::boost::python::arg("val3") )) );
        LanguageResult_exposer.def( ::boost::python::init< char const * >(( ::boost::python::arg("id") )) );
        ::boost::python::implicitly_convertible< char const *, ::osiris::LanguageResult >();
        LanguageResult_exposer.def( ::boost::python::init< ::std::string const & >(( ::boost::python::arg("id") )) );
        ::boost::python::implicitly_convertible< ::std::string const &, ::osiris::LanguageResult >();
        { //::osiris::LanguageResult::empty
        
            typedef boost::python::object ( *empty_function_type )( ::osiris::LanguageResult const & );
            
            LanguageResult_exposer.def( 
                "empty"
                , empty_function_type( &empty_09118a16244b093bb1797b0e2085670a ) );
        
        }
        { //::osiris::LanguageResult::getId
        
            typedef boost::python::object ( *getId_function_type )( ::osiris::LanguageResult const & );
            
            LanguageResult_exposer.def( 
                "getId"
                , getId_function_type( &getId_6c11a4755d0223c6da6b1fbd932f5033 ) );
        
        }
        { //::osiris::LanguageResult::getParams
        
            typedef boost::python::object ( *getParams_function_type )( ::osiris::LanguageResult const & );
            
            LanguageResult_exposer.def( 
                "getParams"
                , getParams_function_type( &getParams_a68269b787a0c043fe59a0fe05c960fc ) );
        
        }
        { //::osiris::LanguageResult::setParam
        
            typedef void ( *setParam_function_type )( ::osiris::LanguageResult &,::std::string const &,::osiris::DataItem const & );
            
            LanguageResult_exposer.def( 
                "setParam"
                , setParam_function_type( &setParam_7785a0556bad9fd5befa96e65118a968 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("key"), ::boost::python::arg("val") ) );
        
        }
        { //::osiris::LanguageResult::clear
        
            typedef void ( *clear_function_type )( ::osiris::LanguageResult & );
            
            LanguageResult_exposer.def( 
                "clear"
                , clear_function_type( &clear_f81eb595119ede7206586b0fc69543ec ) );
        
        }
        { //::osiris::LanguageResult::setId
        
            typedef void ( *setId_function_type )( ::osiris::LanguageResult &,::std::string const & );
            
            LanguageResult_exposer.def( 
                "setId"
                , setId_function_type( &setId_28f6d80cfbdd8392257cac4dad3712c4 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("id") ) );
        
        }
        { //::osiris::LanguageResult::setNoTranslate
        
            typedef void ( *setNoTranslate_function_type )( ::osiris::LanguageResult &,::std::string const & );
            
            LanguageResult_exposer.def( 
                "setNoTranslate"
                , setNoTranslate_function_type( &setNoTranslate_f6012eaba3e008ec112c9d872ddeb284 )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("text") ) );
        
        }
        { //property "id"[fget=::osiris::LanguageResult::getId, fset=::osiris::LanguageResult::setId]
        
            typedef ::std::string ( ::osiris::LanguageResult::*fget )(  ) const;
            typedef void ( ::osiris::LanguageResult::*fset )( ::std::string const & ) ;
            
            LanguageResult_exposer.add_property( 
                "id"
                , fget( &::osiris::LanguageResult::getId )
                , fset( &::osiris::LanguageResult::setId )
                , "get\\set property, built on top of \"std::string osiris::LanguageResult::getId() const [member function]\" and \"void osiris::LanguageResult::setId(std::string const & id) [member function]\"" );
        
        }
        { //property "params"[fget=::osiris::LanguageResult::getParams]
        
            typedef ::osiris::StringCollection<osiris::String, osiris::StringCollectionTraits<osiris::String> > const & ( ::osiris::LanguageResult::*fget )(  ) const;
            
            LanguageResult_exposer.add_property( 
                "params"
                , ::boost::python::make_function( 
                      fget( &::osiris::LanguageResult::getParams )
                    , bp::return_value_policy< bp::copy_const_reference >() ) 
                , "get property, built on top of \"osiris::StringCollection<osiris::String, osiris::StringCollectionTraits<osiris::String> > const & osiris::LanguageResult::getParams() const [member function]\"" );
        
        }
    }

}
Beispiel #8
0
void register_Cache_less__xfx_scope_CubemapTexture__greater__class(){

    { //::xfx::Cache< xfx::CubemapTexture >
        typedef bp::class_< xfx::Cache< xfx::CubemapTexture > > Cache_less__xfx_scope_CubemapTexture__greater__exposer_t;
        Cache_less__xfx_scope_CubemapTexture__greater__exposer_t Cache_less__xfx_scope_CubemapTexture__greater__exposer = Cache_less__xfx_scope_CubemapTexture__greater__exposer_t( "Cache_less__xfx_scope_CubemapTexture__greater_", bp::init< >() );
        bp::scope Cache_less__xfx_scope_CubemapTexture__greater__scope( Cache_less__xfx_scope_CubemapTexture__greater__exposer );
        { //::xfx::Cache< xfx::CubemapTexture >::Clear
        
            typedef xfx::Cache< xfx::CubemapTexture > exported_class_t;
            typedef void ( exported_class_t::*clear_function_type )(  ) ;
            
            Cache_less__xfx_scope_CubemapTexture__greater__exposer.def( 
                "clear"
                , clear_function_type( &::xfx::Cache< xfx::CubemapTexture >::Clear ) );
        
        }
        { //::xfx::Cache< xfx::CubemapTexture >::Register
        
            typedef xfx::Cache< xfx::CubemapTexture > exported_class_t;
            typedef ::boost::shared_ptr< const xfx::CubemapTexture > ( exported_class_t::*register_function_type )( ::std::string const & ) ;
            
            Cache_less__xfx_scope_CubemapTexture__greater__exposer.def( 
                "register"
                , register_function_type( &::xfx::Cache< xfx::CubemapTexture >::Register )
                , ( bp::arg("filename") ) );
        
        }
        { //::xfx::Cache< xfx::CubemapTexture >::Register
        
            typedef xfx::Cache< xfx::CubemapTexture > exported_class_t;
            typedef ::HRESULT ( exported_class_t::*register_function_type )( ::xfx::CubemapTexture &,::std::string const & ) ;
            
            Cache_less__xfx_scope_CubemapTexture__greater__exposer.def( 
                "register"
                , register_function_type( &::xfx::Cache< xfx::CubemapTexture >::Register )
                , ( bp::arg("object"), bp::arg("filename") ) );
        
        }
        { //::xfx::Cache< xfx::CubemapTexture >::ReloadAll
        
            typedef xfx::Cache< xfx::CubemapTexture > exported_class_t;
            typedef void ( exported_class_t::*reload_all_function_type )(  ) ;
            
            Cache_less__xfx_scope_CubemapTexture__greater__exposer.def( 
                "reload_all"
                , reload_all_function_type( &::xfx::Cache< xfx::CubemapTexture >::ReloadAll ) );
        
        }
        { //::xfx::Cache< xfx::CubemapTexture >::Unregister
        
            typedef xfx::Cache< xfx::CubemapTexture > exported_class_t;
            typedef void ( exported_class_t::*unregister_function_type )( ::boost::shared_ptr< const xfx::CubemapTexture > const & ) ;
            
            Cache_less__xfx_scope_CubemapTexture__greater__exposer.def( 
                "unregister"
                , unregister_function_type( &::xfx::Cache< xfx::CubemapTexture >::Unregister )
                , ( bp::arg("object") ) );
        
        }
        bp::register_ptr_to_python< boost::shared_ptr< xfx::Cache<xfx::CubemapTexture> const > >( );
        bp::implicitly_convertible< boost::shared_ptr< xfx::Cache<xfx::CubemapTexture> >, boost::shared_ptr< xfx::Cache<xfx::CubemapTexture> const > >( );
    }

}
Beispiel #9
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 > >();
    }

}
void register_TextureObjectBuffer_class(){

    { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >
        typedef bp::class_< osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > > TextureObjectBuffer_exposer_t;
        TextureObjectBuffer_exposer_t TextureObjectBuffer_exposer = TextureObjectBuffer_exposer_t( "TextureObjectBuffer", bp::init< >() );
        bp::scope TextureObjectBuffer_scope( TextureObjectBuffer_exposer );
        TextureObjectBuffer_exposer.def( bp::init< unsigned int >(( bp::arg("size") )) );
        bp::implicitly_convertible< unsigned int, osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > >();
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::clear
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef void ( exported_class_t::*clear_function_type )(  ) ;
            
            TextureObjectBuffer_exposer.def( 
                "clear"
                , clear_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::clear ) );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::empty
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef bool ( exported_class_t::*empty_function_type )(  ) const;
            
            TextureObjectBuffer_exposer.def( 
                "empty"
                , empty_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::empty ) );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator=
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef ::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > & ( exported_class_t::*assign_function_type )( ::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > const & ) ;
            
            TextureObjectBuffer_exposer.def( 
                "assign"
                , assign_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator= )
                , ( bp::arg("rhs") )
                , bp::return_self< >() );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[]
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef ::osg::ref_ptr< osg::Texture::TextureObject > & ( exported_class_t::*__getitem___function_type )( unsigned int ) ;
            
            TextureObjectBuffer_exposer.def( 
                "__getitem__"
                , __getitem___function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[] )
                , ( bp::arg("pos") )
                , bp::return_internal_reference< >() );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[]
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef ::osg::ref_ptr< osg::Texture::TextureObject > const & ( exported_class_t::*__getitem___function_type )( unsigned int ) const;
            
            TextureObjectBuffer_exposer.def( 
                "__getitem__"
                , __getitem___function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::operator[] )
                , ( bp::arg("pos") )
                , bp::return_internal_reference< >() );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::resize
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef void ( exported_class_t::*resize_function_type )( unsigned int ) ;
            
            TextureObjectBuffer_exposer.def( 
                "resize"
                , resize_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::resize )
                , ( bp::arg("newSize") ) );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::setAllElementsTo
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef void ( exported_class_t::*setAllElementsTo_function_type )( ::osg::ref_ptr< osg::Texture::TextureObject > const & ) ;
            
            TextureObjectBuffer_exposer.def( 
                "setAllElementsTo"
                , setAllElementsTo_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::setAllElementsTo )
                , ( bp::arg("t") ) );
        
        }
        { //::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::size
        
            typedef osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > > exported_class_t;
            typedef unsigned int ( exported_class_t::*size_function_type )(  ) const;
            
            TextureObjectBuffer_exposer.def( 
                "size"
                , size_function_type( &::osg::buffered_object< osg::ref_ptr< osg::Texture::TextureObject > >::size ) );
        
        }
    }

}