void register_SystemMonitor_class(){ { //::SireSystem::SystemMonitor typedef bp::class_< SireSystem::SystemMonitor, bp::bases< SireBase::Property >, boost::noncopyable > SystemMonitor_exposer_t; SystemMonitor_exposer_t SystemMonitor_exposer = SystemMonitor_exposer_t( "SystemMonitor", bp::no_init ); bp::scope SystemMonitor_scope( SystemMonitor_exposer ); { //::SireSystem::SystemMonitor::clearStatistics typedef void ( ::SireSystem::SystemMonitor::*clearStatistics_function_type )( ) ; clearStatistics_function_type clearStatistics_function_value( &::SireSystem::SystemMonitor::clearStatistics ); SystemMonitor_exposer.def( "clearStatistics" , clearStatistics_function_value ); } { //::SireSystem::SystemMonitor::monitor typedef void ( ::SireSystem::SystemMonitor::*monitor_function_type )( ::SireSystem::System & ) ; monitor_function_type monitor_function_value( &::SireSystem::SystemMonitor::monitor ); SystemMonitor_exposer.def( "monitor" , monitor_function_value , ( bp::arg("system") ) ); } { //::SireSystem::SystemMonitor::null typedef ::SireSystem::NullMonitor const & ( *null_function_type )( ); null_function_type null_function_value( &::SireSystem::SystemMonitor::null ); SystemMonitor_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireSystem::SystemMonitor::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireSystem::SystemMonitor::typeName ); SystemMonitor_exposer.def( "typeName" , typeName_function_value ); } SystemMonitor_exposer.staticmethod( "null" ); SystemMonitor_exposer.staticmethod( "typeName" ); SystemMonitor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::SystemMonitor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SystemMonitor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::SystemMonitor >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SystemMonitor_exposer.def( "__str__", &__str__< ::SireSystem::SystemMonitor > ); SystemMonitor_exposer.def( "__repr__", &__str__< ::SireSystem::SystemMonitor > ); } }
void register_Number_class(){ { //::SireID::Number typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t; Number_exposer_t Number_exposer = Number_exposer_t( "Number", bp::no_init ); bp::scope Number_scope( Number_exposer ); { //::SireID::Number::hash typedef ::uint ( ::SireID::Number::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireID::Number::hash ); Number_exposer.def( "hash" , hash_function_value ); } { //::SireID::Number::isNull typedef bool ( ::SireID::Number::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireID::Number::isNull ); Number_exposer.def( "isNull" , isNull_function_value ); } { //::SireID::Number::null typedef ::qint32 ( *null_function_type )( ); null_function_type null_function_value( &::SireID::Number::null ); Number_exposer.def( "null" , null_function_value ); } { //::SireID::Number::value typedef ::qint32 ( ::SireID::Number::*value_function_type )( ) const; value_function_type value_function_value( &::SireID::Number::value ); Number_exposer.def( "value" , value_function_value ); } Number_exposer.staticmethod( "null" ); Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__str__", &pvt_get_name); Number_exposer.def( "__repr__", &pvt_get_name); } }
void register_Perturbation_class(){ { //::SireMol::Perturbation typedef bp::class_< SireMol::Perturbation, bp::bases< SireBase::Property >, boost::noncopyable > Perturbation_exposer_t; Perturbation_exposer_t Perturbation_exposer = Perturbation_exposer_t( "Perturbation", "This is the base class of all perturbation objects. A Perturbation\nis a rule for changing a property of a molecule with respect\nto a driving (reaction) coordinate. Perturbations can be used\nto implement single topology free energy calculations\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Perturbation_scope( Perturbation_exposer ); { //::SireMol::Perturbation::children typedef ::QList< SireBase::PropPtr< SireMol::Perturbation > > ( ::SireMol::Perturbation::*children_function_type)( ) const; children_function_type children_function_value( &::SireMol::Perturbation::children ); Perturbation_exposer.def( "children" , children_function_value , "Return all of the child perturbations that make up\nthis perturbation" ); } { //::SireMol::Perturbation::defaultFunction typedef ::SireCAS::Expression const & ( *defaultFunction_function_type )( ); defaultFunction_function_type defaultFunction_function_value( &::SireMol::Perturbation::defaultFunction ); Perturbation_exposer.def( "defaultFunction" , defaultFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the default mapping equation for the perturbations - this\nlinearly maps from the initial values at lambda=0 to the\nfinal value at lambda=1" ); } { //::SireMol::Perturbation::mappingFunction typedef ::SireCAS::Expression const & ( ::SireMol::Perturbation::*mappingFunction_function_type)( ) const; mappingFunction_function_type mappingFunction_function_value( &::SireMol::Perturbation::mappingFunction ); Perturbation_exposer.def( "mappingFunction" , mappingFunction_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the equation used to control the mapping from the\nthe initial value (represented using symbols().initial()) to\nthe final value (represented using symbols().final()) as a\nfunction of the reaction coordinate (which is normally\nrepresented using symbols().lambda())" ); } { //::SireMol::Perturbation::null typedef ::SireMol::NullPerturbation const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMol::Perturbation::null ); Perturbation_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMol::Perturbation::perturb typedef ::SireMol::Molecule ( ::SireMol::Perturbation::*perturb_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; perturb_function_type perturb_function_value( &::SireMol::Perturbation::perturb ); Perturbation_exposer.def( "perturb" , perturb_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "Perturb the passed molecule, returning the result\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError:incompatible_error\n" ); } { //::SireMol::Perturbation::propertyMap typedef ::SireBase::PropertyMap const & ( ::SireMol::Perturbation::*propertyMap_function_type)( ) const; propertyMap_function_type propertyMap_function_value( &::SireMol::Perturbation::propertyMap ); Perturbation_exposer.def( "propertyMap" , propertyMap_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the property map used to find the properties used,\nand affected by this perturbation" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , "Recreate this perturbation - this has the same effect as .clone()" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function") ) , "Recreate this perturbation, replacing its current mapping function\nwith mapping_function" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("map") ) , "Recreate this perturbation, replacing the current property map with map" ); } { //::SireMol::Perturbation::recreate typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const; recreate_function_type recreate_function_value( &::SireMol::Perturbation::recreate ); Perturbation_exposer.def( "recreate" , recreate_function_value , ( bp::arg("mapping_function"), bp::arg("map") ) , "Recreate this perturbation, replacing both the mapping function and\nthe property map" ); } { //::SireMol::Perturbation::requiredProperties typedef ::QSet< QString > ( ::SireMol::Perturbation::*requiredProperties_function_type)( ) const; requiredProperties_function_type requiredProperties_function_value( &::SireMol::Perturbation::requiredProperties ); Perturbation_exposer.def( "requiredProperties" , requiredProperties_function_value , "" ); } { //::SireMol::Perturbation::requiredSymbols typedef ::QSet< SireCAS::Symbol > ( ::SireMol::Perturbation::*requiredSymbols_function_type)( ) const; requiredSymbols_function_type requiredSymbols_function_value( &::SireMol::Perturbation::requiredSymbols ); Perturbation_exposer.def( "requiredSymbols" , requiredSymbols_function_value , "Return all of the symbols that need to be supplied\nto the mapping function (i.e. ignoring symbols().initial()\nand symbols().final() )" ); } { //::SireMol::Perturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Symbol const &,::SireCAS::Symbol const & ) const; substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute ); Perturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("old_symbol"), bp::arg("new_symbol") ) , "Substitute the symbol old_symbol with the symbol new_symbol\nin all of the mapping functions used by this perturbation. This is\nuseful if, for example, you want to switch from using\nlambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMol::Perturbation::substitute typedef ::SireMol::PerturbationPtr ( ::SireMol::Perturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const; substitute_function_type substitute_function_value( &::SireMol::Perturbation::substitute ); Perturbation_exposer.def( "substitute" , substitute_function_value , ( bp::arg("identities") ) , "Substitute the identities in identities in all of the mapping functions\nused by this perturbation. This is useful if, for example, you want to\nswitch from using lambda to control the perturbation to using alpha, e.g.\n" ); } { //::SireMol::Perturbation::symbols typedef ::SireMol::PerturbationSymbols const & ( *symbols_function_type )( ); symbols_function_type symbols_function_value( &::SireMol::Perturbation::symbols ); Perturbation_exposer.def( "symbols" , symbols_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return the symbols object that contains the symbols used\nby the mapping equation" ); } { //::SireMol::Perturbation::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::Perturbation::typeName ); Perturbation_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireMol::Perturbation::wouldChange typedef bool ( ::SireMol::Perturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const; wouldChange_function_type wouldChange_function_value( &::SireMol::Perturbation::wouldChange ); Perturbation_exposer.def( "wouldChange" , wouldChange_function_value , ( bp::arg("molecule"), bp::arg("values") ) , "" ); } Perturbation_exposer.staticmethod( "defaultFunction" ); Perturbation_exposer.staticmethod( "null" ); Perturbation_exposer.staticmethod( "symbols" ); Perturbation_exposer.staticmethod( "typeName" ); Perturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Perturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Perturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Perturbation >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Perturbation_exposer.def( "__str__", &__str__< ::SireMol::Perturbation > ); Perturbation_exposer.def( "__repr__", &__str__< ::SireMol::Perturbation > ); } }
void register_Integrator_class(){ { //::SireMove::Integrator typedef bp::class_< SireMove::Integrator, bp::bases< SireBase::Property >, boost::noncopyable > Integrator_exposer_t; Integrator_exposer_t Integrator_exposer = Integrator_exposer_t( "Integrator", "This is the virtual base class of all dynamics integrators. An integrator\nis the kernel used to advance the coordinates of the system from one\ntimestep to the next\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Integrator_scope( Integrator_exposer ); { //::SireMove::Integrator::createWorkspace typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireBase::PropertyMap const & ) const; createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace ); Integrator_exposer.def( "createWorkspace" , createWorkspace_function_value , ( bp::arg("map")=SireBase::PropertyMap() ) , "" ); } { //::SireMove::Integrator::createWorkspace typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const; createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace ); Integrator_exposer.def( "createWorkspace" , createWorkspace_function_value , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) , "" ); } { //::SireMove::Integrator::ensemble typedef ::SireMove::Ensemble ( ::SireMove::Integrator::*ensemble_function_type)( ) const; ensemble_function_type ensemble_function_value( &::SireMove::Integrator::ensemble ); Integrator_exposer.def( "ensemble" , ensemble_function_value , "" ); } { //::SireMove::Integrator::integrate typedef void ( ::SireMove::Integrator::*integrate_function_type)( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) ; integrate_function_type integrate_function_value( &::SireMove::Integrator::integrate ); Integrator_exposer.def( "integrate" , integrate_function_value , ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") ) , "" ); } { //::SireMove::Integrator::isTimeReversible typedef bool ( ::SireMove::Integrator::*isTimeReversible_function_type)( ) const; isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::Integrator::isTimeReversible ); Integrator_exposer.def( "isTimeReversible" , isTimeReversible_function_value , "" ); } { //::SireMove::Integrator::null typedef ::SireMove::NullIntegrator const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMove::Integrator::null ); Integrator_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "Return a NullIntegrator" ); } { //::SireMove::Integrator::toString typedef ::QString ( ::SireMove::Integrator::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireMove::Integrator::toString ); Integrator_exposer.def( "toString" , toString_function_value , "" ); } { //::SireMove::Integrator::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::Integrator::typeName ); Integrator_exposer.def( "typeName" , typeName_function_value , "" ); } Integrator_exposer.staticmethod( "null" ); Integrator_exposer.staticmethod( "typeName" ); Integrator_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Integrator >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Integrator_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Integrator >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Integrator_exposer.def( "__str__", &__str__< ::SireMove::Integrator > ); Integrator_exposer.def( "__repr__", &__str__< ::SireMove::Integrator > ); } }
void register_SupraSubMove_class(){ { //::SireMove::SupraSubMove typedef bp::class_< SireMove::SupraSubMove, bp::bases< SireBase::Property >, boost::noncopyable > SupraSubMove_exposer_t; SupraSubMove_exposer_t SupraSubMove_exposer = SupraSubMove_exposer_t( "SupraSubMove", bp::no_init ); bp::scope SupraSubMove_scope( SupraSubMove_exposer ); { //::SireMove::SupraSubMove::clearStatistics typedef void ( ::SireMove::SupraSubMove::*clearStatistics_function_type )( ) ; clearStatistics_function_type clearStatistics_function_value( &::SireMove::SupraSubMove::clearStatistics ); SupraSubMove_exposer.def( "clearStatistics" , clearStatistics_function_value ); } { //::SireMove::SupraSubMove::move typedef void ( ::SireMove::SupraSubMove::*move_function_type )( ::SireMove::SupraSubSystem &,int,int,bool ) ; move_function_type move_function_value( &::SireMove::SupraSubMove::move ); SupraSubMove_exposer.def( "move" , move_function_value , ( bp::arg("system"), bp::arg("n_supra_moves"), bp::arg("n_supra_moves_per_block"), bp::arg("record_stats")=(bool)(true) ) ); } { //::SireMove::SupraSubMove::null typedef ::SireMove::NullSupraSubMove const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMove::SupraSubMove::null ); SupraSubMove_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMove::SupraSubMove::toString typedef ::QString ( ::SireMove::SupraSubMove::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMove::SupraSubMove::toString ); SupraSubMove_exposer.def( "toString" , toString_function_value ); } { //::SireMove::SupraSubMove::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::SupraSubMove::typeName ); SupraSubMove_exposer.def( "typeName" , typeName_function_value ); } SupraSubMove_exposer.staticmethod( "null" ); SupraSubMove_exposer.staticmethod( "typeName" ); SupraSubMove_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubMove >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubMove_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubMove >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); SupraSubMove_exposer.def( "__str__", &__str__< ::SireMove::SupraSubMove > ); SupraSubMove_exposer.def( "__repr__", &__str__< ::SireMove::SupraSubMove > ); } }
void register_QMProgram_class(){ { //::Squire::QMProgram typedef bp::class_< Squire::QMProgram, bp::bases< SireBase::Property >, boost::noncopyable > QMProgram_exposer_t; QMProgram_exposer_t QMProgram_exposer = QMProgram_exposer_t( "QMProgram", bp::no_init ); bp::scope QMProgram_scope( QMProgram_exposer ); { //::Squire::QMProgram::calculateCharges typedef ::SireMol::AtomCharges ( ::Squire::QMProgram::*calculateCharges_function_type )( ::SireMol::Molecule const &,::SireBase::PropertyMap const & ) const; calculateCharges_function_type calculateCharges_function_value( &::Squire::QMProgram::calculateCharges ); QMProgram_exposer.def( "calculateCharges" , calculateCharges_function_value , ( bp::arg("molecule"), bp::arg("map") ) ); } { //::Squire::QMProgram::calculateCharges typedef ::SireMol::AtomCharges ( ::Squire::QMProgram::*calculateCharges_function_type )( ::SireMol::Molecule const & ) const; calculateCharges_function_type calculateCharges_function_value( &::Squire::QMProgram::calculateCharges ); QMProgram_exposer.def( "calculateCharges" , calculateCharges_function_value , ( bp::arg("molecule") ) ); } { //::Squire::QMProgram::chargeCommandFile typedef ::QString ( ::Squire::QMProgram::*chargeCommandFile_function_type )( ::SireMol::Molecule const & ) const; chargeCommandFile_function_type chargeCommandFile_function_value( &::Squire::QMProgram::chargeCommandFile ); QMProgram_exposer.def( "chargeCommandFile" , chargeCommandFile_function_value , ( bp::arg("molecule") ) ); } { //::Squire::QMProgram::chargeCommandFile typedef ::QString ( ::Squire::QMProgram::*chargeCommandFile_function_type )( ::SireMol::Molecule const &,::SireBase::PropertyMap const & ) const; chargeCommandFile_function_type chargeCommandFile_function_value( &::Squire::QMProgram::chargeCommandFile ); QMProgram_exposer.def( "chargeCommandFile" , chargeCommandFile_function_value , ( bp::arg("molecule"), bp::arg("map") ) ); } { //::Squire::QMProgram::null typedef ::Squire::NullQM const & ( *null_function_type )( ); null_function_type null_function_value( &::Squire::QMProgram::null ); QMProgram_exposer.def( "null" , null_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::Squire::QMProgram::numberOfMMAtomsLimit typedef int ( ::Squire::QMProgram::*numberOfMMAtomsLimit_function_type )( ) const; numberOfMMAtomsLimit_function_type numberOfMMAtomsLimit_function_value( &::Squire::QMProgram::numberOfMMAtomsLimit ); QMProgram_exposer.def( "numberOfMMAtomsLimit" , numberOfMMAtomsLimit_function_value ); } { //::Squire::QMProgram::numberOfMMAtomsLimit typedef int ( ::Squire::QMProgram::*numberOfMMAtomsLimit_function_type )( int ) const; numberOfMMAtomsLimit_function_type numberOfMMAtomsLimit_function_value( &::Squire::QMProgram::numberOfMMAtomsLimit ); QMProgram_exposer.def( "numberOfMMAtomsLimit" , numberOfMMAtomsLimit_function_value , ( bp::arg("num_qm_atoms") ) ); } { //::Squire::QMProgram::supportsGaussianCharges typedef bool ( ::Squire::QMProgram::*supportsGaussianCharges_function_type )( ) const; supportsGaussianCharges_function_type supportsGaussianCharges_function_value( &::Squire::QMProgram::supportsGaussianCharges ); QMProgram_exposer.def( "supportsGaussianCharges" , supportsGaussianCharges_function_value ); } { //::Squire::QMProgram::supportsLatticeCharges typedef bool ( ::Squire::QMProgram::*supportsLatticeCharges_function_type )( ) const; supportsLatticeCharges_function_type supportsLatticeCharges_function_value( &::Squire::QMProgram::supportsLatticeCharges ); QMProgram_exposer.def( "supportsLatticeCharges" , supportsLatticeCharges_function_value ); } { //::Squire::QMProgram::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::Squire::QMProgram::typeName ); QMProgram_exposer.def( "typeName" , typeName_function_value ); } QMProgram_exposer.staticmethod( "null" ); QMProgram_exposer.staticmethod( "typeName" ); QMProgram_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::Squire::QMProgram >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); QMProgram_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::Squire::QMProgram >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); QMProgram_exposer.def( "__str__", &__str__< ::Squire::QMProgram > ); QMProgram_exposer.def( "__repr__", &__str__< ::Squire::QMProgram > ); } }
void register_StringMangler_class(){ { //::SireBase::StringMangler typedef bp::class_< SireBase::StringMangler, bp::bases< SireBase::Property >, boost::noncopyable > StringMangler_exposer_t; StringMangler_exposer_t StringMangler_exposer = StringMangler_exposer_t( "StringMangler", "This is the base class of all string mangling functions.\nA string mangler is just a simple function that performs\nsome transformations on an input string, e.g. changing its\ncase, trimming away extra spaces etc.\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope StringMangler_scope( StringMangler_exposer ); { //::SireBase::StringMangler::mangle typedef ::QString ( ::SireBase::StringMangler::*mangle_function_type)( ::QString const & ) const; mangle_function_type mangle_function_value( &::SireBase::StringMangler::mangle ); StringMangler_exposer.def( "mangle" , mangle_function_value , ( bp::arg("input") ) , "" ); } { //::SireBase::StringMangler::null typedef ::SireBase::NoMangling const & ( *null_function_type )( ); null_function_type null_function_value( &::SireBase::StringMangler::null ); StringMangler_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireBase::StringMangler::operator() typedef ::QString ( ::SireBase::StringMangler::*__call___function_type)( ::QString const & ) const; __call___function_type __call___function_value( &::SireBase::StringMangler::operator() ); StringMangler_exposer.def( "__call__" , __call___function_value , ( bp::arg("input") ) , "" ); } { //::SireBase::StringMangler::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireBase::StringMangler::typeName ); StringMangler_exposer.def( "typeName" , typeName_function_value , "" ); } StringMangler_exposer.staticmethod( "null" ); StringMangler_exposer.staticmethod( "typeName" ); StringMangler_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::StringMangler >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); StringMangler_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::StringMangler >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); StringMangler_exposer.def( "__str__", &__str__< ::SireBase::StringMangler > ); StringMangler_exposer.def( "__repr__", &__str__< ::SireBase::StringMangler > ); } }
void register_FFIdx_class(){ { //::SireFF::FFIdx typedef bp::class_< SireFF::FFIdx, bp::bases< SireFF::FFID, SireID::ID, SireID::IndexBase > > FFIdx_exposer_t; FFIdx_exposer_t FFIdx_exposer = FFIdx_exposer_t( "FFIdx", "This is an ID object that is used to index forcefields (e.g. index\nin a list or array).\n\nAuthor: Christopher Woods\n", bp::init< >("") ); bp::scope FFIdx_scope( FFIdx_exposer ); FFIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") ), "") ); FFIdx_exposer.def( bp::init< SireFF::FFIdx const & >(( bp::arg("other") ), "") ); { //::SireFF::FFIdx::hash typedef ::uint ( ::SireFF::FFIdx::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireFF::FFIdx::hash ); FFIdx_exposer.def( "hash" , hash_function_value , "" ); } { //::SireFF::FFIdx::isNull typedef bool ( ::SireFF::FFIdx::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireFF::FFIdx::isNull ); FFIdx_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireFF::FFIdx::map typedef ::QList< SireFF::FFIdx > ( ::SireFF::FFIdx::*map_function_type)( ::SireFF::ForceFields const & ) const; map_function_type map_function_value( &::SireFF::FFIdx::map ); FFIdx_exposer.def( "map" , map_function_value , ( bp::arg("ffields") ) , "Short cut function to map this index to the index of the\nmatching forcefield in the passed ForceFields object\nThrow: SireError::invalid_index\n" ); } { //::SireFF::FFIdx::null typedef ::SireFF::FFIdx ( *null_function_type )( ); null_function_type null_function_value( &::SireFF::FFIdx::null ); FFIdx_exposer.def( "null" , null_function_value , "" ); } { //::SireFF::FFIdx::operator= typedef ::SireFF::FFIdx & ( ::SireFF::FFIdx::*assign_function_type)( ::SireFF::FFIdx const & ) ; assign_function_type assign_function_value( &::SireFF::FFIdx::operator= ); FFIdx_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() , "" ); } { //::SireFF::FFIdx::toString typedef ::QString ( ::SireFF::FFIdx::*toString_function_type)( ) const; toString_function_type toString_function_value( &::SireFF::FFIdx::toString ); FFIdx_exposer.def( "toString" , toString_function_value , "" ); } { //::SireFF::FFIdx::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireFF::FFIdx::typeName ); FFIdx_exposer.def( "typeName" , typeName_function_value , "" ); } { //::SireFF::FFIdx::what typedef char const * ( ::SireFF::FFIdx::*what_function_type)( ) const; what_function_type what_function_value( &::SireFF::FFIdx::what ); FFIdx_exposer.def( "what" , what_function_value , "" ); } FFIdx_exposer.staticmethod( "null" ); FFIdx_exposer.staticmethod( "typeName" ); FFIdx_exposer.def( "__copy__", &__copy__); FFIdx_exposer.def( "__deepcopy__", &__copy__); FFIdx_exposer.def( "clone", &__copy__); FFIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::FFIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FFIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::FFIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); FFIdx_exposer.def( "__str__", &__str__< ::SireFF::FFIdx > ); FFIdx_exposer.def( "__repr__", &__str__< ::SireFF::FFIdx > ); FFIdx_exposer.def( "__hash__", &::SireFF::FFIdx::hash ); } }
void register_Sampler_class(){ { //::SireMove::Sampler typedef bp::class_< SireMove::Sampler, bp::bases< SireBase::Property >, boost::noncopyable > Sampler_exposer_t; Sampler_exposer_t Sampler_exposer = Sampler_exposer_t( "Sampler", bp::no_init ); bp::scope Sampler_scope( Sampler_exposer ); { //::SireMove::Sampler::generator typedef ::SireMaths::RanGenerator const & ( ::SireMove::Sampler::*generator_function_type )( ) const; generator_function_type generator_function_value( &::SireMove::Sampler::generator ); Sampler_exposer.def( "generator" , generator_function_value , bp::return_value_policy< bp::copy_const_reference >() ); } { //::SireMove::Sampler::group typedef ::SireMol::MoleculeGroup const & ( ::SireMove::Sampler::*group_function_type )( ) const; group_function_type group_function_value( &::SireMove::Sampler::group ); Sampler_exposer.def( "group" , group_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMove::Sampler::isBiased typedef bool ( ::SireMove::Sampler::*isBiased_function_type )( ) const; isBiased_function_type isBiased_function_value( &::SireMove::Sampler::isBiased ); Sampler_exposer.def( "isBiased" , isBiased_function_value ); } { //::SireMove::Sampler::null typedef ::SireMove::UniformSampler const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMove::Sampler::null ); Sampler_exposer.def( "null" , null_function_value , bp::return_value_policy<bp::clone_const_reference>() ); } { //::SireMove::Sampler::probabilityOf typedef double ( ::SireMove::Sampler::*probabilityOf_function_type )( ::SireMol::PartialMolecule const & ) const; probabilityOf_function_type probabilityOf_function_value( &::SireMove::Sampler::probabilityOf ); Sampler_exposer.def( "probabilityOf" , probabilityOf_function_value , ( bp::arg("molecule") ) ); } { //::SireMove::Sampler::probabilityOfMolecule typedef double ( ::SireMove::Sampler::*probabilityOfMolecule_function_type )( ::SireMol::Molecule const & ) const; probabilityOfMolecule_function_type probabilityOfMolecule_function_value( &::SireMove::Sampler::probabilityOfMolecule ); Sampler_exposer.def( "probabilityOfMolecule" , probabilityOfMolecule_function_value , ( bp::arg("molecule") ) ); } { //::SireMove::Sampler::sample typedef ::boost::tuples::tuple< SireMol::PartialMolecule, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMove::Sampler::*sample_function_type )( ) const; sample_function_type sample_function_value( &::SireMove::Sampler::sample ); Sampler_exposer.def( "sample" , sample_function_value ); } { //::SireMove::Sampler::sampleMolecule typedef ::boost::tuples::tuple< SireMol::Molecule, double, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMove::Sampler::*sampleMolecule_function_type )( ) const; sampleMolecule_function_type sampleMolecule_function_value( &::SireMove::Sampler::sampleMolecule ); Sampler_exposer.def( "sampleMolecule" , sampleMolecule_function_value ); } { //::SireMove::Sampler::setGenerator typedef void ( ::SireMove::Sampler::*setGenerator_function_type )( ::SireMaths::RanGenerator const & ) ; setGenerator_function_type setGenerator_function_value( &::SireMove::Sampler::setGenerator ); Sampler_exposer.def( "setGenerator" , setGenerator_function_value , ( bp::arg("generator") ) ); } { //::SireMove::Sampler::setGroup typedef void ( ::SireMove::Sampler::*setGroup_function_type )( ::SireMol::MoleculeGroup const & ) ; setGroup_function_type setGroup_function_value( &::SireMove::Sampler::setGroup ); Sampler_exposer.def( "setGroup" , setGroup_function_value , ( bp::arg("molgroup") ) ); } { //::SireMove::Sampler::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMove::Sampler::typeName ); Sampler_exposer.def( "typeName" , typeName_function_value ); } { //::SireMove::Sampler::updateFrom typedef void ( ::SireMove::Sampler::*updateFrom_function_type )( ::SireSystem::System const & ) ; updateFrom_function_type updateFrom_function_value( &::SireMove::Sampler::updateFrom ); Sampler_exposer.def( "updateFrom" , updateFrom_function_value , ( bp::arg("system") ) ); } Sampler_exposer.staticmethod( "null" ); Sampler_exposer.staticmethod( "typeName" ); Sampler_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Sampler >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Sampler_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Sampler >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Sampler_exposer.def( "__str__", &__str__< ::SireMove::Sampler > ); Sampler_exposer.def( "__repr__", &__str__< ::SireMove::Sampler > ); } }
void register_CuttingFunction_class(){ { //::SireMol::CuttingFunction typedef bp::class_< SireMol::CuttingFunction, bp::bases< SireBase::Property >, boost::noncopyable > CuttingFunction_exposer_t; CuttingFunction_exposer_t CuttingFunction_exposer = CuttingFunction_exposer_t( "CuttingFunction", "This is the base class of all cutting functions. These are\nfunctions that divide a molecule up into CutGroups.\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope CuttingFunction_scope( CuttingFunction_exposer ); { //::SireMol::CuttingFunction::null typedef ::SireMol::ResidueCutting const & ( *null_function_type )( ); null_function_type null_function_value( &::SireMol::CuttingFunction::null ); CuttingFunction_exposer.def( "null" , null_function_value , bp::return_value_policy< bp::copy_const_reference >() , "" ); } { //::SireMol::CuttingFunction::operator() typedef ::SireMol::Molecule ( ::SireMol::CuttingFunction::*__call___function_type)( ::SireMol::Molecule const & ) const; __call___function_type __call___function_value( &::SireMol::CuttingFunction::operator() ); CuttingFunction_exposer.def( "__call__" , __call___function_value , ( bp::arg("molecule") ) , "" ); } { //::SireMol::CuttingFunction::operator() typedef ::SireMol::MolStructureEditor ( ::SireMol::CuttingFunction::*__call___function_type)( ::SireMol::MolStructureEditor & ) const; __call___function_type __call___function_value( &::SireMol::CuttingFunction::operator() ); CuttingFunction_exposer.def( "__call__" , __call___function_value , ( bp::arg("moleditor") ) , "" ); } { //::SireMol::CuttingFunction::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::CuttingFunction::typeName ); CuttingFunction_exposer.def( "typeName" , typeName_function_value , "" ); } CuttingFunction_exposer.staticmethod( "null" ); CuttingFunction_exposer.staticmethod( "typeName" ); CuttingFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CuttingFunction >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CuttingFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CuttingFunction >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); CuttingFunction_exposer.def( "__str__", &__str__< ::SireMol::CuttingFunction > ); CuttingFunction_exposer.def( "__repr__", &__str__< ::SireMol::CuttingFunction > ); } }
void register_Number_class(){ { //::SireID::Number typedef bp::class_< SireID::Number, boost::noncopyable > Number_exposer_t; Number_exposer_t Number_exposer = Number_exposer_t( "Number", "This is the base class of all Number ID objects. A Number\nis used to provide an object with an identifying number.\nThis could be the number of a residue in a molecule, a\nuser-supplied number of a CutGroup in a molecule, or\nperhaps the automatic unique ID numbers of molecules,\nforcefields or molecule groups that are assigned by the\nprogram. The key point of a Number is to provide an ID\nthat can be queried and compared rapidly, and that\ndoes not change as the object is moved between different\ncontainers. Generally an object should keep its number\nthroughout its lifetime.\n\nAuthor: Christopher Woods\n", bp::no_init ); bp::scope Number_scope( Number_exposer ); { //::SireID::Number::hash typedef ::uint ( ::SireID::Number::*hash_function_type)( ) const; hash_function_type hash_function_value( &::SireID::Number::hash ); Number_exposer.def( "hash" , hash_function_value , "" ); } { //::SireID::Number::isNull typedef bool ( ::SireID::Number::*isNull_function_type)( ) const; isNull_function_type isNull_function_value( &::SireID::Number::isNull ); Number_exposer.def( "isNull" , isNull_function_value , "" ); } { //::SireID::Number::null typedef ::qint32 ( *null_function_type )( ); null_function_type null_function_value( &::SireID::Number::null ); Number_exposer.def( "null" , null_function_value , "" ); } { //::SireID::Number::value typedef ::qint32 ( ::SireID::Number::*value_function_type)( ) const; value_function_type value_function_value( &::SireID::Number::value ); Number_exposer.def( "value" , value_function_value , "" ); } Number_exposer.staticmethod( "null" ); Number_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Number >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); Number_exposer.def( "__str__", &pvt_get_name); Number_exposer.def( "__repr__", &pvt_get_name); Number_exposer.def( "__hash__", &::SireID::Number::hash ); } }
void register_ChainIdx_class(){ { //::SireMol::ChainIdx typedef bp::class_< SireMol::ChainIdx, bp::bases< SireMol::ChainID, SireID::ID, SireID::IndexBase > > ChainIdx_exposer_t; ChainIdx_exposer_t ChainIdx_exposer = ChainIdx_exposer_t( "ChainIdx", bp::init< >() ); bp::scope ChainIdx_scope( ChainIdx_exposer ); ChainIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") )) ); ChainIdx_exposer.def( bp::init< SireMol::ChainIdx const & >(( bp::arg("other") )) ); { //::SireMol::ChainIdx::hash typedef ::uint ( ::SireMol::ChainIdx::*hash_function_type )( ) const; hash_function_type hash_function_value( &::SireMol::ChainIdx::hash ); ChainIdx_exposer.def( "hash" , hash_function_value ); } { //::SireMol::ChainIdx::isNull typedef bool ( ::SireMol::ChainIdx::*isNull_function_type )( ) const; isNull_function_type isNull_function_value( &::SireMol::ChainIdx::isNull ); ChainIdx_exposer.def( "isNull" , isNull_function_value ); } { //::SireMol::ChainIdx::map typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainIdx::*map_function_type )( ::SireMol::MolInfo const & ) const; map_function_type map_function_value( &::SireMol::ChainIdx::map ); ChainIdx_exposer.def( "map" , map_function_value , ( bp::arg("molinfo") ) ); } { //::SireMol::ChainIdx::null typedef ::SireMol::ChainIdx ( *null_function_type )( ); null_function_type null_function_value( &::SireMol::ChainIdx::null ); ChainIdx_exposer.def( "null" , null_function_value ); } { //::SireMol::ChainIdx::operator= typedef ::SireMol::ChainIdx & ( ::SireMol::ChainIdx::*assign_function_type )( ::SireMol::ChainIdx const & ) ; assign_function_type assign_function_value( &::SireMol::ChainIdx::operator= ); ChainIdx_exposer.def( "assign" , assign_function_value , ( bp::arg("other") ) , bp::return_self< >() ); } { //::SireMol::ChainIdx::toString typedef ::QString ( ::SireMol::ChainIdx::*toString_function_type )( ) const; toString_function_type toString_function_value( &::SireMol::ChainIdx::toString ); ChainIdx_exposer.def( "toString" , toString_function_value ); } { //::SireMol::ChainIdx::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireMol::ChainIdx::typeName ); ChainIdx_exposer.def( "typeName" , typeName_function_value ); } { //::SireMol::ChainIdx::what typedef char const * ( ::SireMol::ChainIdx::*what_function_type )( ) const; what_function_type what_function_value( &::SireMol::ChainIdx::what ); ChainIdx_exposer.def( "what" , what_function_value ); } ChainIdx_exposer.staticmethod( "null" ); ChainIdx_exposer.staticmethod( "typeName" ); ChainIdx_exposer.def( "__copy__", &__copy__); ChainIdx_exposer.def( "__deepcopy__", &__copy__); ChainIdx_exposer.def( "clone", &__copy__); ChainIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainIdx >, bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() ); ChainIdx_exposer.def( "__str__", &__str__< ::SireMol::ChainIdx > ); ChainIdx_exposer.def( "__repr__", &__str__< ::SireMol::ChainIdx > ); } }
void register_IOBase_class(){ { //::SireIO::IOBase typedef bp::class_< SireIO::IOBase, bp::bases< SireBase::Property >, boost::noncopyable > IOBase_exposer_t; IOBase_exposer_t IOBase_exposer = IOBase_exposer_t( "IOBase", bp::no_init ); bp::scope IOBase_scope( IOBase_exposer ); { //::SireIO::IOBase::null typedef ::SireIO::NullIO ( *null_function_type )( ); null_function_type null_function_value( &::SireIO::IOBase::null ); IOBase_exposer.def( "null" , null_function_value ); } { //::SireIO::IOBase::read typedef ::SireMol::MoleculeGroup ( ::SireIO::IOBase::*read_function_type )( ::QString const &,::SireBase::PropertyMap const & ) const; read_function_type read_function_value( &::SireIO::IOBase::read ); IOBase_exposer.def( "read" , read_function_value , ( bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::read typedef ::SireMol::MoleculeGroup ( ::SireIO::IOBase::*read_function_type )( char const *,::SireBase::PropertyMap const & ) const; read_function_type read_function_value( &::SireIO::IOBase::read ); IOBase_exposer.def( "read" , read_function_value , ( bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::read typedef ::SireMol::MoleculeGroup ( ::SireIO::IOBase::*read_function_type )( ::QIODevice &,::SireBase::PropertyMap const & ) const; read_function_type read_function_value( &::SireIO::IOBase::read ); IOBase_exposer.def( "read" , read_function_value , ( bp::arg("dev"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::read typedef ::SireMol::MoleculeGroup ( ::SireIO::IOBase::*read_function_type )( ::QByteArray const &,::SireBase::PropertyMap const & ) const; read_function_type read_function_value( &::SireIO::IOBase::read ); IOBase_exposer.def( "read" , read_function_value , ( bp::arg("data"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::readMolecule typedef ::SireMol::Molecule ( ::SireIO::IOBase::*readMolecule_function_type )( ::QString const &,::SireBase::PropertyMap const & ) const; readMolecule_function_type readMolecule_function_value( &::SireIO::IOBase::readMolecule ); IOBase_exposer.def( "readMolecule" , readMolecule_function_value , ( bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::readMolecule typedef ::SireMol::Molecule ( ::SireIO::IOBase::*readMolecule_function_type )( char const *,::SireBase::PropertyMap const & ) const; readMolecule_function_type readMolecule_function_value( &::SireIO::IOBase::readMolecule ); IOBase_exposer.def( "readMolecule" , readMolecule_function_value , ( bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::readMolecule typedef ::SireMol::Molecule ( ::SireIO::IOBase::*readMolecule_function_type )( ::QIODevice &,::SireBase::PropertyMap const & ) const; readMolecule_function_type readMolecule_function_value( &::SireIO::IOBase::readMolecule ); IOBase_exposer.def( "readMolecule" , readMolecule_function_value , ( bp::arg("dev"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::readMolecule typedef ::SireMol::Molecule ( ::SireIO::IOBase::*readMolecule_function_type )( ::QByteArray const &,::SireBase::PropertyMap const & ) const; readMolecule_function_type readMolecule_function_value( &::SireIO::IOBase::readMolecule ); IOBase_exposer.def( "readMolecule" , readMolecule_function_value , ( bp::arg("data"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::typeName typedef char const * ( *typeName_function_type )( ); typeName_function_type typeName_function_value( &::SireIO::IOBase::typeName ); IOBase_exposer.def( "typeName" , typeName_function_value ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeGroup const &,::QString const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::Molecules const &,::QString const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeView const &,::QString const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecule"), bp::arg("filename"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeGroup const &,::QIODevice &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("dev"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::Molecules const &,::QIODevice &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("dev"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef void ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeView const &,::QIODevice &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecule"), bp::arg("dev"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef ::QByteArray ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef ::QByteArray ( ::SireIO::IOBase::*write_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) ); } { //::SireIO::IOBase::write typedef ::QByteArray ( ::SireIO::IOBase::*write_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const; write_function_type write_function_value( &::SireIO::IOBase::write ); IOBase_exposer.def( "write" , write_function_value , ( bp::arg("molecule"), bp::arg("map")=SireBase::PropertyMap() ) ); } IOBase_exposer.staticmethod( "null" ); IOBase_exposer.staticmethod( "typeName" ); IOBase_exposer.def( "__str__", &__str__< ::SireIO::IOBase > ); IOBase_exposer.def( "__repr__", &__str__< ::SireIO::IOBase > ); } }