void register_Ensemble_class(){
{ //::SireMove::Ensemble
typedef bp::class_< SireMove::Ensemble, bp::bases< SireBase::Property > > Ensemble_exposer_t;
Ensemble_exposer_t Ensemble_exposer = Ensemble_exposer_t( "Ensemble", "This class describes the ensemble that will be created by\na collection of moves (e.g. will the moves sample at constant\nvolume or temperature?)\n\nAuthor: Christopher Woods\n", bp::init< >("Construct an NVE ensemble") );
bp::scope Ensemble_scope( Ensemble_exposer );
Ensemble_exposer.def( bp::init< SireMove::Ensemble const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Return the MuVT ensemble for the temperature temperature and\nthe fugacity fugacity" );
}
{ //::SireMove::Ensemble::MuVT
typedef ::SireMove::Ensemble ( *MuVT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
MuVT_function_type MuVT_function_value( &::SireMove::Ensemble::MuVT );
Ensemble_exposer.def(
"MuVT"
, MuVT_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Return the MuVT ensemble for the temperature temperature and\nthe chemical potential chemical_potential" );
}
{ //::SireMove::Ensemble::NPT
typedef ::SireMove::Ensemble ( *NPT_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
NPT_function_type NPT_function_value( &::SireMove::Ensemble::NPT );
Ensemble_exposer.def(
"NPT"
, NPT_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Return the NPT ensemble for the temperature temperature and\nthe pressure pressure" );
}
{ //::SireMove::Ensemble::NVE
typedef ::SireMove::Ensemble ( *NVE_function_type )( );
NVE_function_type NVE_function_value( &::SireMove::Ensemble::NVE );
Ensemble_exposer.def(
"NVE"
, NVE_function_value
, "Return the NVE ensemble" );
}
{ //::SireMove::Ensemble::NVT
typedef ::SireMove::Ensemble ( *NVT_function_type )( ::SireUnits::Dimension::Temperature const & );
NVT_function_type NVT_function_value( &::SireMove::Ensemble::NVT );
Ensemble_exposer.def(
"NVT"
, NVT_function_value
, ( bp::arg("temperature") )
, "Return the NVT ensemble for the temperature temperature" );
}
{ //::SireMove::Ensemble::canonical
typedef ::SireMove::Ensemble ( *canonical_function_type )( ::SireUnits::Dimension::Temperature const & );
canonical_function_type canonical_function_value( &::SireMove::Ensemble::canonical );
Ensemble_exposer.def(
"canonical"
, canonical_function_value
, ( bp::arg("temperature") )
, "Syntactic sugar to return the NVT ensemble" );
}
{ //::SireMove::Ensemble::chemicalPotential
typedef ::SireUnits::Dimension::MolarEnergy ( ::SireMove::Ensemble::*chemicalPotential_function_type)( ) const;
chemicalPotential_function_type chemicalPotential_function_value( &::SireMove::Ensemble::chemicalPotential );
Ensemble_exposer.def(
"chemicalPotential"
, chemicalPotential_function_value
, "Return the chemical potential of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::fugacity
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*fugacity_function_type)( ) const;
fugacity_function_type fugacity_function_value( &::SireMove::Ensemble::fugacity );
Ensemble_exposer.def(
"fugacity"
, fugacity_function_value
, "Return the fugacity of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("fugacity") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::grandCanonical
typedef ::SireMove::Ensemble ( *grandCanonical_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::MolarEnergy const & );
grandCanonical_function_type grandCanonical_function_value( &::SireMove::Ensemble::grandCanonical );
Ensemble_exposer.def(
"grandCanonical"
, grandCanonical_function_value
, ( bp::arg("temperature"), bp::arg("chemical_potential") )
, "Syntactic sugar to return the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isCanonical
typedef bool ( ::SireMove::Ensemble::*isCanonical_function_type)( ) const;
isCanonical_function_type isCanonical_function_value( &::SireMove::Ensemble::isCanonical );
Ensemble_exposer.def(
"isCanonical"
, isCanonical_function_value
, "Return whether or not this is the canonical (NVT) ensemble" );
}
{ //::SireMove::Ensemble::isConstantChemicalPotential
typedef bool ( ::SireMove::Ensemble::*isConstantChemicalPotential_function_type)( ) const;
isConstantChemicalPotential_function_type isConstantChemicalPotential_function_value( &::SireMove::Ensemble::isConstantChemicalPotential );
Ensemble_exposer.def(
"isConstantChemicalPotential"
, isConstantChemicalPotential_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantEnergy
typedef bool ( ::SireMove::Ensemble::*isConstantEnergy_function_type)( ) const;
isConstantEnergy_function_type isConstantEnergy_function_value( &::SireMove::Ensemble::isConstantEnergy );
Ensemble_exposer.def(
"isConstantEnergy"
, isConstantEnergy_function_value
, "Return whether or not energy is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantFugacity
typedef bool ( ::SireMove::Ensemble::*isConstantFugacity_function_type)( ) const;
isConstantFugacity_function_type isConstantFugacity_function_value( &::SireMove::Ensemble::isConstantFugacity );
Ensemble_exposer.def(
"isConstantFugacity"
, isConstantFugacity_function_value
, "Return whether the chemical potential is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantNParticles
typedef bool ( ::SireMove::Ensemble::*isConstantNParticles_function_type)( ) const;
isConstantNParticles_function_type isConstantNParticles_function_value( &::SireMove::Ensemble::isConstantNParticles );
Ensemble_exposer.def(
"isConstantNParticles"
, isConstantNParticles_function_value
, "Return whether or not the number of particles is constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantPressure
typedef bool ( ::SireMove::Ensemble::*isConstantPressure_function_type)( ) const;
isConstantPressure_function_type isConstantPressure_function_value( &::SireMove::Ensemble::isConstantPressure );
Ensemble_exposer.def(
"isConstantPressure"
, isConstantPressure_function_value
, "Return whether or not pressure is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantTemperature
typedef bool ( ::SireMove::Ensemble::*isConstantTemperature_function_type)( ) const;
isConstantTemperature_function_type isConstantTemperature_function_value( &::SireMove::Ensemble::isConstantTemperature );
Ensemble_exposer.def(
"isConstantTemperature"
, isConstantTemperature_function_value
, "Return whether or not temperature is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isConstantVolume
typedef bool ( ::SireMove::Ensemble::*isConstantVolume_function_type)( ) const;
isConstantVolume_function_type isConstantVolume_function_value( &::SireMove::Ensemble::isConstantVolume );
Ensemble_exposer.def(
"isConstantVolume"
, isConstantVolume_function_value
, "Return whether or not volume is a constant in this ensemble" );
}
{ //::SireMove::Ensemble::isGrandCanonical
typedef bool ( ::SireMove::Ensemble::*isGrandCanonical_function_type)( ) const;
isGrandCanonical_function_type isGrandCanonical_function_value( &::SireMove::Ensemble::isGrandCanonical );
Ensemble_exposer.def(
"isGrandCanonical"
, isGrandCanonical_function_value
, "Return whether or not this is the grand canonical (MuVT) ensemble" );
}
{ //::SireMove::Ensemble::isIsothermalIsobaric
typedef bool ( ::SireMove::Ensemble::*isIsothermalIsobaric_function_type)( ) const;
isIsothermalIsobaric_function_type isIsothermalIsobaric_function_value( &::SireMove::Ensemble::isIsothermalIsobaric );
Ensemble_exposer.def(
"isIsothermalIsobaric"
, isIsothermalIsobaric_function_value
, "Return whether or not this is the isothermal-isobaric (NPT) ensemble" );
}
{ //::SireMove::Ensemble::isMicroCanonical
typedef bool ( ::SireMove::Ensemble::*isMicroCanonical_function_type)( ) const;
isMicroCanonical_function_type isMicroCanonical_function_value( &::SireMove::Ensemble::isMicroCanonical );
Ensemble_exposer.def(
"isMicroCanonical"
, isMicroCanonical_function_value
, "Return whether or not this is the microcanonical (NVE) ensemble" );
}
{ //::SireMove::Ensemble::isMuVT
typedef bool ( ::SireMove::Ensemble::*isMuVT_function_type)( ) const;
isMuVT_function_type isMuVT_function_value( &::SireMove::Ensemble::isMuVT );
Ensemble_exposer.def(
"isMuVT"
, isMuVT_function_value
, "Return whether or not this is the MuVT ensemble" );
}
{ //::SireMove::Ensemble::isNPT
typedef bool ( ::SireMove::Ensemble::*isNPT_function_type)( ) const;
isNPT_function_type isNPT_function_value( &::SireMove::Ensemble::isNPT );
Ensemble_exposer.def(
"isNPT"
, isNPT_function_value
, "Return whether or not this is the NPT ensemble" );
}
{ //::SireMove::Ensemble::isNVE
typedef bool ( ::SireMove::Ensemble::*isNVE_function_type)( ) const;
isNVE_function_type isNVE_function_value( &::SireMove::Ensemble::isNVE );
Ensemble_exposer.def(
"isNVE"
, isNVE_function_value
, "Return whether or not this is the NVE ensemble" );
}
{ //::SireMove::Ensemble::isNVT
typedef bool ( ::SireMove::Ensemble::*isNVT_function_type)( ) const;
isNVT_function_type isNVT_function_value( &::SireMove::Ensemble::isNVT );
Ensemble_exposer.def(
"isNVT"
, isNVT_function_value
, "Return whether or not this is the NVT ensemble" );
}
{ //::SireMove::Ensemble::isothermalIsobaric
typedef ::SireMove::Ensemble ( *isothermalIsobaric_function_type )( ::SireUnits::Dimension::Temperature const &,::SireUnits::Dimension::Pressure const & );
isothermalIsobaric_function_type isothermalIsobaric_function_value( &::SireMove::Ensemble::isothermalIsobaric );
Ensemble_exposer.def(
"isothermalIsobaric"
, isothermalIsobaric_function_value
, ( bp::arg("temperature"), bp::arg("pressure") )
, "Syntactic sugar to return the NPT ensemble" );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( ::SireMove::Ensemble::*merge_function_type)( ::SireMove::Ensemble const & ) const;
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("other") )
, "Merge this ensemble with other. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::merge
typedef ::SireMove::Ensemble ( *merge_function_type )( ::SireMove::Ensemble const &,::SireMove::Ensemble const & );
merge_function_type merge_function_value( &::SireMove::Ensemble::merge );
Ensemble_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("e0"), bp::arg("e1") )
, "Merge the two ensembles e0 and e1 together. This tries to find an ensemble\nthat satisfies both, e.g. merging NVE with NVT will give NVT,\nwhile merging NVE with NPT would give NPT." );
}
{ //::SireMove::Ensemble::microcanonical
typedef ::SireMove::Ensemble ( *microcanonical_function_type )( );
microcanonical_function_type microcanonical_function_value( &::SireMove::Ensemble::microcanonical );
Ensemble_exposer.def(
"microcanonical"
, microcanonical_function_value
, "Syntactic sugar to return the NVE ensemble" );
}
{ //::SireMove::Ensemble::name
typedef ::QString ( ::SireMove::Ensemble::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMove::Ensemble::name );
Ensemble_exposer.def(
"name"
, name_function_value
, "Return the name of this ensemble (if it has a name)" );
}
Ensemble_exposer.def( bp::self != bp::self );
{ //::SireMove::Ensemble::operator=
typedef ::SireMove::Ensemble & ( ::SireMove::Ensemble::*assign_function_type)( ::SireMove::Ensemble const & ) ;
assign_function_type assign_function_value( &::SireMove::Ensemble::operator= );
Ensemble_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
Ensemble_exposer.def( bp::self == bp::self );
{ //::SireMove::Ensemble::pressure
typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*pressure_function_type)( ) const;
pressure_function_type pressure_function_value( &::SireMove::Ensemble::pressure );
Ensemble_exposer.def(
"pressure"
, pressure_function_value
, "Return the pressure of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::shortHand
typedef ::QString ( ::SireMove::Ensemble::*shortHand_function_type)( ) const;
shortHand_function_type shortHand_function_value( &::SireMove::Ensemble::shortHand );
Ensemble_exposer.def(
"shortHand"
, shortHand_function_value
, "Return the shorthand string for this ensemble (e.g. NVT)" );
}
{ //::SireMove::Ensemble::temperature
typedef ::SireUnits::Dimension::Temperature ( ::SireMove::Ensemble::*temperature_function_type)( ) const;
temperature_function_type temperature_function_value( &::SireMove::Ensemble::temperature );
Ensemble_exposer.def(
"temperature"
, temperature_function_value
, "Return the temperature of this ensemble\nThrow: SireError::incompatible_error\n" );
}
{ //::SireMove::Ensemble::toString
typedef ::QString ( ::SireMove::Ensemble::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMove::Ensemble::toString );
Ensemble_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this ensemble" );
}
{ //::SireMove::Ensemble::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMove::Ensemble::typeName );
Ensemble_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
Ensemble_exposer.staticmethod( "MuVT" );
Ensemble_exposer.staticmethod( "NPT" );
Ensemble_exposer.staticmethod( "NVE" );
Ensemble_exposer.staticmethod( "NVT" );
Ensemble_exposer.staticmethod( "canonical" );
Ensemble_exposer.staticmethod( "grandCanonical" );
Ensemble_exposer.staticmethod( "isothermalIsobaric" );
Ensemble_exposer.staticmethod( "merge" );
Ensemble_exposer.staticmethod( "microcanonical" );
Ensemble_exposer.staticmethod( "typeName" );
Ensemble_exposer.def( "__copy__", &__copy__);
Ensemble_exposer.def( "__deepcopy__", &__copy__);
Ensemble_exposer.def( "clone", &__copy__);
Ensemble_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Ensemble >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Ensemble_exposer.def( "__str__", &__str__< ::SireMove::Ensemble > );
Ensemble_exposer.def( "__repr__", &__str__< ::SireMove::Ensemble > );
}
}
void register_PartialMolecule_class(){
{ //::SireMol::PartialMolecule
typedef bp::class_< SireMol::PartialMolecule, bp::bases< SireMol::MoleculeView, SireBase::Property > > PartialMolecule_exposer_t;
PartialMolecule_exposer_t PartialMolecule_exposer = PartialMolecule_exposer_t( "PartialMolecule", bp::init< >() );
bp::scope PartialMolecule_scope( PartialMolecule_exposer );
PartialMolecule_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
PartialMolecule_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::AtomSelection const & >(( bp::arg("moldata"), bp::arg("atoms") )) );
PartialMolecule_exposer.def( bp::init< SireMol::PartialMolecule const & >(( bp::arg("other") )) );
{ //::SireMol::PartialMolecule::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::PartialMolecule::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::PartialMolecule::evaluate );
PartialMolecule_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::PartialMolecule::extract
typedef ::SireMol::PartialMolecule ( ::SireMol::PartialMolecule::*extract_function_type )( ) const;
extract_function_type extract_function_value( &::SireMol::PartialMolecule::extract );
PartialMolecule_exposer.def(
"extract"
, extract_function_value );
}
{ //::SireMol::PartialMolecule::hasMetadata
typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
PartialMolecule_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::PartialMolecule::hasMetadata
typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
PartialMolecule_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::PartialMolecule::hasProperty
typedef bool ( ::SireMol::PartialMolecule::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::PartialMolecule::hasProperty );
PartialMolecule_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::PartialMolecule::isEmpty
typedef bool ( ::SireMol::PartialMolecule::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::PartialMolecule::isEmpty );
PartialMolecule_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::PartialMolecule::metadata
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const & ) const;
metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
PartialMolecule_exposer.def(
"metadata"
, metadata_function_value
, ( bp::arg("metakey") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::metadata
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
PartialMolecule_exposer.def(
"metadata"
, metadata_function_value
, ( bp::arg("key"), bp::arg("metakey") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::metadataKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
PartialMolecule_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::PartialMolecule::metadataKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
PartialMolecule_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::PartialMolecule::move
typedef ::SireMol::Mover< SireMol::PartialMolecule > ( ::SireMol::PartialMolecule::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::PartialMolecule::move );
PartialMolecule_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::PartialMolecule::nAtoms
typedef int ( ::SireMol::PartialMolecule::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::PartialMolecule::nAtoms );
PartialMolecule_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::PartialMolecule::nChains
typedef int ( ::SireMol::PartialMolecule::*nChains_function_type )( ) const;
nChains_function_type nChains_function_value( &::SireMol::PartialMolecule::nChains );
PartialMolecule_exposer.def(
"nChains"
, nChains_function_value );
}
{ //::SireMol::PartialMolecule::nCutGroups
typedef int ( ::SireMol::PartialMolecule::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::PartialMolecule::nCutGroups );
PartialMolecule_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
{ //::SireMol::PartialMolecule::nResidues
typedef int ( ::SireMol::PartialMolecule::*nResidues_function_type )( ) const;
nResidues_function_type nResidues_function_value( &::SireMol::PartialMolecule::nResidues );
PartialMolecule_exposer.def(
"nResidues"
, nResidues_function_value );
}
{ //::SireMol::PartialMolecule::nSegments
typedef int ( ::SireMol::PartialMolecule::*nSegments_function_type )( ) const;
nSegments_function_type nSegments_function_value( &::SireMol::PartialMolecule::nSegments );
PartialMolecule_exposer.def(
"nSegments"
, nSegments_function_value );
}
{ //::SireMol::PartialMolecule::name
typedef ::SireMol::MolName const & ( ::SireMol::PartialMolecule::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::PartialMolecule::name );
PartialMolecule_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::number
typedef ::SireMol::MolNum ( ::SireMol::PartialMolecule::*number_function_type )( ) const;
number_function_type number_function_value( &::SireMol::PartialMolecule::number );
PartialMolecule_exposer.def(
"number"
, number_function_value );
}
PartialMolecule_exposer.def( bp::self != bp::self );
{ //::SireMol::PartialMolecule::operator=
typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::MoleculeView const & ) ;
assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
PartialMolecule_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::PartialMolecule::operator=
typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::PartialMolecule const & ) ;
assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
PartialMolecule_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PartialMolecule_exposer.def( bp::self == bp::self );
{ //::SireMol::PartialMolecule::property
typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*property_function_type )( ::SireBase::PropertyName const & ) const;
property_function_type property_function_value( &::SireMol::PartialMolecule::property );
PartialMolecule_exposer.def(
"property"
, property_function_value
, ( bp::arg("key") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireMol::PartialMolecule::propertyKeys
typedef ::QStringList ( ::SireMol::PartialMolecule::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::PartialMolecule::propertyKeys );
PartialMolecule_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::PartialMolecule::selectedAll
typedef bool ( ::SireMol::PartialMolecule::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::PartialMolecule::selectedAll );
PartialMolecule_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::PartialMolecule::selection
typedef ::SireMol::AtomSelection ( ::SireMol::PartialMolecule::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::PartialMolecule::selection );
PartialMolecule_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::PartialMolecule::toString
typedef ::QString ( ::SireMol::PartialMolecule::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::PartialMolecule::toString );
PartialMolecule_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::PartialMolecule::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::PartialMolecule::typeName );
PartialMolecule_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::PartialMolecule::version
typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ) const;
version_function_type version_function_value( &::SireMol::PartialMolecule::version );
PartialMolecule_exposer.def(
"version"
, version_function_value );
}
{ //::SireMol::PartialMolecule::version
typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ::SireBase::PropertyName const & ) const;
version_function_type version_function_value( &::SireMol::PartialMolecule::version );
PartialMolecule_exposer.def(
"version"
, version_function_value
, ( bp::arg("key") ) );
}
PartialMolecule_exposer.staticmethod( "typeName" );
PartialMolecule_exposer.def( "__copy__", &__copy__);
PartialMolecule_exposer.def( "__deepcopy__", &__copy__);
PartialMolecule_exposer.def( "clone", &__copy__);
PartialMolecule_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::PartialMolecule >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PartialMolecule_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::PartialMolecule >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PartialMolecule_exposer.def( "__str__", &__str__< ::SireMol::PartialMolecule > );
PartialMolecule_exposer.def( "__repr__", &__str__< ::SireMol::PartialMolecule > );
}
}
void register_Segment_class(){
{ //::SireMol::Segment
typedef bp::class_< SireMol::Segment, bp::bases< SireMol::MoleculeView, SireBase::Property > > Segment_exposer_t;
Segment_exposer_t Segment_exposer = Segment_exposer_t( "Segment", bp::init< >() );
bp::scope Segment_scope( Segment_exposer );
Segment_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::SegID const & >(( bp::arg("data"), bp::arg("segid") )) );
Segment_exposer.def( bp::init< SireMol::Segment const & >(( bp::arg("other") )) );
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsMetadata
typedef void ( ::SireMol::Segment::*assertContainsMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
assertContainsMetadata_function_type assertContainsMetadata_function_value( &::SireMol::Segment::assertContainsMetadata );
Segment_exposer.def(
"assertContainsMetadata"
, assertContainsMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::assertContainsProperty
typedef void ( ::SireMol::Segment::*assertContainsProperty_function_type )( ::SireBase::PropertyName const & ) const;
assertContainsProperty_function_type assertContainsProperty_function_value( &::SireMol::Segment::assertContainsProperty );
Segment_exposer.def(
"assertContainsProperty"
, assertContainsProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::atomIdxs
typedef ::QList< SireMol::AtomIdx > const & ( ::SireMol::Segment::*atomIdxs_function_type )( ) const;
atomIdxs_function_type atomIdxs_function_value( &::SireMol::Segment::atomIdxs );
Segment_exposer.def(
"atomIdxs"
, atomIdxs_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomIdx ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomidx") ) );
}
{ //::SireMol::Segment::contains
typedef bool ( ::SireMol::Segment::*contains_function_type )( ::SireMol::AtomID const & ) const;
contains_function_type contains_function_value( &::SireMol::Segment::contains );
Segment_exposer.def(
"contains"
, contains_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::edit
typedef ::SireMol::SegEditor ( ::SireMol::Segment::*edit_function_type )( ) const;
edit_function_type edit_function_value( &::SireMol::Segment::edit );
Segment_exposer.def(
"edit"
, edit_function_value );
}
{ //::SireMol::Segment::evaluate
typedef ::SireMol::Evaluator ( ::SireMol::Segment::*evaluate_function_type )( ) const;
evaluate_function_type evaluate_function_value( &::SireMol::Segment::evaluate );
Segment_exposer.def(
"evaluate"
, evaluate_function_value );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasMetadata
typedef bool ( ::SireMol::Segment::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
hasMetadata_function_type hasMetadata_function_value( &::SireMol::Segment::hasMetadata );
Segment_exposer.def(
"hasMetadata"
, hasMetadata_function_value
, ( bp::arg("key"), bp::arg("metakey") ) );
}
{ //::SireMol::Segment::hasProperty
typedef bool ( ::SireMol::Segment::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
hasProperty_function_type hasProperty_function_value( &::SireMol::Segment::hasProperty );
Segment_exposer.def(
"hasProperty"
, hasProperty_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::index
typedef ::SireMol::SegIdx ( ::SireMol::Segment::*index_function_type )( ) const;
index_function_type index_function_value( &::SireMol::Segment::index );
Segment_exposer.def(
"index"
, index_function_value );
}
{ //::SireMol::Segment::intersects
typedef bool ( ::SireMol::Segment::*intersects_function_type )( ::SireMol::AtomID const & ) const;
intersects_function_type intersects_function_value( &::SireMol::Segment::intersects );
Segment_exposer.def(
"intersects"
, intersects_function_value
, ( bp::arg("atomid") ) );
}
{ //::SireMol::Segment::isEmpty
typedef bool ( ::SireMol::Segment::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::Segment::isEmpty );
Segment_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value );
}
{ //::SireMol::Segment::metadataKeys
typedef ::QStringList ( ::SireMol::Segment::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
metadataKeys_function_type metadataKeys_function_value( &::SireMol::Segment::metadataKeys );
Segment_exposer.def(
"metadataKeys"
, metadataKeys_function_value
, ( bp::arg("key") ) );
}
{ //::SireMol::Segment::move
typedef ::SireMol::Mover< SireMol::Segment > ( ::SireMol::Segment::*move_function_type )( ) const;
move_function_type move_function_value( &::SireMol::Segment::move );
Segment_exposer.def(
"move"
, move_function_value );
}
{ //::SireMol::Segment::nAtoms
typedef int ( ::SireMol::Segment::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::Segment::nAtoms );
Segment_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::Segment::name
typedef ::SireMol::SegName const & ( ::SireMol::Segment::*name_function_type )( ) const;
name_function_type name_function_value( &::SireMol::Segment::name );
Segment_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
Segment_exposer.def( bp::self != bp::self );
{ //::SireMol::Segment::operator=
typedef ::SireMol::Segment & ( ::SireMol::Segment::*assign_function_type )( ::SireMol::Segment const & ) ;
assign_function_type assign_function_value( &::SireMol::Segment::operator= );
Segment_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
Segment_exposer.def( bp::self == bp::self );
{ //::SireMol::Segment::propertyKeys
typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )( ) const;
propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );
Segment_exposer.def(
"propertyKeys"
, propertyKeys_function_value );
}
{ //::SireMol::Segment::selectedAll
typedef bool ( ::SireMol::Segment::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );
Segment_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireMol::Segment::selection
typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )( ) const;
selection_function_type selection_function_value( &::SireMol::Segment::selection );
Segment_exposer.def(
"selection"
, selection_function_value );
}
{ //::SireMol::Segment::selector
typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )( ) const;
selector_function_type selector_function_value( &::SireMol::Segment::selector );
Segment_exposer.def(
"selector"
, selector_function_value );
}
{ //::SireMol::Segment::toString
typedef ::QString ( ::SireMol::Segment::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Segment::toString );
Segment_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Segment::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );
Segment_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireMol::Segment::update
typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;
update_function_type update_function_value( &::SireMol::Segment::update );
Segment_exposer.def(
"update"
, update_function_value
, ( bp::arg("moldata") ) );
}
Segment_exposer.staticmethod( "typeName" );
Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());
Segment_exposer.def( "__copy__", &__copy__);
Segment_exposer.def( "__deepcopy__", &__copy__);
Segment_exposer.def( "clone", &__copy__);
Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );
Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );
}
}
void register_ResStructureEditor_class(){
{ //::SireMol::ResStructureEditor
typedef bp::class_< SireMol::ResStructureEditor > ResStructureEditor_exposer_t;
ResStructureEditor_exposer_t ResStructureEditor_exposer = ResStructureEditor_exposer_t( "ResStructureEditor", "This is the class used to edit a residues structure\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ResStructureEditor_scope( ResStructureEditor_exposer );
ResStructureEditor_exposer.def( bp::init< SireMol::Residue const & >(( bp::arg("residue") ), "Construct an editor to edit the structure of a copy of the\nresidue residue") );
ResStructureEditor_exposer.def( bp::init< SireMol::StructureEditor const &, SireMol::ResIdx >(( bp::arg("data"), bp::arg("residx") ), "Construct an editor to edit the residue at index residx in the\neditor whose data is in data\nThrow: SireError::invalid_index\n") );
ResStructureEditor_exposer.def( bp::init< SireMol::ResStructureEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomName const & ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomname") )
, "Add a new atom called name to this residue - this returns\nan editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomNum ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomnum") )
, "Add a new atom with the number number to this residue - this\nreturns an editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( int ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( ::SireMol::AtomID const & ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::chain
typedef ::SireMol::ChainStructureEditor ( ::SireMol::ResStructureEditor::*chain_function_type)( ) ;
chain_function_type chain_function_value( &::SireMol::ResStructureEditor::chain );
ResStructureEditor_exposer.def(
"chain"
, chain_function_value
, "Return an editor for the chain that contains this residue" );
}
{ //::SireMol::ResStructureEditor::commit
typedef ::SireMol::Residue ( ::SireMol::ResStructureEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::ResStructureEditor::commit );
ResStructureEditor_exposer.def(
"commit"
, commit_function_value
, "Commit the changes made by this editor and return the updated residue" );
}
{ //::SireMol::ResStructureEditor::index
typedef ::SireMol::ResIdx ( ::SireMol::ResStructureEditor::*index_function_type)( ) const;
index_function_type index_function_value( &::SireMol::ResStructureEditor::index );
ResStructureEditor_exposer.def(
"index"
, index_function_value
, "Return the index of this residue in the molecule" );
}
{ //::SireMol::ResStructureEditor::molecule
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*molecule_function_type)( ) ;
molecule_function_type molecule_function_value( &::SireMol::ResStructureEditor::molecule );
ResStructureEditor_exposer.def(
"molecule"
, molecule_function_value
, "Return an editor for the molecule that contains this residue" );
}
{ //::SireMol::ResStructureEditor::nAtoms
typedef int ( ::SireMol::ResStructureEditor::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::ResStructureEditor::nAtoms );
ResStructureEditor_exposer.def(
"nAtoms"
, nAtoms_function_value
, "Return the number of atoms in this residue - this may be zero" );
}
{ //::SireMol::ResStructureEditor::name
typedef ::SireMol::ResName const & ( ::SireMol::ResStructureEditor::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMol::ResStructureEditor::name );
ResStructureEditor_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the name of this residue" );
}
{ //::SireMol::ResStructureEditor::number
typedef ::SireMol::ResNum ( ::SireMol::ResStructureEditor::*number_function_type)( ) const;
number_function_type number_function_value( &::SireMol::ResStructureEditor::number );
ResStructureEditor_exposer.def(
"number"
, number_function_value
, "Return the number of this residue" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::Residue const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("residue") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::ResStructureEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::reindex
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reindex_function_type)( ::SireMol::ResIdx ) ;
reindex_function_type reindex_function_value( &::SireMol::ResStructureEditor::reindex );
ResStructureEditor_exposer.def(
"reindex"
, reindex_function_value
, ( bp::arg("index") )
, bp::return_self< >()
, "Change the index of this residue to newidx. If this\nis larger than the number of residues in the molecule\nthen this residue is moved to the end" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*remove_function_type)( ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, bp::return_self< >()
, "Completely remove this residue from the molecule - this returns\na MolStructureEditor that can be used to further edit the molecule" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( ::SireMol::AtomID const & ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atomid") )
, bp::return_self< >()
, "Remove all atoms with ID atomid from this residue\nThrow: SireMol::missing_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( int ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, bp::return_self< >()
, "Remove the ith atom from this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::rename
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*rename_function_type)( ::SireMol::ResName const & ) ;
rename_function_type rename_function_value( &::SireMol::ResStructureEditor::rename );
ResStructureEditor_exposer.def(
"rename"
, rename_function_value
, ( bp::arg("name") )
, bp::return_self< >()
, "Rename this residue to newname" );
}
{ //::SireMol::ResStructureEditor::renumber
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*renumber_function_type)( ::SireMol::ResNum ) ;
renumber_function_type renumber_function_value( &::SireMol::ResStructureEditor::renumber );
ResStructureEditor_exposer.def(
"renumber"
, renumber_function_value
, ( bp::arg("number") )
, bp::return_self< >()
, "Renumber this residue to newnum" );
}
{ //::SireMol::ResStructureEditor::reparent
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reparent_function_type)( ::SireMol::ChainID const & ) ;
reparent_function_type reparent_function_value( &::SireMol::ResStructureEditor::reparent );
ResStructureEditor_exposer.def(
"reparent"
, reparent_function_value
, ( bp::arg("chainid") )
, bp::return_self< >()
, "Move this residue into the chain with ID chainid\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( int ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( ::SireMol::AtomID const & ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::selectedAll
typedef bool ( ::SireMol::ResStructureEditor::*selectedAll_function_type)( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::ResStructureEditor::selectedAll );
ResStructureEditor_exposer.def(
"selectedAll"
, selectedAll_function_value
, "Is this editor editing the entire molecule?" );
}
{ //::SireMol::ResStructureEditor::toString
typedef ::QString ( ::SireMol::ResStructureEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ResStructureEditor::toString );
ResStructureEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( ::SireMol::AtomID const &,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("atomid"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms that match the ID atomid into the residue that\nmatches the ID resid\nThrow: SireMol::missing_atom\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( int,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("i"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer the ith atom from this residue into the residue that\nmatches the ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transferAll
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transferAll_function_type)( ::SireMol::ResID const & ) ;
transferAll_function_type transferAll_function_value( &::SireMol::ResStructureEditor::transferAll );
ResStructureEditor_exposer.def(
"transferAll"
, transferAll_function_value
, ( bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms from this residue into the residue with ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ResStructureEditor::typeName );
ResStructureEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ResStructureEditor::what
typedef char const * ( ::SireMol::ResStructureEditor::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ResStructureEditor::what );
ResStructureEditor_exposer.def(
"what"
, what_function_value
, "" );
}
ResStructureEditor_exposer.staticmethod( "typeName" );
ResStructureEditor_exposer.def( "__copy__", &__copy__);
ResStructureEditor_exposer.def( "__deepcopy__", &__copy__);
ResStructureEditor_exposer.def( "clone", &__copy__);
ResStructureEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__str__", &__str__< ::SireMol::ResStructureEditor > );
ResStructureEditor_exposer.def( "__repr__", &__str__< ::SireMol::ResStructureEditor > );
}
}
