Пример #1
0
void register_HtmlPopup_class(){

    { //::osiris::HtmlPopup
        typedef ::boost::python::class_< HtmlPopup_wrapper, ::boost::python::bases< ::osiris::HtmlDiv >, ::boost::noncopyable > HtmlPopup_exposer_t;
        HtmlPopup_exposer_t HtmlPopup_exposer = HtmlPopup_exposer_t( "HtmlPopup", ::boost::python::init< >() );
        ::boost::python::scope HtmlPopup_scope( HtmlPopup_exposer );
        ::boost::python::enum_< ::osiris::HtmlPopup::Type>("Type")
            .value("ptStatic", ::osiris::HtmlPopup::ptStatic)
            .value("ptStaticClick", ::osiris::HtmlPopup::ptStaticClick)
            .value("ptTooltip", ::osiris::HtmlPopup::ptTooltip)
            .value("ptPopup", ::osiris::HtmlPopup::ptPopup)
            .export_values()
            ;
        { //::osiris::HtmlPopup::getType
        
            typedef boost::python::object ( *getType_function_type )( ::osiris::HtmlPopup const & );
            
            HtmlPopup_exposer.def( 
                "getType"
                , getType_function_type( &HtmlPopup_wrapper::getType ) );
        
        }
        { //::osiris::HtmlPopup::getHeader
        
            typedef boost::python::object ( *getHeader_function_type )( ::osiris::HtmlPopup & );
            
            HtmlPopup_exposer.def( 
                "getHeader"
                , getHeader_function_type( &HtmlPopup_wrapper::getHeader ) );
        
        }
        { //::osiris::HtmlPopup::getBody
        
            typedef boost::python::object ( *getBody_function_type )( ::osiris::HtmlPopup & );
            
            HtmlPopup_exposer.def( 
                "getBody"
                , getBody_function_type( &HtmlPopup_wrapper::getBody ) );
        
        }
        { //::osiris::HtmlPopup::onPreRender
        
            typedef void ( HtmlPopup_wrapper::*onPreRender_function_type )(  ) ;
            
            HtmlPopup_exposer.def( 
                "onPreRender"
                , onPreRender_function_type( &HtmlPopup_wrapper::default_onPreRender ) );
        
        }
        { //::osiris::HtmlPopup::setType
        
            typedef void ( *setType_function_type )( ::osiris::HtmlPopup &,::osiris::HtmlPopup::Type );
            
            HtmlPopup_exposer.def( 
                "setType"
                , setType_function_type( &HtmlPopup_wrapper::setType )
                , ( ::boost::python::arg("inst"), ::boost::python::arg("type") ) );
        
        }
        { //::osiris::IHtmlControl::decodeEvent
        
            typedef bool ( HtmlPopup_wrapper::*decodeEvent_function_type )( ::osiris::String const &,::osiris::String &,::osiris::HtmlEvent & ) const;
            
            HtmlPopup_exposer.def( 
                "decodeEvent"
                , decodeEvent_function_type( &HtmlPopup_wrapper::decodeEvent )
                , ( ::boost::python::arg("command"), ::boost::python::arg("eventName"), ::boost::python::arg("e") ) );
        
        }
        { //::osiris::IHtmlControl::encodeEvent
        
            typedef ::osiris::String ( HtmlPopup_wrapper::*encodeEvent_function_type )( ::osiris::String const &,::osiris::HtmlEvent const * ) const;
            
            HtmlPopup_exposer.def( 
                "encodeEvent"
                , encodeEvent_function_type( &HtmlPopup_wrapper::encodeEvent )
                , ( ::boost::python::arg("eventName"), ::boost::python::arg("e")=(nullptr) ) );
        
        }
        { //::osiris::IHtmlControl::getSession
        
            typedef ::boost::shared_ptr< osiris::HttpSession > ( ::osiris::IHtmlControl::*getSession_function_type )(  ) const;
            typedef ::boost::shared_ptr< osiris::HttpSession > ( HtmlPopup_wrapper::*default_getSession_function_type )(  ) const;
            
            HtmlPopup_exposer.def( 
                "getSession"
                , getSession_function_type(&::osiris::IHtmlControl::getSession)
                , default_getSession_function_type(&HtmlPopup_wrapper::default_getSession) );
        
        }
        { //::osiris::IHtmlControl::onEvent
        
            typedef void ( HtmlPopup_wrapper::*onEvent_function_type )( ::osiris::String const &,::osiris::IEvent * ) ;
            
            HtmlPopup_exposer.def( 
                "onEvent"
                , onEvent_function_type( &HtmlPopup_wrapper::default_onEvent )
                , ( ::boost::python::arg("name"), ::boost::python::arg("e")=(nullptr) ) );
        
        }
        { //::osiris::IHtmlControl::onInit
        
            typedef void ( HtmlPopup_wrapper::*onInit_function_type )(  ) ;
            
            HtmlPopup_exposer.def( 
                "onInit"
                , onInit_function_type( &HtmlPopup_wrapper::default_onInit ) );
        
        }
        { //::osiris::IHtmlControl::onLoad
        
            typedef void ( HtmlPopup_wrapper::*onLoad_function_type )(  ) ;
            
            HtmlPopup_exposer.def( 
                "onLoad"
                , onLoad_function_type( &HtmlPopup_wrapper::default_onLoad ) );
        
        }
        { //::osiris::IHtmlControl::onLoadViewState
        
            typedef void ( HtmlPopup_wrapper::*onLoadViewState_function_type )( ::osiris::DataTree const & ) ;
            
            HtmlPopup_exposer.def( 
                "onLoadViewState"
                , onLoadViewState_function_type( &HtmlPopup_wrapper::default_onLoadViewState )
                , ( ::boost::python::arg("state") ) );
        
        }
        { //::osiris::HtmlDiv::onRender
        
            typedef void ( HtmlPopup_wrapper::*onRender_function_type )( ::osiris::HtmlWriter & ) ;
            
            HtmlPopup_exposer.def( 
                "onRender"
                , onRender_function_type( &HtmlPopup_wrapper::default_onRender )
                , ( ::boost::python::arg("writer") ) );
        
        }
        { //::osiris::IHtmlControl::onSaveViewState
        
            typedef void ( HtmlPopup_wrapper::*onSaveViewState_function_type )( ::osiris::DataTree & ) ;
            
            HtmlPopup_exposer.def( 
                "onSaveViewState"
                , onSaveViewState_function_type( &HtmlPopup_wrapper::default_onSaveViewState )
                , ( ::boost::python::arg("state") ) );
        
        }
        { //::osiris::IHtmlControl::renderAttributes
        
            typedef void ( ::osiris::IHtmlControl::*renderAttributes_function_type )( ::osiris::HtmlWriter & ) ;
            typedef void ( HtmlPopup_wrapper::*default_renderAttributes_function_type )( ::osiris::HtmlWriter & ) ;
            
            HtmlPopup_exposer.def( 
                "renderAttributes"
                , renderAttributes_function_type(&::osiris::IHtmlControl::renderAttributes)
                , default_renderAttributes_function_type(&HtmlPopup_wrapper::default_renderAttributes)
                , ( ::boost::python::arg("writer") ) );
        
        }
        { //::osiris::IHtmlControl::renderChilds
        
            typedef void ( ::osiris::IHtmlControl::*renderChilds_function_type )( ::osiris::HtmlWriter & ) ;
            typedef void ( HtmlPopup_wrapper::*default_renderChilds_function_type )( ::osiris::HtmlWriter & ) ;
            
            HtmlPopup_exposer.def( 
                "renderChilds"
                , renderChilds_function_type(&::osiris::IHtmlControl::renderChilds)
                , default_renderChilds_function_type(&HtmlPopup_wrapper::default_renderChilds)
                , ( ::boost::python::arg("writer") ) );
        
        }
        { //::osiris::IHtmlControl::saveViewState
        
            typedef void ( HtmlPopup_wrapper::*saveViewState_function_type )( ::osiris::DataTree & ) ;
            
            HtmlPopup_exposer.def( 
                "saveViewState"
                , saveViewState_function_type( &HtmlPopup_wrapper::saveViewState )
                , ( ::boost::python::arg("states") ) );
        
        }
        { //property "type"[fget=::osiris::HtmlPopup::getType, fset=::osiris::HtmlPopup::setType]
        
            typedef ::osiris::HtmlPopup::Type ( ::osiris::HtmlPopup::*fget )(  ) const;
            typedef void ( ::osiris::HtmlPopup::*fset )( ::osiris::HtmlPopup::Type ) ;
            
            HtmlPopup_exposer.add_property( 
                "type"
                , fget( &::osiris::HtmlPopup::getType )
                , fset( &::osiris::HtmlPopup::setType )
                , "get\\set property, built on top of \"osiris::HtmlPopup::Type osiris::HtmlPopup::getType() const [member function]\" and \"void osiris::HtmlPopup::setType(osiris::HtmlPopup::Type type) [member function]\"" );
        
        }
    }

}
Пример #2
0
void register_ID_class(){

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

}