Example #1
0
void register_ResEditorBase_class(){

    { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >
        typedef bp::class_< SireMol::Editor< SireMol::ResEditor, SireMol::Residue >, bp::bases< SireMol::Residue, SireMol::MoleculeView, SireBase::Property >, boost::noncopyable > ResEditorBase_exposer_t;
        ResEditorBase_exposer_t ResEditorBase_exposer = ResEditorBase_exposer_t( "ResEditorBase", bp::no_init );
        bp::scope ResEditorBase_scope( ResEditorBase_exposer );
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::atom
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*atom_function_type )(  ) ;
            atom_function_type atom_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::atom );
            
            ResEditorBase_exposer.def( 
                "atom"
                , atom_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::atom
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*atom_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
            atom_function_type atom_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::atom );
            
            ResEditorBase_exposer.def( 
                "atom"
                , atom_function_value
                , ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::chain
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*chain_function_type )(  ) ;
            chain_function_type chain_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::chain );
            
            ResEditorBase_exposer.def( 
                "chain"
                , chain_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::chain
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*chain_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
            chain_function_type chain_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::chain );
            
            ResEditorBase_exposer.def( 
                "chain"
                , chain_function_value
                , ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::cutGroup
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*cutGroup_function_type )(  ) ;
            cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::cutGroup );
            
            ResEditorBase_exposer.def( 
                "cutGroup"
                , cutGroup_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::cutGroup
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*cutGroup_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
            cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::cutGroup );
            
            ResEditorBase_exposer.def( 
                "cutGroup"
                , cutGroup_function_value
                , ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::molecule
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::MolEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*molecule_function_type )(  ) ;
            molecule_function_type molecule_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::molecule );
            
            ResEditorBase_exposer.def( 
                "molecule"
                , molecule_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::operator=
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue > & ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*assign_function_type )( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue > const & ) ;
            assign_function_type assign_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::operator= );
            
            ResEditorBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::operator=
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue > & ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*assign_function_type )( ::SireMol::Residue const & ) ;
            assign_function_type assign_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::operator= );
            
            ResEditorBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeMetadata
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor & ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*removeMetadata_function_type )( ::SireBase::PropertyName const & ) ;
            removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeMetadata );
            
            ResEditorBase_exposer.def( 
                "removeMetadata"
                , removeMetadata_function_value
                , ( bp::arg("metakey") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeMetadata
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor & ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*removeMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) ;
            removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeMetadata );
            
            ResEditorBase_exposer.def( 
                "removeMetadata"
                , removeMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeProperty
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor & ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*removeProperty_function_type )( ::SireBase::PropertyName const & ) ;
            removeProperty_function_type removeProperty_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::removeProperty );
            
            ResEditorBase_exposer.def( 
                "removeProperty"
                , removeProperty_function_value
                , ( bp::arg("key") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::residue
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*residue_function_type )(  ) ;
            residue_function_type residue_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::residue );
            
            ResEditorBase_exposer.def( 
                "residue"
                , residue_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::residue
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*residue_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
            residue_function_type residue_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::residue );
            
            ResEditorBase_exposer.def( 
                "residue"
                , residue_function_value
                , ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::segment
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*segment_function_type )(  ) ;
            segment_function_type segment_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::segment );
            
            ResEditorBase_exposer.def( 
                "segment"
                , segment_function_value );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::segment
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*segment_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
            segment_function_type segment_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::segment );
            
            ResEditorBase_exposer.def( 
                "segment"
                , segment_function_value
                , ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*select_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select );
            
            ResEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*select_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select );
            
            ResEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*select_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select );
            
            ResEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*select_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select );
            
            ResEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select
        
            typedef SireMol::Editor< SireMol::ResEditor, SireMol::Residue > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::*select_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::ResEditor, SireMol::Residue >::select );
            
            ResEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        ResEditorBase_exposer.def( "_set_property_QString", 
                                           &SireMol::ResEditorBase::setProperty< QString >, bp::return_self< >() );
        ResEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_ResStringProperty_function1, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_ResStringProperty_function2, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_property_qint64", 
                                           &SireMol::ResEditorBase::setProperty< qint64 >, bp::return_self< >() );
        ResEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_ResIntProperty_function1, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_ResIntProperty_function2, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_property_double", 
                                           &SireMol::ResEditorBase::setProperty< double >, bp::return_self< >() );
        ResEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_ResFloatProperty_function1, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_ResFloatProperty_function2, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_property_QVariant", 
                                           &SireMol::ResEditorBase::setProperty< QVariant >, bp::return_self< >() );
        ResEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_ResVariantProperty_function1, bp::return_self< >());
        ResEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_ResVariantProperty_function2, bp::return_self< >());
        ResEditorBase_exposer.def( "__str__", &__str__< ::SireMol::Editor<SireMol::ResEditor, SireMol::Residue> > );
        ResEditorBase_exposer.def( "__repr__", &__str__< ::SireMol::Editor<SireMol::ResEditor, SireMol::Residue> > );
    }

}
Example #2
0
void register_AtomEditorBase_class(){

    { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >
        typedef bp::class_< SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >, bp::bases< SireMol::Atom, SireMol::MoleculeView, SireBase::Property >, boost::noncopyable > AtomEditorBase_exposer_t;
        AtomEditorBase_exposer_t AtomEditorBase_exposer = AtomEditorBase_exposer_t( "AtomEditorBase", bp::no_init );
        bp::scope AtomEditorBase_scope( AtomEditorBase_exposer );
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*atom_function_type )(  ) ;
            atom_function_type atom_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom );
            
            AtomEditorBase_exposer.def( 
                "atom"
                , atom_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*atom_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
            atom_function_type atom_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::atom );
            
            AtomEditorBase_exposer.def( 
                "atom"
                , atom_function_value
                , ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*chain_function_type )(  ) ;
            chain_function_type chain_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain );
            
            AtomEditorBase_exposer.def( 
                "chain"
                , chain_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*chain_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
            chain_function_type chain_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::chain );
            
            AtomEditorBase_exposer.def( 
                "chain"
                , chain_function_value
                , ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*cutGroup_function_type )(  ) ;
            cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup );
            
            AtomEditorBase_exposer.def( 
                "cutGroup"
                , cutGroup_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*cutGroup_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
            cutGroup_function_type cutGroup_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::cutGroup );
            
            AtomEditorBase_exposer.def( 
                "cutGroup"
                , cutGroup_function_value
                , ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::molecule
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::MolEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*molecule_function_type )(  ) ;
            molecule_function_type molecule_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::molecule );
            
            AtomEditorBase_exposer.def( 
                "molecule"
                , molecule_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator=
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*assign_function_type )( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > const & ) ;
            assign_function_type assign_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator= );
            
            AtomEditorBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator=
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*assign_function_type )( ::SireMol::Atom const & ) ;
            assign_function_type assign_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::operator= );
            
            AtomEditorBase_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeMetadata_function_type )( ::SireBase::PropertyName const & ) ;
            removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata );
            
            AtomEditorBase_exposer.def( 
                "removeMetadata"
                , removeMetadata_function_value
                , ( bp::arg("metakey") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) ;
            removeMetadata_function_type removeMetadata_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeMetadata );
            
            AtomEditorBase_exposer.def( 
                "removeMetadata"
                , removeMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeProperty
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor & ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*removeProperty_function_type )( ::SireBase::PropertyName const & ) ;
            removeProperty_function_type removeProperty_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::removeProperty );
            
            AtomEditorBase_exposer.def( 
                "removeProperty"
                , removeProperty_function_value
                , ( bp::arg("key") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*residue_function_type )(  ) ;
            residue_function_type residue_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue );
            
            AtomEditorBase_exposer.def( 
                "residue"
                , residue_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*residue_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
            residue_function_type residue_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::residue );
            
            AtomEditorBase_exposer.def( 
                "residue"
                , residue_function_value
                , ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*segment_function_type )(  ) ;
            segment_function_type segment_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment );
            
            AtomEditorBase_exposer.def( 
                "segment"
                , segment_function_value );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*segment_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
            segment_function_type segment_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::segment );
            
            AtomEditorBase_exposer.def( 
                "segment"
                , segment_function_value
                , ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::AtomEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::AtomID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
            
            AtomEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("atomid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::CGEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::CGID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
            
            AtomEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("cgid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ResEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::ResID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
            
            AtomEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("resid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::ChainEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::ChainID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
            
            AtomEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("chainid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select
        
            typedef SireMol::Editor< SireMol::AtomEditor, SireMol::Atom > exported_class_t;
            typedef ::SireMol::SegEditor ( ::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::*select_function_type )( ::SireMol::SegID const &,::SireBase::PropertyMap const & ) ;
            select_function_type select_function_value( &::SireMol::Editor< SireMol::AtomEditor, SireMol::Atom >::select );
            
            AtomEditorBase_exposer.def( 
                "select"
                , select_function_value
                , ( bp::arg("segid"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        AtomEditorBase_exposer.def( "_set_property_SireMM_LJParameter", 
                                           &SireMol::AtomEditorBase::setProperty< SireMM::LJParameter >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMM_LJParameter", &set_Metadata_SireMM_AtomLJs_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMM_LJParameter", &set_Metadata_SireMM_AtomLJs_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_Volume", 
                                           &SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::Volume >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Volume", &set_Metadata_SireMol_AtomPolarisabilities_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Volume", &set_Metadata_SireMol_AtomPolarisabilities_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_MolarEnergy", 
                                           &SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::MolarEnergy >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarEnergy", &set_Metadata_SireMol_AtomEnergies_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarEnergy", &set_Metadata_SireMol_AtomEnergies_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector", 
                                           &SireMol::AtomEditorBase::setProperty< SireMaths::Vector >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector", &set_Metadata_SireMol_AtomCoords_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector", &set_Metadata_SireMol_AtomCoords_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector3D_SireUnits_Dimension_Force_", 
                                           &SireMol::AtomEditorBase::setProperty< SireMaths::Vector3D<SireUnits::Dimension::Force> >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Force_", &set_Metadata_SireMol_AtomForces_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Force_", &set_Metadata_SireMol_AtomForces_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireMol_BeadNum", 
                                           &SireMol::AtomEditorBase::setProperty< SireMol::BeadNum >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMol_BeadNum", &set_Metadata_SireMol_AtomBeads_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMol_BeadNum", &set_Metadata_SireMol_AtomBeads_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireMaths_Vector3D_SireUnits_Dimension_Velocity_", 
                                           &SireMol::AtomEditorBase::setProperty< SireMaths::Vector3D<SireUnits::Dimension::Velocity> >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Velocity_", &set_Metadata_SireMol_AtomVelocities_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMaths_Vector3D_SireUnits_Dimension_Velocity_", &set_Metadata_SireMol_AtomVelocities_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_Charge", 
                                           &SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::Charge >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Charge", &set_Metadata_SireMol_AtomCharges_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_Charge", &set_Metadata_SireMol_AtomCharges_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireMol_Element", 
                                           &SireMol::AtomEditorBase::setProperty< SireMol::Element >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireMol_Element", &set_Metadata_SireMol_AtomElements_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireMol_Element", &set_Metadata_SireMol_AtomElements_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_SireUnits_Dimension_MolarMass", 
                                           &SireMol::AtomEditorBase::setProperty< SireUnits::Dimension::MolarMass >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarMass", &set_Metadata_SireMol_AtomMasses_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_SireUnits_Dimension_MolarMass", &set_Metadata_SireMol_AtomMasses_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_QString", 
                                           &SireMol::AtomEditorBase::setProperty< QString >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_AtomStringProperty_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_QString", &set_Metadata_SireMol_AtomStringProperty_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_qint64", 
                                           &SireMol::AtomEditorBase::setProperty< qint64 >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_AtomIntProperty_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_qint64", &set_Metadata_SireMol_AtomIntProperty_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_double", 
                                           &SireMol::AtomEditorBase::setProperty< double >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_AtomFloatProperty_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_double", &set_Metadata_SireMol_AtomFloatProperty_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_property_QVariant", 
                                           &SireMol::AtomEditorBase::setProperty< QVariant >, bp::return_self< >() );
        AtomEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_AtomVariantProperty_function1, bp::return_self< >());
        AtomEditorBase_exposer.def( "_set_metadata_QVariant", &set_Metadata_SireMol_AtomVariantProperty_function2, bp::return_self< >());
        AtomEditorBase_exposer.def( "__str__", &__str__< ::SireMol::Editor<SireMol::AtomEditor, SireMol::Atom> > );
        AtomEditorBase_exposer.def( "__repr__", &__str__< ::SireMol::Editor<SireMol::AtomEditor, SireMol::Atom> > );
    }

}
Example #3
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 > );
    }

}