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