Esempio n. 1
0
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 > );
    }

}
Esempio n. 2
0
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 > );
    }

}
Esempio n. 3
0
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 > );
    }

}
Esempio n. 4
0
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 > );
    }

}