Beispiel #1
0
void register_ResID_class(){

    { //::SireMol::ResID
        typedef bp::class_< SireMol::ResID, bp::bases< SireID::ID >, boost::noncopyable > ResID_exposer_t;
        ResID_exposer_t ResID_exposer = ResID_exposer_t( "ResID", bp::no_init );
        bp::scope ResID_scope( ResID_exposer );
        { //::SireMol::ResID::atom
        
            typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atom_function_type )( int ) const;
            atom_function_type atom_function_value( &::SireMol::ResID::atom );
            
            ResID_exposer.def( 
                "atom"
                , atom_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMol::ResID::atoms
        
            typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atoms_function_type )(  ) const;
            atoms_function_type atoms_function_value( &::SireMol::ResID::atoms );
            
            ResID_exposer.def( 
                "atoms"
                , atoms_function_value );
        
        }
        { //::SireMol::ResID::atoms
        
            typedef ::SireMol::AtomsIn< SireMol::ResID > ( ::SireMol::ResID::*atoms_function_type )( int,int ) const;
            atoms_function_type atoms_function_value( &::SireMol::ResID::atoms );
            
            ResID_exposer.def( 
                "atoms"
                , atoms_function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        { //::SireMol::ResID::chains
        
            typedef ::SireMol::ChainsWithRes ( ::SireMol::ResID::*chains_function_type )(  ) const;
            chains_function_type chains_function_value( &::SireMol::ResID::chains );
            
            ResID_exposer.def( 
                "chains"
                , chains_function_value );
        
        }
        { //::SireMol::ResID::map
        
            typedef ::QList< SireMol::ResIdx > ( ::SireMol::ResID::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::ResID::map );
            
            ResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::ResID::map
        
            typedef ::QList< SireMol::ResIdx > ( ::SireMol::ResID::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            map_function_type map_function_value( &::SireMol::ResID::map );
            
            ResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        ResID_exposer.def( bp::self & bp::self );
        ResID_exposer.def( bp::self & bp::other< SireMol::ChainID >() );
        ResID_exposer.def( bp::self & bp::other< SireMol::AtomID >() );
        ResID_exposer.def( bp::self & bp::other< SireMol::SegID >() );
        ResID_exposer.def( bp::self & bp::other< SireMol::CGID >() );
        { //::SireMol::ResID::operator()
        
            typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__call___function_type )( int ) const;
            __call___function_type __call___function_value( &::SireMol::ResID::operator() );
            
            ResID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMol::ResID::operator()
        
            typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireMol::ResID::operator() );
            
            ResID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        ResID_exposer.def( bp::self * bp::self );
        ResID_exposer.def( bp::self + bp::self );
        ResID_exposer.def( bp::self + bp::other< SireMol::ChainID >() );
        ResID_exposer.def( bp::self + bp::other< SireMol::AtomID >() );
        ResID_exposer.def( bp::self + bp::other< SireMol::SegID >() );
        ResID_exposer.def( bp::self + bp::other< SireMol::CGID >() );
        { //::SireMol::ResID::operator[]
        
            typedef ::SireID::Specify< SireMol::ResID > ( ::SireMol::ResID::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::ResID::operator[] );
            
            ResID_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        ResID_exposer.def( bp::self | bp::self );
        { //::SireMol::ResID::selectAllFrom
        
            typedef ::SireMol::Selector< SireMol::Residue > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
            
            ResID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
            
            ResID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
            
            ResID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::ResID::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ResID::selectAllFrom );
            
            ResID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectFrom
        
            typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
            
            ResID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectFrom
        
            typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
            
            ResID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectFrom
        
            typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
            
            ResID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::selectFrom
        
            typedef ::SireMol::Residue ( ::SireMol::ResID::*selectFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ResID::selectFrom );
            
            ResID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ResID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ResID::typeName );
            
            ResID_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        ResID_exposer.staticmethod( "typeName" );
        ResID_exposer.def( "__str__", &__str__< ::SireMol::ResID > );
        ResID_exposer.def( "__repr__", &__str__< ::SireMol::ResID > );
    }

}
Beispiel #2
0
void register_ChainID_class(){

    { //::SireMol::ChainID
        typedef bp::class_< SireMol::ChainID, bp::bases< SireID::ID >, boost::noncopyable > ChainID_exposer_t;
        ChainID_exposer_t ChainID_exposer = ChainID_exposer_t( "ChainID", "This is the base class of all identifiers that are used\nto identify a chain within a molecule\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope ChainID_scope( ChainID_exposer );
        { //::SireMol::ChainID::atom
        
            typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atom_function_type)( int ) const;
            atom_function_type atom_function_value( &::SireMol::ChainID::atom );
            
            ChainID_exposer.def( 
                "atom"
                , atom_function_value
                , ( bp::arg("i") )
                , "Return a specific atom in the matching residues" );
        
        }
        { //::SireMol::ChainID::atoms
        
            typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atoms_function_type)(  ) const;
            atoms_function_type atoms_function_value( &::SireMol::ChainID::atoms );
            
            ChainID_exposer.def( 
                "atoms"
                , atoms_function_value
                , "Return the atoms in the matching residues" );
        
        }
        { //::SireMol::ChainID::atoms
        
            typedef ::SireMol::AtomsIn< SireMol::ChainID > ( ::SireMol::ChainID::*atoms_function_type)( int,int ) const;
            atoms_function_type atoms_function_value( &::SireMol::ChainID::atoms );
            
            ChainID_exposer.def( 
                "atoms"
                , atoms_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "Return a range of atoms in the matching residues" );
        
        }
        { //::SireMol::ChainID::map
        
            typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainID::*map_function_type)( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::ChainID::map );
            
            ChainID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") )
                , "Map this ID back to the indicies of the chains in the molecule,\nusing the passed MoleculeInfo to do the mapping" );
        
        }
        { //::SireMol::ChainID::map
        
            typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainID::*map_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            map_function_type map_function_value( &::SireMol::ChainID::map );
            
            ChainID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
                , "Map this ChainID to the chains in the passed molecule view\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
        
        }
        ChainID_exposer.def( bp::self & bp::self );
        ChainID_exposer.def( bp::self & bp::other< SireMol::ResID >() );
        ChainID_exposer.def( bp::self & bp::other< SireMol::AtomID >() );
        ChainID_exposer.def( bp::self & bp::other< SireMol::SegID >() );
        ChainID_exposer.def( bp::self & bp::other< SireMol::CGID >() );
        { //::SireMol::ChainID::operator()
        
            typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__call___function_type)( int ) const;
            __call___function_type __call___function_value( &::SireMol::ChainID::operator() );
            
            ChainID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        { //::SireMol::ChainID::operator()
        
            typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__call___function_type)( int,int ) const;
            __call___function_type __call___function_value( &::SireMol::ChainID::operator() );
            
            ChainID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "" );
        
        }
        ChainID_exposer.def( bp::self * bp::self );
        ChainID_exposer.def( bp::self + bp::self );
        ChainID_exposer.def( bp::self + bp::other< SireMol::ResID >() );
        ChainID_exposer.def( bp::self + bp::other< SireMol::AtomID >() );
        ChainID_exposer.def( bp::self + bp::other< SireMol::SegID >() );
        ChainID_exposer.def( bp::self + bp::other< SireMol::CGID >() );
        { //::SireMol::ChainID::operator[]
        
            typedef ::SireID::Specify< SireMol::ChainID > ( ::SireMol::ChainID::*__getitem___function_type)( int ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::ChainID::operator[] );
            
            ChainID_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        ChainID_exposer.def( bp::self | bp::self );
        { //::SireMol::ChainID::residue
        
            typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residue_function_type)( int ) const;
            residue_function_type residue_function_value( &::SireMol::ChainID::residue );
            
            ChainID_exposer.def( 
                "residue"
                , residue_function_value
                , ( bp::arg("i") )
                , "Return a specific atom in the matching residues" );
        
        }
        { //::SireMol::ChainID::residues
        
            typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residues_function_type)(  ) const;
            residues_function_type residues_function_value( &::SireMol::ChainID::residues );
            
            ChainID_exposer.def( 
                "residues"
                , residues_function_value
                , "Return the atoms in the matching residues" );
        
        }
        { //::SireMol::ChainID::residues
        
            typedef ::SireMol::ResIn< SireMol::ChainID > ( ::SireMol::ChainID::*residues_function_type)( int,int ) const;
            residues_function_type residues_function_value( &::SireMol::ChainID::residues );
            
            ChainID_exposer.def( 
                "residues"
                , residues_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "Return a range of atoms in the matching residues" );
        
        }
        { //::SireMol::ChainID::selectAllFrom
        
            typedef ::SireMol::Selector< SireMol::Chain > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
            
            ChainID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
                , "Select all the chains from the passed view that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\nThrow: SireMol::duplicate_chain\n" );
        
        }
        { //::SireMol::ChainID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
            
            ChainID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return all of the chains from the molecules that match\nthis ID\nThrow: SireMol::missing_chain\n" );
        
        }
        { //::SireMol::ChainID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
            
            ChainID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return the chains from the molecule group molgroup that match\nthis ID\nThrow: SireMol::missing_chain\n" );
        
        }
        { //::SireMol::ChainID::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Chain > > ( ::SireMol::ChainID::*selectAllFrom_function_type)( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::ChainID::selectAllFrom );
            
            ChainID_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return the set of chains that match this ID in the molecule groups\nset molgroups\nThrow: SireMol::missing_chain\n" );
        
        }
        { //::SireMol::ChainID::selectFrom
        
            typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
            
            ChainID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() )
                , "Select the chain from the passed view that matches this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\nThrow: SireMol::duplicate_chain\n" );
        
        }
        { //::SireMol::ChainID::selectFrom
        
            typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
            
            ChainID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return the chain from the molecules molecules that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
        
        }
        { //::SireMol::ChainID::selectFrom
        
            typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
            
            ChainID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return the chain from the molecule group molgroup that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
        
        }
        { //::SireMol::ChainID::selectFrom
        
            typedef ::SireMol::Chain ( ::SireMol::ChainID::*selectFrom_function_type)( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
            selectFrom_function_type selectFrom_function_value( &::SireMol::ChainID::selectFrom );
            
            ChainID_exposer.def( 
                "selectFrom"
                , selectFrom_function_value
                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() )
                , "Return the chain from the molecule groups molgroups that matches\nthis ID\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\n" );
        
        }
        { //::SireMol::ChainID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ChainID::typeName );
            
            ChainID_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        ChainID_exposer.staticmethod( "typeName" );
        ChainID_exposer.def( "__str__", &__str__< ::SireMol::ChainID > );
        ChainID_exposer.def( "__repr__", &__str__< ::SireMol::ChainID > );
        ChainID_exposer.def( "__hash__", &::SireMol::ChainID::hash );
    }

}
void register_MolWithResID_class(){

    { //::SireMol::MolWithResID
        typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t;
        MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() );
        bp::scope MolWithResID_scope( MolWithResID_exposer );
        MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) );
        MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) );
        MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) );
        MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) );
        MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) );
        { //::SireMol::MolWithResID::hash
        
            typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireMol::MolWithResID::hash );
            
            MolWithResID_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireMol::MolWithResID::isNull
        
            typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull );
            
            MolWithResID_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMol::MolWithResID::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molecules") ) );
        
        }
        { //::SireMol::MolWithResID::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroup") ) );
        
        }
        { //::SireMol::MolWithResID::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const;
            map_function_type map_function_value( &::SireMol::MolWithResID::map );
            
            MolWithResID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroups") ) );
        
        }
        MolWithResID_exposer.def( bp::self != bp::self );
        { //::SireMol::MolWithResID::operator=
        
            typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ;
            assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= );
            
            MolWithResID_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() );
        MolWithResID_exposer.def( bp::self == bp::self );
        { //::SireMol::MolWithResID::resID
        
            typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )(  ) const;
            resID_function_type resID_function_value( &::SireMol::MolWithResID::resID );
            
            MolWithResID_exposer.def( 
                "resID"
                , resID_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::MolWithResID::toString
        
            typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::MolWithResID::toString );
            
            MolWithResID_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::MolWithResID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::MolWithResID::typeName );
            
            MolWithResID_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::MolWithResID::what
        
            typedef char const * ( ::SireMol::MolWithResID::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::MolWithResID::what );
            
            MolWithResID_exposer.def( 
                "what"
                , what_function_value );
        
        }
        MolWithResID_exposer.staticmethod( "typeName" );
        MolWithResID_exposer.def( "__copy__", &__copy__);
        MolWithResID_exposer.def( "__deepcopy__", &__copy__);
        MolWithResID_exposer.def( "clone", &__copy__);
        MolWithResID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolWithResID >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolWithResID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolWithResID >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolWithResID_exposer.def( "__str__", &__str__< ::SireMol::MolWithResID > );
        MolWithResID_exposer.def( "__repr__", &__str__< ::SireMol::MolWithResID > );
    }

}
void register_Specify_SegID__class(){

    { //::SireID::Specify< SireMol::SegID >
        typedef bp::class_< SireID::Specify< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > Specify_SegID__exposer_t;
        Specify_SegID__exposer_t Specify_SegID__exposer = Specify_SegID__exposer_t( "Specify_SegID_", bp::init< >() );
        bp::scope Specify_SegID__scope( Specify_SegID__exposer );
        Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32 >(( bp::arg("id"), bp::arg("i") )) );
        Specify_SegID__exposer.def( bp::init< SireMol::SegID const &, qint32, qint32 >(( bp::arg("id"), bp::arg("i"), bp::arg("j") )) );
        Specify_SegID__exposer.def( bp::init< SireID::Specify< SireMol::SegID > const & >(( bp::arg("other") )) );
        { //::SireID::Specify< SireMol::SegID >::hash
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::uint ( ::SireID::Specify< SireMol::SegID >::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireID::Specify< SireMol::SegID >::hash );
            
            Specify_SegID__exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::isNull
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef bool ( ::SireID::Specify< SireMol::SegID >::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireID::Specify< SireMol::SegID >::isNull );
            
            Specify_SegID__exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::map
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::QList< SireMol::SegIdx > ( ::SireID::Specify< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireID::Specify< SireMol::SegID >::map );
            
            Specify_SegID__exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("obj") ) );
        
        }
        Specify_SegID__exposer.def( bp::self != bp::self );
        Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
        { //::SireID::Specify< SireMol::SegID >::operator()
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;
            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
            
            Specify_SegID__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::operator()
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );
            
            Specify_SegID__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::operator=
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;
            assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );
            
            Specify_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Specify_SegID__exposer.def( bp::self == bp::self );
        Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
        { //::SireID::Specify< SireMol::SegID >::operator[]
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );
            
            Specify_SegID__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireID::Specify< SireMol::SegID >::toString
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );
            
            Specify_SegID__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::typeName
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );
            
            Specify_SegID__exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireID::Specify< SireMol::SegID >::what
        
            typedef SireID::Specify< SireMol::SegID > exported_class_t;
            typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );
            
            Specify_SegID__exposer.def( 
                "what"
                , what_function_value );
        
        }
        Specify_SegID__exposer.staticmethod( "typeName" );
        Specify_SegID__exposer.def( "__copy__", &__copy__);
        Specify_SegID__exposer.def( "__deepcopy__", &__copy__);
        Specify_SegID__exposer.def( "clone", &__copy__);
        Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );
        Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );
    }

}
Beispiel #5
0
void register_MolResNum_class(){

    { //::SireMol::MolResNum
        typedef bp::class_< SireMol::MolResNum, bp::bases< SireMol::ResID, SireID::ID > > MolResNum_exposer_t;
        MolResNum_exposer_t MolResNum_exposer = MolResNum_exposer_t( "MolResNum", bp::init< >() );
        bp::scope MolResNum_scope( MolResNum_exposer );
        MolResNum_exposer.def( bp::init< SireMol::MolNum const &, SireMol::ResNum const & >(( bp::arg("molnum"), bp::arg("resnum") )) );
        MolResNum_exposer.def( bp::init< SireMol::ResNum const &, SireMol::MolNum const & >(( bp::arg("resnum"), bp::arg("molnum") )) );
        MolResNum_exposer.def( bp::init< SireMol::MolResNum const & >(( bp::arg("other") )) );
        { //::SireMol::MolResNum::hash
        
            typedef ::uint ( ::SireMol::MolResNum::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireMol::MolResNum::hash );
            
            MolResNum_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireMol::MolResNum::isNull
        
            typedef bool ( ::SireMol::MolResNum::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::MolResNum::isNull );
            
            MolResNum_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMol::MolResNum::map
        
            typedef ::QList< SireMol::ResIdx > ( ::SireMol::MolResNum::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::MolResNum::map );
            
            MolResNum_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::MolResNum::molNum
        
            typedef ::SireMol::MolNum const & ( ::SireMol::MolResNum::*molNum_function_type )(  ) const;
            molNum_function_type molNum_function_value( &::SireMol::MolResNum::molNum );
            
            MolResNum_exposer.def( 
                "molNum"
                , molNum_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        MolResNum_exposer.def( bp::self != bp::self );
        { //::SireMol::MolResNum::operator=
        
            typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ;
            assign_function_type assign_function_value( &::SireMol::MolResNum::operator= );
            
            MolResNum_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() );
        MolResNum_exposer.def( bp::self == bp::self );
        { //::SireMol::MolResNum::resNum
        
            typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )(  ) const;
            resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum );
            
            MolResNum_exposer.def( 
                "resNum"
                , resNum_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::MolResNum::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
            
            MolResNum_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::MolResNum::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
            
            MolResNum_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::MolResNum::selectAllFrom
        
            typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;
            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );
            
            MolResNum_exposer.def( 
                "selectAllFrom"
                , selectAllFrom_function_value
                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::MolResNum::toString
        
            typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::MolResNum::toString );
            
            MolResNum_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::MolResNum::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName );
            
            MolResNum_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::MolResNum::what
        
            typedef char const * ( ::SireMol::MolResNum::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::MolResNum::what );
            
            MolResNum_exposer.def( 
                "what"
                , what_function_value );
        
        }
        MolResNum_exposer.staticmethod( "typeName" );
        MolResNum_exposer.def( "__copy__", &__copy__);
        MolResNum_exposer.def( "__deepcopy__", &__copy__);
        MolResNum_exposer.def( "clone", &__copy__);
        MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > );
        MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > );
    }

}
void register_IDOrSet_SegID__class(){

    { //::SireID::IDOrSet< SireMol::SegID >
        typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t;
        IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() );
        bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer );
        IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) );
        IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) );
        IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) );
        IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) );
        { //::SireID::IDOrSet< SireMol::SegID >::IDs
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )(  ) const;
            IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs );
            
            IDOrSet_SegID__exposer.def( 
                "IDs"
                , IDs_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::hash
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash );
            
            IDOrSet_SegID__exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::isNull
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull );
            
            IDOrSet_SegID__exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::map
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map );
            
            IDOrSet_SegID__exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("obj") ) );
        
        }
        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );
        IDOrSet_SegID__exposer.def( bp::self != bp::self );
        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() );
        { //::SireID::IDOrSet< SireMol::SegID >::operator=
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ;
            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
            
            IDOrSet_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::operator=
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ;
            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );
            
            IDOrSet_SegID__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );
        IDOrSet_SegID__exposer.def( bp::self == bp::self );
        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() );
        { //::SireID::IDOrSet< SireMol::SegID >::toString
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString );
            
            IDOrSet_SegID__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::typeName
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireID::IDOrSet< SireMol::SegID >::typeName );
            
            IDOrSet_SegID__exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireID::IDOrSet< SireMol::SegID >::what
        
            typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;
            typedef char const * ( ::SireID::IDOrSet< SireMol::SegID >::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireID::IDOrSet< SireMol::SegID >::what );
            
            IDOrSet_SegID__exposer.def( 
                "what"
                , what_function_value );
        
        }
        IDOrSet_SegID__exposer.staticmethod( "typeName" );
        IDOrSet_SegID__exposer.def( "__copy__", &__copy__);
        IDOrSet_SegID__exposer.def( "__deepcopy__", &__copy__);
        IDOrSet_SegID__exposer.def( "clone", &__copy__);
        IDOrSet_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IDOrSet_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::IDOrSet<SireMol::SegID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        IDOrSet_SegID__exposer.def( "__str__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
        IDOrSet_SegID__exposer.def( "__repr__", &__str__< ::SireID::IDOrSet<SireMol::SegID> > );
    }

}
Beispiel #7
0
void register_FFIdx_class(){

    { //::SireFF::FFIdx
        typedef bp::class_< SireFF::FFIdx, bp::bases< SireFF::FFID, SireID::ID, SireID::IndexBase > > FFIdx_exposer_t;
        FFIdx_exposer_t FFIdx_exposer = FFIdx_exposer_t( "FFIdx", "This is an ID object that is used to index forcefields (e.g. index\nin a list or array).\n\nAuthor: Christopher Woods\n", bp::init< >("") );
        bp::scope FFIdx_scope( FFIdx_exposer );
        FFIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") ), "") );
        FFIdx_exposer.def( bp::init< SireFF::FFIdx const & >(( bp::arg("other") ), "") );
        { //::SireFF::FFIdx::hash
        
            typedef ::uint ( ::SireFF::FFIdx::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireFF::FFIdx::hash );
            
            FFIdx_exposer.def( 
                "hash"
                , hash_function_value
                , "" );
        
        }
        { //::SireFF::FFIdx::isNull
        
            typedef bool ( ::SireFF::FFIdx::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireFF::FFIdx::isNull );
            
            FFIdx_exposer.def( 
                "isNull"
                , isNull_function_value
                , "" );
        
        }
        { //::SireFF::FFIdx::map
        
            typedef ::QList< SireFF::FFIdx > ( ::SireFF::FFIdx::*map_function_type)( ::SireFF::ForceFields const & ) const;
            map_function_type map_function_value( &::SireFF::FFIdx::map );
            
            FFIdx_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("ffields") )
                , "Short cut function to map this index to the index of the\nmatching forcefield in the passed ForceFields object\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireFF::FFIdx::null
        
            typedef ::SireFF::FFIdx ( *null_function_type )(  );
            null_function_type null_function_value( &::SireFF::FFIdx::null );
            
            FFIdx_exposer.def( 
                "null"
                , null_function_value
                , "" );
        
        }
        { //::SireFF::FFIdx::operator=
        
            typedef ::SireFF::FFIdx & ( ::SireFF::FFIdx::*assign_function_type)( ::SireFF::FFIdx const & ) ;
            assign_function_type assign_function_value( &::SireFF::FFIdx::operator= );
            
            FFIdx_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireFF::FFIdx::toString
        
            typedef ::QString ( ::SireFF::FFIdx::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireFF::FFIdx::toString );
            
            FFIdx_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireFF::FFIdx::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::FFIdx::typeName );
            
            FFIdx_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireFF::FFIdx::what
        
            typedef char const * ( ::SireFF::FFIdx::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireFF::FFIdx::what );
            
            FFIdx_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        FFIdx_exposer.staticmethod( "null" );
        FFIdx_exposer.staticmethod( "typeName" );
        FFIdx_exposer.def( "__copy__", &__copy__);
        FFIdx_exposer.def( "__deepcopy__", &__copy__);
        FFIdx_exposer.def( "clone", &__copy__);
        FFIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::FFIdx >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        FFIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::FFIdx >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        FFIdx_exposer.def( "__str__", &__str__< ::SireFF::FFIdx > );
        FFIdx_exposer.def( "__repr__", &__str__< ::SireFF::FFIdx > );
        FFIdx_exposer.def( "__hash__", &::SireFF::FFIdx::hash );
    }

}
Beispiel #8
0
void register_ChainAtomID_class(){

    { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >
        typedef bp::class_< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >, bp::bases< SireMol::GroupAtomIDBase, SireMol::AtomID, SireID::ID > > ChainAtomID_exposer_t;
        ChainAtomID_exposer_t ChainAtomID_exposer = ChainAtomID_exposer_t( "ChainAtomID", "", bp::init< >("") );
        bp::scope ChainAtomID_scope( ChainAtomID_exposer );
        ChainAtomID_exposer.def( bp::init< SireMol::ChainID const &, SireMol::AtomID const & >(( bp::arg("group"), bp::arg("atom") ), "") );
        ChainAtomID_exposer.def( bp::init< SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > const & >(( bp::arg("other") ), "") );
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef ::uint ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::hash );
            
            ChainAtomID_exposer.def( 
                "hash"
                , hash_function_value
                , "" );
        
        }
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef bool ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::isNull );
            
            ChainAtomID_exposer.def( 
                "isNull"
                , isNull_function_value
                , "" );
        
        }
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef ::QList< SireMol::AtomIdx > ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*map_function_type)( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::map );
            
            ChainAtomID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        ChainAtomID_exposer.def( bp::self != bp::self );
        ChainAtomID_exposer.def( bp::self == bp::self );
        ChainAtomID_exposer.def( bp::self == bp::other< SireID::ID >() );
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef ::QString ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::toString );
            
            ChainAtomID_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::typeName );
            
            ChainAtomID_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what
        
            typedef SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID > exported_class_t;
            typedef char const * ( ::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMol::GroupAtomID< SireMol::ChainID, SireMol::AtomID >::what );
            
            ChainAtomID_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        ChainAtomID_exposer.staticmethod( "typeName" );
        ChainAtomID_exposer.def( "__copy__", &__copy__);
        ChainAtomID_exposer.def( "__deepcopy__", &__copy__);
        ChainAtomID_exposer.def( "clone", &__copy__);
        ChainAtomID_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainAtomID_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainAtomID_exposer.def( "__str__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
        ChainAtomID_exposer.def( "__repr__", &__str__< ::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID> > );
        ChainAtomID_exposer.def( "__hash__", &::SireMol::GroupAtomID<SireMol::ChainID, SireMol::AtomID>::hash );
    }

}
Beispiel #9
0
void register_Within_class(){

    { //::SireMol::Within
        typedef bp::class_< SireMol::Within, bp::bases< SireMol::AtomID, SireID::ID > > Within_exposer_t;
        Within_exposer_t Within_exposer = Within_exposer_t( "Within", bp::init< >() );
        bp::scope Within_scope( Within_exposer );
        Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMaths::Vector const & >(( bp::arg("distance"), bp::arg("point") )) );
        Within_exposer.def( bp::init< SireUnits::Dimension::Length, SireMol::AtomID const & >(( bp::arg("distance"), bp::arg("atomid") )) );
        Within_exposer.def( bp::init< SireMol::Within const & >(( bp::arg("other") )) );
        { //::SireMol::Within::hash
        
            typedef ::uint ( ::SireMol::Within::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireMol::Within::hash );
            
            Within_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireMol::Within::isNull
        
            typedef bool ( ::SireMol::Within::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::Within::isNull );
            
            Within_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMol::Within::map
        
            typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::Within::map );
            
            Within_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::Within::map
        
            typedef ::QList< SireMol::AtomIdx > ( ::SireMol::Within::*map_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            map_function_type map_function_value( &::SireMol::Within::map );
            
            Within_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molview"), bp::arg("map") ) );
        
        }
        Within_exposer.def( bp::self != bp::self );
        { //::SireMol::Within::operator=
        
            typedef ::SireMol::Within & ( ::SireMol::Within::*assign_function_type )( ::SireMol::Within const & ) ;
            assign_function_type assign_function_value( &::SireMol::Within::operator= );
            
            Within_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Within_exposer.def( bp::self == bp::other< SireID::ID >() );
        Within_exposer.def( bp::self == bp::self );
        { //::SireMol::Within::toString
        
            typedef ::QString ( ::SireMol::Within::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::Within::toString );
            
            Within_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::Within::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::Within::typeName );
            
            Within_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::Within::what
        
            typedef char const * ( ::SireMol::Within::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::Within::what );
            
            Within_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Within_exposer.staticmethod( "typeName" );
        Within_exposer.def( "__copy__", &__copy__);
        Within_exposer.def( "__deepcopy__", &__copy__);
        Within_exposer.def( "clone", &__copy__);
        Within_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Within >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Within_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Within >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Within_exposer.def( "__str__", &__str__< ::SireMol::Within > );
        Within_exposer.def( "__repr__", &__str__< ::SireMol::Within > );
    }

}
Beispiel #10
0
void register_SpecifyMol_class(){

    { //::SireMol::SpecifyMol
        typedef bp::class_< SireMol::SpecifyMol, bp::bases< SireMol::MolID, SireID::ID > > SpecifyMol_exposer_t;
        SpecifyMol_exposer_t SpecifyMol_exposer = SpecifyMol_exposer_t( "SpecifyMol", "This class allow for the specification of specific\nmatching molecules\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
        bp::scope SpecifyMol_scope( SpecifyMol_exposer );
        SpecifyMol_exposer.def( bp::init< SireMol::MolID const & >(( bp::arg("molid") ), "Construct to match all of the molecules that match the\nID molid") );
        SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int >(( bp::arg("molid"), bp::arg("i") ), "Construct to match the ith molecule that matches the ID molid") );
        SpecifyMol_exposer.def( bp::init< SireMol::MolID const &, int, int >(( bp::arg("molid"), bp::arg("i"), bp::arg("j") ), "Construct to math the range of molecules from i to j that\nmatch the ID molid") );
        SpecifyMol_exposer.def( bp::init< SireMol::SpecifyMol const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMol::SpecifyMol::hash
        
            typedef ::uint ( ::SireMol::SpecifyMol::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireMol::SpecifyMol::hash );
            
            SpecifyMol_exposer.def( 
                "hash"
                , hash_function_value
                , "Hash this ID" );
        
        }
        { //::SireMol::SpecifyMol::isNull
        
            typedef bool ( ::SireMol::SpecifyMol::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::SpecifyMol::isNull );
            
            SpecifyMol_exposer.def( 
                "isNull"
                , isNull_function_value
                , "Return whether or not this ID is null" );
        
        }
        { //::SireMol::SpecifyMol::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::Molecules const & ) const;
            map_function_type map_function_value( &::SireMol::SpecifyMol::map );
            
            SpecifyMol_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molecules") )
                , "Map this ID to the list of molecule numbers that match" );
        
        }
        { //::SireMol::SpecifyMol::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MoleculeGroup const & ) const;
            map_function_type map_function_value( &::SireMol::SpecifyMol::map );
            
            SpecifyMol_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroup") )
                , "Map this ID to the list of molecule numbers that match" );
        
        }
        { //::SireMol::SpecifyMol::map
        
            typedef ::QList< SireMol::MolNum > ( ::SireMol::SpecifyMol::*map_function_type)( ::SireMol::MolGroupsBase const & ) const;
            map_function_type map_function_value( &::SireMol::SpecifyMol::map );
            
            SpecifyMol_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molgroups") )
                , "Map this ID to the list of molecule numbers that match" );
        
        }
        SpecifyMol_exposer.def( bp::self != bp::self );
        SpecifyMol_exposer.def( bp::self != bp::other< SireID::ID >() );
        { //::SireMol::SpecifyMol::operator=
        
            typedef ::SireMol::SpecifyMol & ( ::SireMol::SpecifyMol::*assign_function_type)( ::SireMol::SpecifyMol const & ) ;
            assign_function_type assign_function_value( &::SireMol::SpecifyMol::operator= );
            
            SpecifyMol_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        SpecifyMol_exposer.def( bp::self == bp::self );
        SpecifyMol_exposer.def( bp::self == bp::other< SireID::ID >() );
        { //::SireMol::SpecifyMol::toString
        
            typedef ::QString ( ::SireMol::SpecifyMol::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::SpecifyMol::toString );
            
            SpecifyMol_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this ID" );
        
        }
        { //::SireMol::SpecifyMol::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::SpecifyMol::typeName );
            
            SpecifyMol_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMol::SpecifyMol::what
        
            typedef char const * ( ::SireMol::SpecifyMol::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMol::SpecifyMol::what );
            
            SpecifyMol_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        SpecifyMol_exposer.staticmethod( "typeName" );
        SpecifyMol_exposer.def( "__copy__", &__copy__);
        SpecifyMol_exposer.def( "__deepcopy__", &__copy__);
        SpecifyMol_exposer.def( "clone", &__copy__);
        SpecifyMol_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::SpecifyMol >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        SpecifyMol_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::SpecifyMol >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        SpecifyMol_exposer.def( "__str__", &__str__< ::SireMol::SpecifyMol > );
        SpecifyMol_exposer.def( "__repr__", &__str__< ::SireMol::SpecifyMol > );
        SpecifyMol_exposer.def( "__hash__", &::SireMol::SpecifyMol::hash );
    }

}
Beispiel #11
0
void register_CGsWithAtoms_class(){

    { //::SireMol::CGsWithAtoms
        typedef bp::class_< SireMol::CGsWithAtoms, bp::bases< SireMol::CGID, SireID::ID > > CGsWithAtoms_exposer_t;
        CGsWithAtoms_exposer_t CGsWithAtoms_exposer = CGsWithAtoms_exposer_t( "CGsWithAtoms", bp::init< >() );
        bp::scope CGsWithAtoms_scope( CGsWithAtoms_exposer );
        CGsWithAtoms_exposer.def( bp::init< SireMol::AtomID const & >(( bp::arg("atomid") )) );
        CGsWithAtoms_exposer.def( bp::init< SireMol::CGsWithAtoms const & >(( bp::arg("other") )) );
        { //::SireMol::CGsWithAtoms::atomID
        
            typedef ::SireMol::AtomID const & ( ::SireMol::CGsWithAtoms::*atomID_function_type )(  ) const;
            atomID_function_type atomID_function_value( &::SireMol::CGsWithAtoms::atomID );
            
            CGsWithAtoms_exposer.def( 
                "atomID"
                , atomID_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::CGsWithAtoms::hash
        
            typedef ::uint ( ::SireMol::CGsWithAtoms::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireMol::CGsWithAtoms::hash );
            
            CGsWithAtoms_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireMol::CGsWithAtoms::isNull
        
            typedef bool ( ::SireMol::CGsWithAtoms::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::CGsWithAtoms::isNull );
            
            CGsWithAtoms_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMol::CGsWithAtoms::map
        
            typedef ::QList< SireMol::CGIdx > ( ::SireMol::CGsWithAtoms::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::CGsWithAtoms::map );
            
            CGsWithAtoms_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        CGsWithAtoms_exposer.def( bp::self != bp::self );
        { //::SireMol::CGsWithAtoms::operator=
        
            typedef ::SireMol::CGsWithAtoms & ( ::SireMol::CGsWithAtoms::*assign_function_type )( ::SireMol::CGsWithAtoms const & ) ;
            assign_function_type assign_function_value( &::SireMol::CGsWithAtoms::operator= );
            
            CGsWithAtoms_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CGsWithAtoms_exposer.def( bp::self == bp::other< SireID::ID >() );
        CGsWithAtoms_exposer.def( bp::self == bp::self );
        { //::SireMol::CGsWithAtoms::toString
        
            typedef ::QString ( ::SireMol::CGsWithAtoms::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::CGsWithAtoms::toString );
            
            CGsWithAtoms_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::CGsWithAtoms::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::CGsWithAtoms::typeName );
            
            CGsWithAtoms_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::CGsWithAtoms::what
        
            typedef char const * ( ::SireMol::CGsWithAtoms::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::CGsWithAtoms::what );
            
            CGsWithAtoms_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CGsWithAtoms_exposer.staticmethod( "typeName" );
        CGsWithAtoms_exposer.def( "__copy__", &__copy__);
        CGsWithAtoms_exposer.def( "__deepcopy__", &__copy__);
        CGsWithAtoms_exposer.def( "clone", &__copy__);
        CGsWithAtoms_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CGsWithAtoms >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CGsWithAtoms_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CGsWithAtoms >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CGsWithAtoms_exposer.def( "__str__", &__str__< ::SireMol::CGsWithAtoms > );
        CGsWithAtoms_exposer.def( "__repr__", &__str__< ::SireMol::CGsWithAtoms > );
    }

}
Beispiel #12
0
void register_ChainIdx_class(){

    { //::SireMol::ChainIdx
        typedef bp::class_< SireMol::ChainIdx, bp::bases< SireMol::ChainID, SireID::ID, SireID::IndexBase > > ChainIdx_exposer_t;
        ChainIdx_exposer_t ChainIdx_exposer = ChainIdx_exposer_t( "ChainIdx", bp::init< >() );
        bp::scope ChainIdx_scope( ChainIdx_exposer );
        ChainIdx_exposer.def( bp::init< qint32 >(( bp::arg("idx") )) );
        ChainIdx_exposer.def( bp::init< SireMol::ChainIdx const & >(( bp::arg("other") )) );
        { //::SireMol::ChainIdx::hash
        
            typedef ::uint ( ::SireMol::ChainIdx::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireMol::ChainIdx::hash );
            
            ChainIdx_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireMol::ChainIdx::isNull
        
            typedef bool ( ::SireMol::ChainIdx::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::ChainIdx::isNull );
            
            ChainIdx_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMol::ChainIdx::map
        
            typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainIdx::*map_function_type )( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::ChainIdx::map );
            
            ChainIdx_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::ChainIdx::null
        
            typedef ::SireMol::ChainIdx ( *null_function_type )(  );
            null_function_type null_function_value( &::SireMol::ChainIdx::null );
            
            ChainIdx_exposer.def( 
                "null"
                , null_function_value );
        
        }
        { //::SireMol::ChainIdx::operator=
        
            typedef ::SireMol::ChainIdx & ( ::SireMol::ChainIdx::*assign_function_type )( ::SireMol::ChainIdx const & ) ;
            assign_function_type assign_function_value( &::SireMol::ChainIdx::operator= );
            
            ChainIdx_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::ChainIdx::toString
        
            typedef ::QString ( ::SireMol::ChainIdx::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::ChainIdx::toString );
            
            ChainIdx_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::ChainIdx::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ChainIdx::typeName );
            
            ChainIdx_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::ChainIdx::what
        
            typedef char const * ( ::SireMol::ChainIdx::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMol::ChainIdx::what );
            
            ChainIdx_exposer.def( 
                "what"
                , what_function_value );
        
        }
        ChainIdx_exposer.staticmethod( "null" );
        ChainIdx_exposer.staticmethod( "typeName" );
        ChainIdx_exposer.def( "__copy__", &__copy__);
        ChainIdx_exposer.def( "__deepcopy__", &__copy__);
        ChainIdx_exposer.def( "clone", &__copy__);
        ChainIdx_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainIdx >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainIdx_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainIdx >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainIdx_exposer.def( "__str__", &__str__< ::SireMol::ChainIdx > );
        ChainIdx_exposer.def( "__repr__", &__str__< ::SireMol::ChainIdx > );
    }

}
Beispiel #13
0
void register_MonitorName_class(){

    { //::SireSystem::MonitorName
        typedef bp::class_< SireSystem::MonitorName, bp::bases< SireSystem::MonitorID, SireID::ID, SireID::Name > > MonitorName_exposer_t;
        MonitorName_exposer_t MonitorName_exposer = MonitorName_exposer_t( "MonitorName", "This class holds the name of a simulation system\n\nAuthor: Christopher Woods\n", bp::init< >("") );
        bp::scope MonitorName_scope( MonitorName_exposer );
        MonitorName_exposer.def( bp::init< QString const & >(( bp::arg("name") ), "") );
        MonitorName_exposer.def( bp::init< SireSystem::MonitorName const & >(( bp::arg("other") ), "") );
        { //::SireSystem::MonitorName::hash
        
            typedef ::uint ( ::SireSystem::MonitorName::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireSystem::MonitorName::hash );
            
            MonitorName_exposer.def( 
                "hash"
                , hash_function_value
                , "" );
        
        }
        { //::SireSystem::MonitorName::isNull
        
            typedef bool ( ::SireSystem::MonitorName::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireSystem::MonitorName::isNull );
            
            MonitorName_exposer.def( 
                "isNull"
                , isNull_function_value
                , "" );
        
        }
        { //::SireSystem::MonitorName::map
        
            typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorName::*map_function_type)( ::SireSystem::SystemMonitors const & ) const;
            map_function_type map_function_value( &::SireSystem::MonitorName::map );
            
            MonitorName_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("monitors") )
                , "" );
        
        }
        MonitorName_exposer.def( bp::self != bp::self );
        { //::SireSystem::MonitorName::operator=
        
            typedef ::SireSystem::MonitorName & ( ::SireSystem::MonitorName::*assign_function_type)( ::SireSystem::MonitorName const & ) ;
            assign_function_type assign_function_value( &::SireSystem::MonitorName::operator= );
            
            MonitorName_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        MonitorName_exposer.def( bp::self == bp::other< SireID::ID >() );
        MonitorName_exposer.def( bp::self == bp::self );
        { //::SireSystem::MonitorName::toString
        
            typedef ::QString ( ::SireSystem::MonitorName::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireSystem::MonitorName::toString );
            
            MonitorName_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireSystem::MonitorName::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireSystem::MonitorName::typeName );
            
            MonitorName_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireSystem::MonitorName::what
        
            typedef char const * ( ::SireSystem::MonitorName::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireSystem::MonitorName::what );
            
            MonitorName_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        MonitorName_exposer.staticmethod( "typeName" );
        MonitorName_exposer.def( "__copy__", &__copy__);
        MonitorName_exposer.def( "__deepcopy__", &__copy__);
        MonitorName_exposer.def( "clone", &__copy__);
        MonitorName_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::MonitorName >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MonitorName_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::MonitorName >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MonitorName_exposer.def( "__str__", &__str__< ::SireSystem::MonitorName > );
        MonitorName_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorName > );
        MonitorName_exposer.def( "__hash__", &::SireSystem::MonitorName::hash );
    }

}
Beispiel #14
0
void register_ChainsWithRes_class(){

    { //::SireMol::ChainsWithRes
        typedef bp::class_< SireMol::ChainsWithRes, bp::bases< SireMol::ChainID, SireID::ID > > ChainsWithRes_exposer_t;
        ChainsWithRes_exposer_t ChainsWithRes_exposer = ChainsWithRes_exposer_t( "ChainsWithRes", "This ID class identifies chains that contain residues that\nmatch the passed ResID\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope ChainsWithRes_scope( ChainsWithRes_exposer );
        ChainsWithRes_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") ), "Construct from the passed residue ID") );
        ChainsWithRes_exposer.def( bp::init< SireMol::ChainsWithRes const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMol::ChainsWithRes::hash
        
            typedef ::uint ( ::SireMol::ChainsWithRes::*hash_function_type)(  ) const;
            hash_function_type hash_function_value( &::SireMol::ChainsWithRes::hash );
            
            ChainsWithRes_exposer.def( 
                "hash"
                , hash_function_value
                , "Return a hash of this identifier" );
        
        }
        { //::SireMol::ChainsWithRes::isNull
        
            typedef bool ( ::SireMol::ChainsWithRes::*isNull_function_type)(  ) const;
            isNull_function_type isNull_function_value( &::SireMol::ChainsWithRes::isNull );
            
            ChainsWithRes_exposer.def( 
                "isNull"
                , isNull_function_value
                , "Is this selection null?" );
        
        }
        { //::SireMol::ChainsWithRes::map
        
            typedef ::QList< SireMol::ChainIdx > ( ::SireMol::ChainsWithRes::*map_function_type)( ::SireMol::MolInfo const & ) const;
            map_function_type map_function_value( &::SireMol::ChainsWithRes::map );
            
            ChainsWithRes_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("molinfo") )
                , "Map this ID to the list of indicies of chains that match this ID\nThrow: SireMol::missing_chain\nThrow: SireError::invalid_index\n" );
        
        }
        ChainsWithRes_exposer.def( bp::self != bp::self );
        { //::SireMol::ChainsWithRes::operator=
        
            typedef ::SireMol::ChainsWithRes & ( ::SireMol::ChainsWithRes::*assign_function_type)( ::SireMol::ChainsWithRes const & ) ;
            assign_function_type assign_function_value( &::SireMol::ChainsWithRes::operator= );
            
            ChainsWithRes_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        ChainsWithRes_exposer.def( bp::self == bp::other< SireID::ID >() );
        ChainsWithRes_exposer.def( bp::self == bp::self );
        { //::SireMol::ChainsWithRes::resID
        
            typedef ::SireMol::ResID const & ( ::SireMol::ChainsWithRes::*resID_function_type)(  ) const;
            resID_function_type resID_function_value( &::SireMol::ChainsWithRes::resID );
            
            ChainsWithRes_exposer.def( 
                "resID"
                , resID_function_value
                , bp::return_value_policy<bp::clone_const_reference>()
                , "Return the residue ID" );
        
        }
        { //::SireMol::ChainsWithRes::toString
        
            typedef ::QString ( ::SireMol::ChainsWithRes::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::ChainsWithRes::toString );
            
            ChainsWithRes_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representatio of this ID" );
        
        }
        { //::SireMol::ChainsWithRes::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ChainsWithRes::typeName );
            
            ChainsWithRes_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMol::ChainsWithRes::what
        
            typedef char const * ( ::SireMol::ChainsWithRes::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMol::ChainsWithRes::what );
            
            ChainsWithRes_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        ChainsWithRes_exposer.staticmethod( "typeName" );
        ChainsWithRes_exposer.def( "__copy__", &__copy__);
        ChainsWithRes_exposer.def( "__deepcopy__", &__copy__);
        ChainsWithRes_exposer.def( "clone", &__copy__);
        ChainsWithRes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChainsWithRes >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainsWithRes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChainsWithRes >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChainsWithRes_exposer.def( "__str__", &__str__< ::SireMol::ChainsWithRes > );
        ChainsWithRes_exposer.def( "__repr__", &__str__< ::SireMol::ChainsWithRes > );
        ChainsWithRes_exposer.def( "__hash__", &::SireMol::ChainsWithRes::hash );
    }

}
void register_MolPotentialTable_class(){

    { //::SireFF::MolPotentialTable
        typedef bp::class_< SireFF::MolPotentialTable > MolPotentialTable_exposer_t;
        MolPotentialTable_exposer_t MolPotentialTable_exposer = MolPotentialTable_exposer_t( "MolPotentialTable", bp::init< >() );
        bp::scope MolPotentialTable_scope( MolPotentialTable_exposer );
        MolPotentialTable_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molview") )) );
        MolPotentialTable_exposer.def( bp::init< SireFF::MolPotentialTable const & >(( bp::arg("other") )) );
        { //::SireFF::MolPotentialTable::add
        
            typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("cgatomidx"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("selected_atoms"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireFF::MolPotentialTable const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::MolPotentialTable::add
        
            typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
            
            MolPotentialTable_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::divide
        
            typedef void ( ::SireFF::MolPotentialTable::*divide_function_type )( double ) ;
            divide_function_type divide_function_value( &::SireFF::MolPotentialTable::divide );
            
            MolPotentialTable_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::MolPotentialTable::initialise
        
            typedef void ( ::SireFF::MolPotentialTable::*initialise_function_type )(  ) ;
            initialise_function_type initialise_function_value( &::SireFF::MolPotentialTable::initialise );
            
            MolPotentialTable_exposer.def( 
                "initialise"
                , initialise_function_value );
        
        }
        { //::SireFF::MolPotentialTable::map
        
            typedef int ( ::SireFF::MolPotentialTable::*map_function_type )( ::SireMol::CGIdx ) const;
            map_function_type map_function_value( &::SireFF::MolPotentialTable::map );
            
            MolPotentialTable_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireFF::MolPotentialTable::molNum
        
            typedef ::SireMol::MolNum ( ::SireFF::MolPotentialTable::*molNum_function_type )(  ) const;
            molNum_function_type molNum_function_value( &::SireFF::MolPotentialTable::molNum );
            
            MolPotentialTable_exposer.def( 
                "molNum"
                , molNum_function_value );
        
        }
        { //::SireFF::MolPotentialTable::molUID
        
            typedef ::QUuid const & ( ::SireFF::MolPotentialTable::*molUID_function_type )(  ) const;
            molUID_function_type molUID_function_value( &::SireFF::MolPotentialTable::molUID );
            
            MolPotentialTable_exposer.def( 
                "molUID"
                , molUID_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::MolPotentialTable::multiply
        
            typedef void ( ::SireFF::MolPotentialTable::*multiply_function_type )( double ) ;
            multiply_function_type multiply_function_value( &::SireFF::MolPotentialTable::multiply );
            
            MolPotentialTable_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireFF::MolPotentialTable::nCutGroups
        
            typedef int ( ::SireFF::MolPotentialTable::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireFF::MolPotentialTable::nCutGroups );
            
            MolPotentialTable_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        { //::SireFF::MolPotentialTable::nSelectedCutGroups
        
            typedef int ( ::SireFF::MolPotentialTable::*nSelectedCutGroups_function_type )(  ) const;
            nSelectedCutGroups_function_type nSelectedCutGroups_function_value( &::SireFF::MolPotentialTable::nSelectedCutGroups );
            
            MolPotentialTable_exposer.def( 
                "nSelectedCutGroups"
                , nSelectedCutGroups_function_value );
        
        }
        MolPotentialTable_exposer.def( bp::self != bp::self );
        MolPotentialTable_exposer.def( bp::self * bp::other< double >() );
        MolPotentialTable_exposer.def( bp::self + bp::self );
        MolPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        MolPotentialTable_exposer.def( bp::self - bp::self );
        MolPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
        MolPotentialTable_exposer.def( -bp::self );
        MolPotentialTable_exposer.def( bp::self / bp::other< double >() );
        { //::SireFF::MolPotentialTable::operator=
        
            typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireFF::MolPotentialTable const & ) ;
            assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
            
            MolPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireFF::MolPotentialTable::operator=
        
            typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
            
            MolPotentialTable_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("potential") )
                , bp::return_self< >() );
        
        }
        MolPotentialTable_exposer.def( bp::self == bp::self );
        { //::SireFF::MolPotentialTable::selected
        
            typedef bool ( ::SireFF::MolPotentialTable::*selected_function_type )( ::SireMol::CGIdx ) const;
            selected_function_type selected_function_value( &::SireFF::MolPotentialTable::selected );
            
            MolPotentialTable_exposer.def( 
                "selected"
                , selected_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireFF::MolPotentialTable::selectedAll
        
            typedef bool ( ::SireFF::MolPotentialTable::*selectedAll_function_type )(  ) const;
            selectedAll_function_type selectedAll_function_value( &::SireFF::MolPotentialTable::selectedAll );
            
            MolPotentialTable_exposer.def( 
                "selectedAll"
                , selectedAll_function_value );
        
        }
        { //::SireFF::MolPotentialTable::setAll
        
            typedef void ( ::SireFF::MolPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            setAll_function_type setAll_function_value( &::SireFF::MolPotentialTable::setAll );
            
            MolPotentialTable_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::subtract
        
            typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
            
            MolPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("cgatomidx"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::subtract
        
            typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
            
            MolPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("selected_atoms"), bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::subtract
        
            typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireFF::MolPotentialTable const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
            
            MolPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireFF::MolPotentialTable::subtract
        
            typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
            subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
            
            MolPotentialTable_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("potential") ) );
        
        }
        { //::SireFF::MolPotentialTable::toVector
        
            typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
            
            MolPotentialTable_exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireFF::MolPotentialTable::toVector
        
            typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
            toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
            
            MolPotentialTable_exposer.def( 
                "toVector"
                , toVector_function_value
                , ( bp::arg("selection") ) );
        
        }
        { //::SireFF::MolPotentialTable::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireFF::MolPotentialTable::typeName );
            
            MolPotentialTable_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireFF::MolPotentialTable::what
        
            typedef char const * ( ::SireFF::MolPotentialTable::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireFF::MolPotentialTable::what );
            
            MolPotentialTable_exposer.def( 
                "what"
                , what_function_value );
        
        }
        MolPotentialTable_exposer.staticmethod( "typeName" );
        MolPotentialTable_exposer.def( "__copy__", &__copy__);
        MolPotentialTable_exposer.def( "__deepcopy__", &__copy__);
        MolPotentialTable_exposer.def( "clone", &__copy__);
        MolPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::MolPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::MolPotentialTable >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        MolPotentialTable_exposer.def( "__str__", &__str__< ::SireFF::MolPotentialTable > );
        MolPotentialTable_exposer.def( "__repr__", &__str__< ::SireFF::MolPotentialTable > );
        MolPotentialTable_exposer.def( "__len__", &__len_size< ::SireFF::MolPotentialTable > );
    }

}
Beispiel #16
0
void register_MonitorID_class(){

    { //::SireSystem::MonitorID
        typedef bp::class_< SireSystem::MonitorID, bp::bases< SireID::ID >, boost::noncopyable > MonitorID_exposer_t;
        MonitorID_exposer_t MonitorID_exposer = MonitorID_exposer_t( "MonitorID", bp::no_init );
        bp::scope MonitorID_scope( MonitorID_exposer );
        { //::SireSystem::MonitorID::map
        
            typedef ::QList< SireSystem::MonitorName > ( ::SireSystem::MonitorID::*map_function_type )( ::SireSystem::SystemMonitors const & ) const;
            map_function_type map_function_value( &::SireSystem::MonitorID::map );
            
            MonitorID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("monitors") ) );
        
        }
        MonitorID_exposer.def( bp::self & bp::self );
        { //::SireSystem::MonitorID::operator()
        
            typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__call___function_type )( int ) const;
            __call___function_type __call___function_value( &::SireSystem::MonitorID::operator() );
            
            MonitorID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireSystem::MonitorID::operator()
        
            typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireSystem::MonitorID::operator() );
            
            MonitorID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        MonitorID_exposer.def( bp::self * bp::self );
        MonitorID_exposer.def( bp::self + bp::self );
        { //::SireSystem::MonitorID::operator[]
        
            typedef ::SireID::Specify< SireSystem::MonitorID > ( ::SireSystem::MonitorID::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireSystem::MonitorID::operator[] );
            
            MonitorID_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") ) );
        
        }
        MonitorID_exposer.def( bp::self | bp::self );
        { //::SireSystem::MonitorID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireSystem::MonitorID::typeName );
            
            MonitorID_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        MonitorID_exposer.staticmethod( "typeName" );
        MonitorID_exposer.def( "__str__", &__str__< ::SireSystem::MonitorID > );
        MonitorID_exposer.def( "__repr__", &__str__< ::SireSystem::MonitorID > );
    }

}
Beispiel #17
0
void register_SysID_class(){

    { //::SireSystem::SysID
        typedef bp::class_< SireSystem::SysID, bp::bases< SireID::ID >, boost::noncopyable > SysID_exposer_t;
        SysID_exposer_t SysID_exposer = SysID_exposer_t( "SysID", "The base class of all system identifiers\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope SysID_scope( SysID_exposer );
        { //::SireSystem::SysID::map
        
            typedef ::QList< SireSystem::SysIdx > ( ::SireSystem::SysID::*map_function_type)( ::SireSystem::Systems const & ) const;
            map_function_type map_function_value( &::SireSystem::SysID::map );
            
            SysID_exposer.def( 
                "map"
                , map_function_value
                , ( bp::arg("systems") )
                , "" );
        
        }
        SysID_exposer.def( bp::self & bp::self );
        { //::SireSystem::SysID::operator()
        
            typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__call___function_type)( int ) const;
            __call___function_type __call___function_value( &::SireSystem::SysID::operator() );
            
            SysID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        { //::SireSystem::SysID::operator()
        
            typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__call___function_type)( int,int ) const;
            __call___function_type __call___function_value( &::SireSystem::SysID::operator() );
            
            SysID_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "" );
        
        }
        SysID_exposer.def( bp::self * bp::self );
        SysID_exposer.def( bp::self + bp::self );
        { //::SireSystem::SysID::operator[]
        
            typedef ::SireID::Specify< SireSystem::SysID > ( ::SireSystem::SysID::*__getitem___function_type)( int ) const;
            __getitem___function_type __getitem___function_value( &::SireSystem::SysID::operator[] );
            
            SysID_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , "" );
        
        }
        SysID_exposer.def( bp::self | bp::self );
        { //::SireSystem::SysID::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireSystem::SysID::typeName );
            
            SysID_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        SysID_exposer.staticmethod( "typeName" );
        SysID_exposer.def( "__str__", &__str__< ::SireSystem::SysID > );
        SysID_exposer.def( "__repr__", &__str__< ::SireSystem::SysID > );
        SysID_exposer.def( "__hash__", &::SireSystem::SysID::hash );
    }

}