void register_ChemicalBondHunter_class(){

    { //::SireMol::ChemicalBondHunter
        typedef bp::class_< SireMol::ChemicalBondHunter, bp::bases< SireMol::CovalentBondHunter, SireMol::BondHunter, SireBase::Property > > ChemicalBondHunter_exposer_t;
        ChemicalBondHunter_exposer_t ChemicalBondHunter_exposer = ChemicalBondHunter_exposer_t( "ChemicalBondHunter", bp::init< >() );
        bp::scope ChemicalBondHunter_scope( ChemicalBondHunter_exposer );
        ChemicalBondHunter_exposer.def( bp::init< double >(( bp::arg("tolerance") )) );
        ChemicalBondHunter_exposer.def( bp::init< SireMol::ChemicalBondHunter const & >(( bp::arg("other") )) );
        { //::SireMol::ChemicalBondHunter::operator()
        
            typedef ::SireMol::Connectivity ( ::SireMol::ChemicalBondHunter::*__call___function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) const;
            __call___function_type __call___function_value( &::SireMol::ChemicalBondHunter::operator() );
            
            ChemicalBondHunter_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("molview"), bp::arg("map")=SireBase::PropertyMap() ) );
        
        }
        { //::SireMol::ChemicalBondHunter::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::ChemicalBondHunter::typeName );
            
            ChemicalBondHunter_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        ChemicalBondHunter_exposer.staticmethod( "typeName" );
        ChemicalBondHunter_exposer.def( "__copy__", &__copy__);
        ChemicalBondHunter_exposer.def( "__deepcopy__", &__copy__);
        ChemicalBondHunter_exposer.def( "clone", &__copy__);
        ChemicalBondHunter_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ChemicalBondHunter >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChemicalBondHunter_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ChemicalBondHunter >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        ChemicalBondHunter_exposer.def( "__str__", &__str__< ::SireMol::ChemicalBondHunter > );
        ChemicalBondHunter_exposer.def( "__repr__", &__str__< ::SireMol::ChemicalBondHunter > );
    }

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

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

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

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

}
Example #6
0
void register_Expression_class(){

    { //::SireCAS::Expression
        typedef bp::class_< SireCAS::Expression > Expression_exposer_t;
        Expression_exposer_t Expression_exposer = Expression_exposer_t( "Expression", bp::init< >() );
        bp::scope Expression_scope( Expression_exposer );
        Expression_exposer.def( bp::init< int >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Rational const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< double >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireMaths::Complex const & >(( bp::arg("constant") )) );
        Expression_exposer.def( bp::init< SireCAS::ExpressionBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::ExBase const & >(( bp::arg("base") )) );
        Expression_exposer.def( bp::init< SireCAS::Expression const & >(( bp::arg("other") )) );
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireCAS::Expression const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( double ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::add
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*add_function_type )( ::SireMaths::Complex const & ) const;
            add_function_type add_function_value( &::SireCAS::Expression::add );
            
            Expression_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::base
        
            typedef ::SireCAS::ExpressionBase const & ( ::SireCAS::Expression::*base_function_type )(  ) const;
            base_function_type base_function_value( &::SireCAS::Expression::base );
            
            Expression_exposer.def( 
                "base"
                , base_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireCAS::Expression::children
        
            typedef ::SireCAS::Expressions ( ::SireCAS::Expression::*children_function_type )(  ) const;
            children_function_type children_function_value( &::SireCAS::Expression::children );
            
            Expression_exposer.def( 
                "children"
                , children_function_value );
        
        }
        { //::SireCAS::Expression::conjugate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*conjugate_function_type )(  ) const;
            conjugate_function_type conjugate_function_value( &::SireCAS::Expression::conjugate );
            
            Expression_exposer.def( 
                "conjugate"
                , conjugate_function_value );
        
        }
        { //::SireCAS::Expression::cubed
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*cubed_function_type )(  ) const;
            cubed_function_type cubed_function_value( &::SireCAS::Expression::cubed );
            
            Expression_exposer.def( 
                "cubed"
                , cubed_function_value );
        
        }
        { //::SireCAS::Expression::diff
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*diff_function_type )( ::SireCAS::Symbol const &,int ) const;
            diff_function_type diff_function_value( &::SireCAS::Expression::diff );
            
            Expression_exposer.def( 
                "diff"
                , diff_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::differentiate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*differentiate_function_type )( ::SireCAS::Symbol const &,int ) const;
            differentiate_function_type differentiate_function_value( &::SireCAS::Expression::differentiate );
            
            Expression_exposer.def( 
                "differentiate"
                , differentiate_function_value
                , ( bp::arg("symbol"), bp::arg("level")=(int)(1) ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireCAS::Expression const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( double ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::divide
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*divide_function_type )( ::SireMaths::Complex const & ) const;
            divide_function_type divide_function_value( &::SireCAS::Expression::divide );
            
            Expression_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef double ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::Values const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::evaluate
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*evaluate_function_type )( ::SireCAS::ComplexValues const & ) const;
            evaluate_function_type evaluate_function_value( &::SireCAS::Expression::evaluate );
            
            Expression_exposer.def( 
                "evaluate"
                , evaluate_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::expand
        
            typedef ::QList< SireCAS::Factor > ( ::SireCAS::Expression::*expand_function_type )( ::SireCAS::Symbol const & ) const;
            expand_function_type expand_function_value( &::SireCAS::Expression::expand );
            
            Expression_exposer.def( 
                "expand"
                , expand_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::factor
        
            typedef double ( ::SireCAS::Expression::*factor_function_type )(  ) const;
            factor_function_type factor_function_value( &::SireCAS::Expression::factor );
            
            Expression_exposer.def( 
                "factor"
                , factor_function_value );
        
        }
        { //::SireCAS::Expression::functions
        
            typedef ::SireCAS::Functions ( ::SireCAS::Expression::*functions_function_type )(  ) const;
            functions_function_type functions_function_value( &::SireCAS::Expression::functions );
            
            Expression_exposer.def( 
                "functions"
                , functions_function_value );
        
        }
        { //::SireCAS::Expression::hash
        
            typedef ::uint ( ::SireCAS::Expression::*hash_function_type )(  ) const;
            hash_function_type hash_function_value( &::SireCAS::Expression::hash );
            
            Expression_exposer.def( 
                "hash"
                , hash_function_value );
        
        }
        { //::SireCAS::Expression::integ
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integ_function_type )( ::SireCAS::Symbol const & ) const;
            integ_function_type integ_function_value( &::SireCAS::Expression::integ );
            
            Expression_exposer.def( 
                "integ"
                , integ_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::integrate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*integrate_function_type )( ::SireCAS::Symbol const & ) const;
            integrate_function_type integrate_function_value( &::SireCAS::Expression::integrate );
            
            Expression_exposer.def( 
                "integrate"
                , integrate_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::invert
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*invert_function_type )(  ) const;
            invert_function_type invert_function_value( &::SireCAS::Expression::invert );
            
            Expression_exposer.def( 
                "invert"
                , invert_function_value );
        
        }
        { //::SireCAS::Expression::isComplex
        
            typedef bool ( ::SireCAS::Expression::*isComplex_function_type )(  ) const;
            isComplex_function_type isComplex_function_value( &::SireCAS::Expression::isComplex );
            
            Expression_exposer.def( 
                "isComplex"
                , isComplex_function_value );
        
        }
        { //::SireCAS::Expression::isCompound
        
            typedef bool ( ::SireCAS::Expression::*isCompound_function_type )(  ) const;
            isCompound_function_type isCompound_function_value( &::SireCAS::Expression::isCompound );
            
            Expression_exposer.def( 
                "isCompound"
                , isCompound_function_value );
        
        }
        { //::SireCAS::Expression::isConstant
        
            typedef bool ( ::SireCAS::Expression::*isConstant_function_type )(  ) const;
            isConstant_function_type isConstant_function_value( &::SireCAS::Expression::isConstant );
            
            Expression_exposer.def( 
                "isConstant"
                , isConstant_function_value );
        
        }
        { //::SireCAS::Expression::isFunction
        
            typedef bool ( ::SireCAS::Expression::*isFunction_function_type )( ::SireCAS::Symbol const & ) const;
            isFunction_function_type isFunction_function_value( &::SireCAS::Expression::isFunction );
            
            Expression_exposer.def( 
                "isFunction"
                , isFunction_function_value
                , ( bp::arg("symbol") ) );
        
        }
        { //::SireCAS::Expression::isZero
        
            typedef bool ( ::SireCAS::Expression::*isZero_function_type )(  ) const;
            isZero_function_type isZero_function_value( &::SireCAS::Expression::isZero );
            
            Expression_exposer.def( 
                "isZero"
                , isZero_function_value );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireCAS::Expression const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( double ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::multiply
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*multiply_function_type )( ::SireMaths::Complex const & ) const;
            multiply_function_type multiply_function_value( &::SireCAS::Expression::multiply );
            
            Expression_exposer.def( 
                "multiply"
                , multiply_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::negate
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*negate_function_type )(  ) const;
            negate_function_type negate_function_value( &::SireCAS::Expression::negate );
            
            Expression_exposer.def( 
                "negate"
                , negate_function_value );
        
        }
        Expression_exposer.def( bp::self != bp::self );
        { //::SireCAS::Expression::operator()
        
            typedef double ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::Values const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireCAS::Expression::operator()
        
            typedef ::SireMaths::Complex ( ::SireCAS::Expression::*__call___function_type )( ::SireCAS::ComplexValues const & ) const;
            __call___function_type __call___function_value( &::SireCAS::Expression::operator() );
            
            Expression_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("values") ) );
        
        }
        Expression_exposer.def( -bp::self );
        { //::SireCAS::Expression::operator=
        
            typedef ::SireCAS::Expression & ( ::SireCAS::Expression::*assign_function_type )( ::SireCAS::Expression const & ) ;
            assign_function_type assign_function_value( &::SireCAS::Expression::operator= );
            
            Expression_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Expression_exposer.def( bp::self == bp::self );
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( int ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Rational const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( double ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireMaths::Complex const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::pow
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*pow_function_type )( ::SireCAS::Expression const & ) const;
            pow_function_type pow_function_value( &::SireCAS::Expression::pow );
            
            Expression_exposer.def( 
                "pow"
                , pow_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::root
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*root_function_type )( int ) const;
            root_function_type root_function_value( &::SireCAS::Expression::root );
            
            Expression_exposer.def( 
                "root"
                , root_function_value
                , ( bp::arg("n") ) );
        
        }
        { //::SireCAS::Expression::series
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*series_function_type )( ::SireCAS::Symbol const &,int ) const;
            series_function_type series_function_value( &::SireCAS::Expression::series );
            
            Expression_exposer.def( 
                "series"
                , series_function_value
                , ( bp::arg("symbol"), bp::arg("order") ) );
        
        }
        { //::SireCAS::Expression::simplify
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*simplify_function_type )( int ) const;
            simplify_function_type simplify_function_value( &::SireCAS::Expression::simplify );
            
            Expression_exposer.def( 
                "simplify"
                , simplify_function_value
                , ( bp::arg("options")=(int)(0) ) );
        
        }
        { //::SireCAS::Expression::squared
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*squared_function_type )(  ) const;
            squared_function_type squared_function_value( &::SireCAS::Expression::squared );
            
            Expression_exposer.def( 
                "squared"
                , squared_function_value );
        
        }
        { //::SireCAS::Expression::substitute
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*substitute_function_type )( ::SireCAS::Identities const & ) const;
            substitute_function_type substitute_function_value( &::SireCAS::Expression::substitute );
            
            Expression_exposer.def( 
                "substitute"
                , substitute_function_value
                , ( bp::arg("identities") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireCAS::Expression const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("ex") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::subtract
        
            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;
            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );
            
            Expression_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("val") ) );
        
        }
        { //::SireCAS::Expression::symbols
        
            typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )(  ) const;
            symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );
            
            Expression_exposer.def( 
                "symbols"
                , symbols_function_value );
        
        }
        { //::SireCAS::Expression::toString
        
            typedef ::QString ( ::SireCAS::Expression::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireCAS::Expression::toString );
            
            Expression_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireCAS::Expression::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );
            
            Expression_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireCAS::Expression::what
        
            typedef char const * ( ::SireCAS::Expression::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireCAS::Expression::what );
            
            Expression_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Expression_exposer.staticmethod( "typeName" );
        Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );
        Expression_exposer.def( bp::self * bp::other< double >() );
        Expression_exposer.def( bp::other< double >() * bp::self );
        Expression_exposer.def( bp::self * bp::self );
        Expression_exposer.def( bp::self * bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() + bp::self );
        Expression_exposer.def( bp::self + bp::other< double >() );
        Expression_exposer.def( bp::self + bp::self );
        Expression_exposer.def( bp::self + bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< double >() - bp::self );
        Expression_exposer.def( bp::self - bp::other< double >() );
        Expression_exposer.def( bp::self - bp::self );
        Expression_exposer.def( bp::self - bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( bp::other< SireMaths::Complex >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireMaths::Complex >() );
        Expression_exposer.def( bp::other< double >() / bp::self );
        Expression_exposer.def( bp::self / bp::other< double >() );
        Expression_exposer.def( bp::self / bp::self );
        Expression_exposer.def( bp::self / bp::other< SireCAS::ExBase >() );
        Expression_exposer.def( self + self );
        Expression_exposer.def( self - self );
        Expression_exposer.def( self * self );
        Expression_exposer.def( self / self );
        Expression_exposer.def( other<double>() + self );
        Expression_exposer.def( other<double>() - self );
        Expression_exposer.def( other<double>() * self );
        Expression_exposer.def( other<double>() / self );
        Expression_exposer.def( self + other<double>() );
        Expression_exposer.def( self - other<double>() );
        Expression_exposer.def( self * other<double>() );
        Expression_exposer.def( self / other<double>() );
        Expression_exposer.def( other<SireMaths::Complex>() + self );
        Expression_exposer.def( other<SireMaths::Complex>() - self );
        Expression_exposer.def( other<SireMaths::Complex>() * self );
        Expression_exposer.def( other<SireMaths::Complex>() / self );
        Expression_exposer.def( self + other<SireMaths::Complex>() );
        Expression_exposer.def( self - other<SireMaths::Complex>() );
        Expression_exposer.def( self * other<SireMaths::Complex>() );
        Expression_exposer.def( self / other<SireMaths::Complex>() );
        Expression_exposer.def( other<SireCAS::ExBase>() + self );
        Expression_exposer.def( other<SireCAS::ExBase>() - self );
        Expression_exposer.def( other<SireCAS::ExBase>() * self );
        Expression_exposer.def( other<SireCAS::ExBase>() / self );
        Expression_exposer.def( self + other<SireCAS::ExBase>() );
        Expression_exposer.def( self - other<SireCAS::ExBase>() );
        Expression_exposer.def( self * other<SireCAS::ExBase>() );
        Expression_exposer.def( self / other<SireCAS::ExBase>() );
        Expression_exposer.def( "__copy__", &__copy__);
        Expression_exposer.def( "__deepcopy__", &__copy__);
        Expression_exposer.def( "clone", &__copy__);
        Expression_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::Expression >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Expression_exposer.def( "__str__", &__str__< ::SireCAS::Expression > );
        Expression_exposer.def( "__repr__", &__str__< ::SireCAS::Expression > );
    }

}
void register_TrigArray2D_double__class(){

    { //::SireBase::TrigArray2D< double >
        typedef bp::class_< SireBase::TrigArray2D< double >, bp::bases< SireBase::TrigArray2DBase > > TrigArray2D_double__exposer_t;
        TrigArray2D_double__exposer_t TrigArray2D_double__exposer = TrigArray2D_double__exposer_t( "TrigArray2D_double_", bp::init< >() );
        bp::scope TrigArray2D_double__scope( TrigArray2D_double__exposer );
        TrigArray2D_double__exposer.def( bp::init< int >(( bp::arg("dimension") )) );
        TrigArray2D_double__exposer.def( bp::init< int, double const & >(( bp::arg("dimension"), bp::arg("default_value") )) );
        TrigArray2D_double__exposer.def( bp::init< SireBase::TrigArray2D< double > const & >(( bp::arg("other") )) );
        { //::SireBase::TrigArray2D< double >::at
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef double const & ( ::SireBase::TrigArray2D< double >::*at_function_type )( int,int ) const;
            at_function_type at_function_value( &::SireBase::TrigArray2D< double >::at );
            
            TrigArray2D_double__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::TrigArray2D< double >::get
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef double const & ( ::SireBase::TrigArray2D< double >::*get_function_type )( int,int ) const;
            get_function_type get_function_value( &::SireBase::TrigArray2D< double >::get );
            
            TrigArray2D_double__exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        TrigArray2D_double__exposer.def( bp::self != bp::self );
        { //::SireBase::TrigArray2D< double >::operator()
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef double const & ( ::SireBase::TrigArray2D< double >::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireBase::TrigArray2D< double >::operator() );
            
            TrigArray2D_double__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::TrigArray2D< double >::operator=
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef ::SireBase::TrigArray2D< double > & ( ::SireBase::TrigArray2D< double >::*assign_function_type )( ::SireBase::TrigArray2D< double > const & ) ;
            assign_function_type assign_function_value( &::SireBase::TrigArray2D< double >::operator= );
            
            TrigArray2D_double__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        TrigArray2D_double__exposer.def( bp::self == bp::self );
        { //::SireBase::TrigArray2D< double >::redimension
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef void ( ::SireBase::TrigArray2D< double >::*redimension_function_type )( int ) ;
            redimension_function_type redimension_function_value( &::SireBase::TrigArray2D< double >::redimension );
            
            TrigArray2D_double__exposer.def( 
                "redimension"
                , redimension_function_value
                , ( bp::arg("dimension") ) );
        
        }
        { //::SireBase::TrigArray2D< double >::set
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef void ( ::SireBase::TrigArray2D< double >::*set_function_type )( int,int,double const & ) ;
            set_function_type set_function_value( &::SireBase::TrigArray2D< double >::set );
            
            TrigArray2D_double__exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
        
        }
        { //::SireBase::TrigArray2D< double >::setAll
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef void ( ::SireBase::TrigArray2D< double >::*setAll_function_type )( double const & ) ;
            setAll_function_type setAll_function_value( &::SireBase::TrigArray2D< double >::setAll );
            
            TrigArray2D_double__exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::TrigArray2D< double >::toString
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef ::QString ( ::SireBase::TrigArray2D< double >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireBase::TrigArray2D< double >::toString );
            
            TrigArray2D_double__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireBase::TrigArray2D< double >::transpose
        
            typedef SireBase::TrigArray2D< double > exported_class_t;
            typedef ::SireBase::TrigArray2D< double > ( ::SireBase::TrigArray2D< double >::*transpose_function_type )(  ) const;
            transpose_function_type transpose_function_value( &::SireBase::TrigArray2D< double >::transpose );
            
            TrigArray2D_double__exposer.def( 
                "transpose"
                , transpose_function_value );
        
        }
        TrigArray2D_double__exposer.def( "__copy__", &__copy__);
        TrigArray2D_double__exposer.def( "__deepcopy__", &__copy__);
        TrigArray2D_double__exposer.def( "clone", &__copy__);
        TrigArray2D_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::TrigArray2D<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        TrigArray2D_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::TrigArray2D<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        TrigArray2D_double__exposer.def( "__str__", &__str__< ::SireBase::TrigArray2D<double> > );
        TrigArray2D_double__exposer.def( "__repr__", &__str__< ::SireBase::TrigArray2D<double> > );
        TrigArray2D_double__exposer.def( "__len__", &__len_size< ::SireBase::TrigArray2D<double> > );
    }

}
Example #8
0
void register_N4Matrix_class(){

    { //::SireMaths::N4Matrix
        typedef bp::class_< SireMaths::N4Matrix > N4Matrix_exposer_t;
        N4Matrix_exposer_t N4Matrix_exposer = N4Matrix_exposer_t( "N4Matrix", "This is a dense, double, general NMLK 4-dimensional matrix.\nThe data is stored as a column-major 2D matrix of column-major\n2D matricies (so each 2D sub-matrix is suitable for\nuse with Fortran BLAS or LAPACK functions). This is\ndesigned for high speed.\n\nThe data is implicitly shared (copy on write), so\ncopying a matrix is very fast.\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope N4Matrix_scope( N4Matrix_exposer );
        N4Matrix_exposer.def( bp::init< int, int, int, int >(( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("columns") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are not initialised") );
        N4Matrix_exposer.def( bp::init< int, int, int, int, double >(( bp::arg("nbigrows"), bp::arg("nbigcolumn"), bp::arg("nrows"), bp::arg("ncolumns"), bp::arg("initial_value") ), "Construct a matrix with nbigrows big rows, nbigcolumns big columns,\nnrows rows and ncolumns columns. The values in the matrix are\ninitialised to be equal to initial_value") );
        N4Matrix_exposer.def( bp::init< SireMaths::NMatrix const & >(( bp::arg("matrix") ), "Construct from the passed matrix - this creates a matrix\nof dimension [1, 1, matrix.nRows(), matrix.nColumns()]") );
        N4Matrix_exposer.def( bp::init< SireBase::Array2D< SireMaths::NMatrix > const & >(( bp::arg("matrix") ), "Construct from the passed Array or Matricies") );
        N4Matrix_exposer.def( bp::init< QVector< QVector< QVector< QVector< double > > > > const & >(( bp::arg("matrix") ), "Construct from the passed vector of vector of vector of vectors...") );
        N4Matrix_exposer.def( bp::init< SireMaths::N4Matrix const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMaths::N4Matrix::add
        
            typedef void ( ::SireMaths::N4Matrix::*add_function_type)( int,int,::SireMaths::NMatrix const & ) ;
            add_function_type add_function_value( &::SireMaths::N4Matrix::add );
            
            N4Matrix_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
                , "Add the contents of matrix to the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::assertNBigColumns
        
            typedef void ( ::SireMaths::N4Matrix::*assertNBigColumns_function_type)( int ) const;
            assertNBigColumns_function_type assertNBigColumns_function_value( &::SireMaths::N4Matrix::assertNBigColumns );
            
            N4Matrix_exposer.def( 
                "assertNBigColumns"
                , assertNBigColumns_function_value
                , ( bp::arg("nbigcolumns") )
                , "Assert that this matrix has nbigcolumns big columns\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::assertNBigRows
        
            typedef void ( ::SireMaths::N4Matrix::*assertNBigRows_function_type)( int ) const;
            assertNBigRows_function_type assertNBigRows_function_value( &::SireMaths::N4Matrix::assertNBigRows );
            
            N4Matrix_exposer.def( 
                "assertNBigRows"
                , assertNBigRows_function_value
                , ( bp::arg("nbigrows") )
                , "Assert that this matrix has nbigrows big rows\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::assertNColumns
        
            typedef void ( ::SireMaths::N4Matrix::*assertNColumns_function_type)( int ) const;
            assertNColumns_function_type assertNColumns_function_value( &::SireMaths::N4Matrix::assertNColumns );
            
            N4Matrix_exposer.def( 
                "assertNColumns"
                , assertNColumns_function_value
                , ( bp::arg("ncolumns") )
                , "Assert that this matrix has ncolumns columns\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::assertNRows
        
            typedef void ( ::SireMaths::N4Matrix::*assertNRows_function_type)( int ) const;
            assertNRows_function_type assertNRows_function_value( &::SireMaths::N4Matrix::assertNRows );
            
            N4Matrix_exposer.def( 
                "assertNRows"
                , assertNRows_function_value
                , ( bp::arg("nrows") )
                , "Assert that this matrix has nrows rows\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::assertValidBigColumn
        
            typedef void ( ::SireMaths::N4Matrix::*assertValidBigColumn_function_type)( int ) const;
            assertValidBigColumn_function_type assertValidBigColumn_function_value( &::SireMaths::N4Matrix::assertValidBigColumn );
            
            N4Matrix_exposer.def( 
                "assertValidBigColumn"
                , assertValidBigColumn_function_value
                , ( bp::arg("j") )
                , "Assert that there is an jth big column\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::assertValidBigRow
        
            typedef void ( ::SireMaths::N4Matrix::*assertValidBigRow_function_type)( int ) const;
            assertValidBigRow_function_type assertValidBigRow_function_value( &::SireMaths::N4Matrix::assertValidBigRow );
            
            N4Matrix_exposer.def( 
                "assertValidBigRow"
                , assertValidBigRow_function_value
                , ( bp::arg("i") )
                , "Assert that there is an ith big row\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::assertValidColumn
        
            typedef void ( ::SireMaths::N4Matrix::*assertValidColumn_function_type)( int ) const;
            assertValidColumn_function_type assertValidColumn_function_value( &::SireMaths::N4Matrix::assertValidColumn );
            
            N4Matrix_exposer.def( 
                "assertValidColumn"
                , assertValidColumn_function_value
                , ( bp::arg("l") )
                , "Assert that there is an lth column\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::assertValidIndex
        
            typedef void ( ::SireMaths::N4Matrix::*assertValidIndex_function_type)( int,int,int,int ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::N4Matrix::assertValidIndex );
            
            N4Matrix_exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
                , "Assert that the index [i,j,k,l] is valid for this matrix\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::assertValidRow
        
            typedef void ( ::SireMaths::N4Matrix::*assertValidRow_function_type)( int ) const;
            assertValidRow_function_type assertValidRow_function_value( &::SireMaths::N4Matrix::assertValidRow );
            
            N4Matrix_exposer.def( 
                "assertValidRow"
                , assertValidRow_function_value
                , ( bp::arg("k") )
                , "Assert that there is an kth row\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::checkedOffset
        
            typedef int ( ::SireMaths::N4Matrix::*checkedOffset_function_type)( int,int,int,int ) const;
            checkedOffset_function_type checkedOffset_function_value( &::SireMaths::N4Matrix::checkedOffset );
            
            N4Matrix_exposer.def( 
                "checkedOffset"
                , checkedOffset_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
                , "Calculate the offset in the 1D array of the value\nat index [i,j,k,l]\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::memory
        
            typedef ::QVector< double > ( ::SireMaths::N4Matrix::*memory_function_type)(  ) const;
            memory_function_type memory_function_value( &::SireMaths::N4Matrix::memory );
            
            N4Matrix_exposer.def( 
                "memory"
                , memory_function_value
                , "Return the raw QVector memory used by this matrix" );
        
        }
        { //::SireMaths::N4Matrix::nBigColumns
        
            typedef int ( ::SireMaths::N4Matrix::*nBigColumns_function_type)(  ) const;
            nBigColumns_function_type nBigColumns_function_value( &::SireMaths::N4Matrix::nBigColumns );
            
            N4Matrix_exposer.def( 
                "nBigColumns"
                , nBigColumns_function_value
                , "Return the number of big columns in this matrix" );
        
        }
        { //::SireMaths::N4Matrix::nBigRows
        
            typedef int ( ::SireMaths::N4Matrix::*nBigRows_function_type)(  ) const;
            nBigRows_function_type nBigRows_function_value( &::SireMaths::N4Matrix::nBigRows );
            
            N4Matrix_exposer.def( 
                "nBigRows"
                , nBigRows_function_value
                , "Return the number of big rows in this matrix" );
        
        }
        { //::SireMaths::N4Matrix::nColumns
        
            typedef int ( ::SireMaths::N4Matrix::*nColumns_function_type)(  ) const;
            nColumns_function_type nColumns_function_value( &::SireMaths::N4Matrix::nColumns );
            
            N4Matrix_exposer.def( 
                "nColumns"
                , nColumns_function_value
                , "Return the number of columns in this matrix" );
        
        }
        { //::SireMaths::N4Matrix::nRows
        
            typedef int ( ::SireMaths::N4Matrix::*nRows_function_type)(  ) const;
            nRows_function_type nRows_function_value( &::SireMaths::N4Matrix::nRows );
            
            N4Matrix_exposer.def( 
                "nRows"
                , nRows_function_value
                , "Return the number of rows in this matrix" );
        
        }
        { //::SireMaths::N4Matrix::offset
        
            typedef int ( ::SireMaths::N4Matrix::*offset_function_type)( int,int,int,int ) const;
            offset_function_type offset_function_value( &::SireMaths::N4Matrix::offset );
            
            N4Matrix_exposer.def( 
                "offset"
                , offset_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
                , "" );
        
        }
        N4Matrix_exposer.def( bp::self != bp::self );
        { //::SireMaths::N4Matrix::operator()
        
            typedef double const & ( ::SireMaths::N4Matrix::*__call___function_type)( int,int,int,int ) const;
            __call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() );
            
            N4Matrix_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMaths::N4Matrix::operator()
        
            typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*__call___function_type)( int,int ) const;
            __call___function_type __call___function_value( &::SireMaths::N4Matrix::operator() );
            
            N4Matrix_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "" );
        
        }
        N4Matrix_exposer.def( bp::self * bp::other< double >() );
        N4Matrix_exposer.def( bp::self + bp::self );
        N4Matrix_exposer.def( -bp::self );
        N4Matrix_exposer.def( bp::self - bp::self );
        N4Matrix_exposer.def( bp::self / bp::other< double >() );
        { //::SireMaths::N4Matrix::operator=
        
            typedef ::SireMaths::N4Matrix & ( ::SireMaths::N4Matrix::*assign_function_type)( ::SireMaths::N4Matrix const & ) ;
            assign_function_type assign_function_value( &::SireMaths::N4Matrix::operator= );
            
            N4Matrix_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        N4Matrix_exposer.def( bp::self == bp::self );
        { //::SireMaths::N4Matrix::redimension
        
            typedef void ( ::SireMaths::N4Matrix::*redimension_function_type)( int,int,int,int ) ;
            redimension_function_type redimension_function_value( &::SireMaths::N4Matrix::redimension );
            
            N4Matrix_exposer.def( 
                "redimension"
                , redimension_function_value
                , ( bp::arg("nbigrows"), bp::arg("nbigcolumns"), bp::arg("nrows"), bp::arg("ncolumns") )
                , "Redimension this matrix to have nbigrows big rows,\nnbigcolumns big columns, nrows rows and ncolumns\ncolumns. The contents of this matrix are undefined after\nthis redimension. This function will only reallocate\nmemory if there is not enough memory allocated to store\nthe new matrix. Use this function if you want to use\nthe same piece of memory over and over again for lots\nof different size matricies - just create a matrix with\nthe maximum dimension, then call this redimension function\nwhenever you want to change. It is very fast, as it just\nupdates the internal record of the size of the matrix" );
        
        }
        { //::SireMaths::N4Matrix::set
        
            typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,::SireMaths::NMatrix const & ) ;
            set_function_type set_function_value( &::SireMaths::N4Matrix::set );
            
            N4Matrix_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
                , "Set the view at [i,j] equal to matrix\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::set
        
            typedef void ( ::SireMaths::N4Matrix::*set_function_type)( int,int,int,int,double ) ;
            set_function_type set_function_value( &::SireMaths::N4Matrix::set );
            
            N4Matrix_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("k"), bp::arg("l"), bp::arg("value") )
                , "Set the value at [i,j,k,l] equal to value\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::setAll
        
            typedef void ( ::SireMaths::N4Matrix::*setAll_function_type)( double ) ;
            setAll_function_type setAll_function_value( &::SireMaths::N4Matrix::setAll );
            
            N4Matrix_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("value") )
                , "Set all entries in the matrix to the value value" );
        
        }
        { //::SireMaths::N4Matrix::subtract
        
            typedef void ( ::SireMaths::N4Matrix::*subtract_function_type)( int,int,::SireMaths::NMatrix const & ) ;
            subtract_function_type subtract_function_value( &::SireMaths::N4Matrix::subtract );
            
            N4Matrix_exposer.def( 
                "subtract"
                , subtract_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("matrix") )
                , "Subtract the contents of matrix from the sub-matrix view at [i,j]\nThrow: SireError::invalid_index\nThrow: SireError::incompatible_error\n" );
        
        }
        { //::SireMaths::N4Matrix::toString
        
            typedef ::QString ( ::SireMaths::N4Matrix::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMaths::N4Matrix::toString );
            
            N4Matrix_exposer.def( 
                "toString"
                , toString_function_value
                , "Return a string representation of this matrix" );
        
        }
        { //::SireMaths::N4Matrix::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::N4Matrix::typeName );
            
            N4Matrix_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMaths::N4Matrix::view
        
            typedef ::SireMaths::NMatrix ( ::SireMaths::N4Matrix::*view_function_type)( int,int ) const;
            view_function_type view_function_value( &::SireMaths::N4Matrix::view );
            
            N4Matrix_exposer.def( 
                "view"
                , view_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , "Return the sub-matrix view at [i,j,k,l]\nThrow: SireError::invalid_index\n" );
        
        }
        { //::SireMaths::N4Matrix::what
        
            typedef char const * ( ::SireMaths::N4Matrix::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMaths::N4Matrix::what );
            
            N4Matrix_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        N4Matrix_exposer.staticmethod( "typeName" );
        N4Matrix_exposer.def( "__copy__", &__copy__);
        N4Matrix_exposer.def( "__deepcopy__", &__copy__);
        N4Matrix_exposer.def( "clone", &__copy__);
        N4Matrix_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::N4Matrix >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        N4Matrix_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::N4Matrix >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        N4Matrix_exposer.def( "__str__", &__str__< ::SireMaths::N4Matrix > );
        N4Matrix_exposer.def( "__repr__", &__str__< ::SireMaths::N4Matrix > );
    }

}
Example #9
0
void register_StringMangler_class(){

    { //::SireBase::StringMangler
        typedef bp::class_< SireBase::StringMangler, bp::bases< SireBase::Property >, boost::noncopyable > StringMangler_exposer_t;
        StringMangler_exposer_t StringMangler_exposer = StringMangler_exposer_t( "StringMangler", "This is the base class of all string mangling functions.\nA string mangler is just a simple function that performs\nsome transformations on an input string, e.g. changing its\ncase, trimming away extra spaces etc.\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope StringMangler_scope( StringMangler_exposer );
        { //::SireBase::StringMangler::mangle
        
            typedef ::QString ( ::SireBase::StringMangler::*mangle_function_type)( ::QString const & ) const;
            mangle_function_type mangle_function_value( &::SireBase::StringMangler::mangle );
            
            StringMangler_exposer.def( 
                "mangle"
                , mangle_function_value
                , ( bp::arg("input") )
                , "" );
        
        }
        { //::SireBase::StringMangler::null
        
            typedef ::SireBase::NoMangling const & ( *null_function_type )(  );
            null_function_type null_function_value( &::SireBase::StringMangler::null );
            
            StringMangler_exposer.def( 
                "null"
                , null_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireBase::StringMangler::operator()
        
            typedef ::QString ( ::SireBase::StringMangler::*__call___function_type)( ::QString const & ) const;
            __call___function_type __call___function_value( &::SireBase::StringMangler::operator() );
            
            StringMangler_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("input") )
                , "" );
        
        }
        { //::SireBase::StringMangler::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireBase::StringMangler::typeName );
            
            StringMangler_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        StringMangler_exposer.staticmethod( "null" );
        StringMangler_exposer.staticmethod( "typeName" );
        StringMangler_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::StringMangler >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        StringMangler_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::StringMangler >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        StringMangler_exposer.def( "__str__", &__str__< ::SireBase::StringMangler > );
        StringMangler_exposer.def( "__repr__", &__str__< ::SireBase::StringMangler > );
    }

}
void register_Array2D_SireMaths_AccumulatorPtr__class(){

    { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >
        typedef bp::class_< SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >, bp::bases< SireBase::Array2DBase > > Array2D_SireMaths_AccumulatorPtr__exposer_t;
        Array2D_SireMaths_AccumulatorPtr__exposer_t Array2D_SireMaths_AccumulatorPtr__exposer = Array2D_SireMaths_AccumulatorPtr__exposer_t( "Array2D_SireMaths_AccumulatorPtr_", bp::init< >() );
        bp::scope Array2D_SireMaths_AccumulatorPtr__scope( Array2D_SireMaths_AccumulatorPtr__exposer );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< int, int >(( bp::arg("nrows"), bp::arg("ncolumns") )) );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< int, int, SireBase::PropPtr< SireMaths::Accumulator > const & >(( bp::arg("nrows"), bp::arg("ncolumns"), bp::arg("default_value") )) );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::init< SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > const & >(( bp::arg("other") )) );
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::at
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*at_function_type )( int,int ) const;
            at_function_type at_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::at );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::get
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*get_function_type )( int,int ) const;
            get_function_type get_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::get );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::self != bp::self );
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator()
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::SireBase::PropPtr< SireMaths::Accumulator > const & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator() );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator=
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > & ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*assign_function_type )( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > const & ) ;
            assign_function_type assign_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::operator= );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Array2D_SireMaths_AccumulatorPtr__exposer.def( bp::self == bp::self );
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::redimension
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*redimension_function_type )( int,int ) ;
            redimension_function_type redimension_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::redimension );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "redimension"
                , redimension_function_value
                , ( bp::arg("nrows"), bp::arg("ncolumns") ) );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::set
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*set_function_type )( int,int,::SireBase::PropPtr< SireMaths::Accumulator > const & ) ;
            set_function_type set_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::set );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::setAll
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef void ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*setAll_function_type )( ::SireBase::PropPtr< SireMaths::Accumulator > const & ) ;
            setAll_function_type setAll_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::setAll );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::toString
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::QString ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::toString );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::transpose
        
            typedef SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > exported_class_t;
            typedef ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > > ( ::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::*transpose_function_type )(  ) const;
            transpose_function_type transpose_function_value( &::SireBase::Array2D< SireBase::PropPtr< SireMaths::Accumulator > >::transpose );
            
            Array2D_SireMaths_AccumulatorPtr__exposer.def( 
                "transpose"
                , transpose_function_value );
        
        }
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__copy__", &__copy__);
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__deepcopy__", &__copy__);
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "clone", &__copy__);
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__str__", &__str__< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > > );
        Array2D_SireMaths_AccumulatorPtr__exposer.def( "__repr__", &__str__< ::SireBase::Array2D<SireBase::PropPtr<SireMaths::Accumulator> > > );
    }

}
Example #11
0
void register_CuttingFunction_class(){

    { //::SireMol::CuttingFunction
        typedef bp::class_< SireMol::CuttingFunction, bp::bases< SireBase::Property >, boost::noncopyable > CuttingFunction_exposer_t;
        CuttingFunction_exposer_t CuttingFunction_exposer = CuttingFunction_exposer_t( "CuttingFunction", "This is the base class of all cutting functions. These are\nfunctions that divide a molecule up into CutGroups.\n\nAuthor: Christopher Woods\n", bp::no_init );
        bp::scope CuttingFunction_scope( CuttingFunction_exposer );
        { //::SireMol::CuttingFunction::null
        
            typedef ::SireMol::ResidueCutting const & ( *null_function_type )(  );
            null_function_type null_function_value( &::SireMol::CuttingFunction::null );
            
            CuttingFunction_exposer.def( 
                "null"
                , null_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::CuttingFunction::operator()
        
            typedef ::SireMol::Molecule ( ::SireMol::CuttingFunction::*__call___function_type)( ::SireMol::Molecule const & ) const;
            __call___function_type __call___function_value( &::SireMol::CuttingFunction::operator() );
            
            CuttingFunction_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("molecule") )
                , "" );
        
        }
        { //::SireMol::CuttingFunction::operator()
        
            typedef ::SireMol::MolStructureEditor ( ::SireMol::CuttingFunction::*__call___function_type)( ::SireMol::MolStructureEditor & ) const;
            __call___function_type __call___function_value( &::SireMol::CuttingFunction::operator() );
            
            CuttingFunction_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("moleditor") )
                , "" );
        
        }
        { //::SireMol::CuttingFunction::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::CuttingFunction::typeName );
            
            CuttingFunction_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        CuttingFunction_exposer.staticmethod( "null" );
        CuttingFunction_exposer.staticmethod( "typeName" );
        CuttingFunction_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::CuttingFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CuttingFunction_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::CuttingFunction >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CuttingFunction_exposer.def( "__str__", &__str__< ::SireMol::CuttingFunction > );
        CuttingFunction_exposer.def( "__repr__", &__str__< ::SireMol::CuttingFunction > );
    }

}
Example #12
0
void register_NVector_class(){

    { //::SireMaths::NVector
        typedef bp::class_< SireMaths::NVector > NVector_exposer_t;
        NVector_exposer_t NVector_exposer = NVector_exposer_t( "NVector", bp::init< >() );
        bp::scope NVector_scope( NVector_exposer );
        NVector_exposer.def( bp::init< int >(( bp::arg("nrows") )) );
        NVector_exposer.def( bp::init< int, double >(( bp::arg("nrows"), bp::arg("initial_value") )) );
        NVector_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("vector") )) );
        NVector_exposer.def( bp::init< QVector< double > const & >(( bp::arg("vector") )) );
        NVector_exposer.def( bp::init< SireMaths::NVector const & >(( bp::arg("vector") )) );
        { //::SireMaths::NVector::assertNColumns
        
            typedef void ( ::SireMaths::NVector::*assertNColumns_function_type )( int ) const;
            assertNColumns_function_type assertNColumns_function_value( &::SireMaths::NVector::assertNColumns );
            
            NVector_exposer.def( 
                "assertNColumns"
                , assertNColumns_function_value
                , ( bp::arg("ncolumns") ) );
        
        }
        { //::SireMaths::NVector::assertNRows
        
            typedef void ( ::SireMaths::NVector::*assertNRows_function_type )( int ) const;
            assertNRows_function_type assertNRows_function_value( &::SireMaths::NVector::assertNRows );
            
            NVector_exposer.def( 
                "assertNRows"
                , assertNRows_function_value
                , ( bp::arg("nrows") ) );
        
        }
        { //::SireMaths::NVector::assertValidIndex
        
            typedef void ( ::SireMaths::NVector::*assertValidIndex_function_type )( int ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::NVector::assertValidIndex );
            
            NVector_exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMaths::NVector::assertValidIndex
        
            typedef void ( ::SireMaths::NVector::*assertValidIndex_function_type )( int,int ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireMaths::NVector::assertValidIndex );
            
            NVector_exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i"), bp::arg("j") ) );
        
        }
        { //::SireMaths::NVector::count
        
            typedef int ( ::SireMaths::NVector::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireMaths::NVector::count );
            
            NVector_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireMaths::NVector::cross
        
            typedef ::SireMaths::NVector ( ::SireMaths::NVector::*cross_function_type )( ::SireMaths::NVector const & ) const;
            cross_function_type cross_function_value( &::SireMaths::NVector::cross );
            
            NVector_exposer.def( 
                "cross"
                , cross_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::NVector::dot
        
            typedef double ( ::SireMaths::NVector::*dot_function_type )( ::SireMaths::NVector const & ) const;
            dot_function_type dot_function_value( &::SireMaths::NVector::dot );
            
            NVector_exposer.def( 
                "dot"
                , dot_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMaths::NVector::isZero
        
            typedef bool ( ::SireMaths::NVector::*isZero_function_type )(  ) const;
            isZero_function_type isZero_function_value( &::SireMaths::NVector::isZero );
            
            NVector_exposer.def( 
                "isZero"
                , isZero_function_value );
        
        }
        { //::SireMaths::NVector::length
        
            typedef double ( ::SireMaths::NVector::*length_function_type )(  ) const;
            length_function_type length_function_value( &::SireMaths::NVector::length );
            
            NVector_exposer.def( 
                "length"
                , length_function_value );
        
        }
        { //::SireMaths::NVector::length2
        
            typedef double ( ::SireMaths::NVector::*length2_function_type )(  ) const;
            length2_function_type length2_function_value( &::SireMaths::NVector::length2 );
            
            NVector_exposer.def( 
                "length2"
                , length2_function_value );
        
        }
        { //::SireMaths::NVector::nColumns
        
            typedef int ( ::SireMaths::NVector::*nColumns_function_type )(  ) const;
            nColumns_function_type nColumns_function_value( &::SireMaths::NVector::nColumns );
            
            NVector_exposer.def( 
                "nColumns"
                , nColumns_function_value );
        
        }
        { //::SireMaths::NVector::nRows
        
            typedef int ( ::SireMaths::NVector::*nRows_function_type )(  ) const;
            nRows_function_type nRows_function_value( &::SireMaths::NVector::nRows );
            
            NVector_exposer.def( 
                "nRows"
                , nRows_function_value );
        
        }
        { //::SireMaths::NVector::normalise
        
            typedef ::SireMaths::NVector ( ::SireMaths::NVector::*normalise_function_type )(  ) const;
            normalise_function_type normalise_function_value( &::SireMaths::NVector::normalise );
            
            NVector_exposer.def( 
                "normalise"
                , normalise_function_value );
        
        }
        NVector_exposer.def( bp::self != bp::self );
        { //::SireMaths::NVector::operator()
        
            typedef double const & ( ::SireMaths::NVector::*__call___function_type )( int ) const;
            __call___function_type __call___function_value( &::SireMaths::NVector::operator() );
            
            NVector_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMaths::NVector::operator()
        
            typedef double const & ( ::SireMaths::NVector::*__call___function_type )( int,int ) const;
            __call___function_type __call___function_value( &::SireMaths::NVector::operator() );
            
            NVector_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        NVector_exposer.def( bp::self * bp::other< double >() );
        NVector_exposer.def( bp::self + bp::self );
        NVector_exposer.def( -bp::self );
        NVector_exposer.def( bp::self - bp::self );
        NVector_exposer.def( bp::self / bp::other< double >() );
        { //::SireMaths::NVector::operator=
        
            typedef ::SireMaths::NVector & ( ::SireMaths::NVector::*assign_function_type )( ::SireMaths::NVector const & ) ;
            assign_function_type assign_function_value( &::SireMaths::NVector::operator= );
            
            NVector_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        NVector_exposer.def( bp::self == bp::self );
        { //::SireMaths::NVector::operator[]
        
            typedef double & ( ::SireMaths::NVector::*__getitem___function_type )( int ) ;
            __getitem___function_type __getitem___function_value( &::SireMaths::NVector::operator[] );
            
            NVector_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_non_const_reference >() );
        
        }
        { //::SireMaths::NVector::operator[]
        
            typedef double const & ( ::SireMaths::NVector::*__getitem___function_type )( int ) const;
            __getitem___function_type __getitem___function_value( &::SireMaths::NVector::operator[] );
            
            NVector_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMaths::NVector::set
        
            typedef void ( ::SireMaths::NVector::*set_function_type )( int,double ) ;
            set_function_type set_function_value( &::SireMaths::NVector::set );
            
            NVector_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("value") ) );
        
        }
        { //::SireMaths::NVector::set
        
            typedef void ( ::SireMaths::NVector::*set_function_type )( int,int,double ) ;
            set_function_type set_function_value( &::SireMaths::NVector::set );
            
            NVector_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );
        
        }
        { //::SireMaths::NVector::setAll
        
            typedef void ( ::SireMaths::NVector::*setAll_function_type )( double ) ;
            setAll_function_type setAll_function_value( &::SireMaths::NVector::setAll );
            
            NVector_exposer.def( 
                "setAll"
                , setAll_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireMaths::NVector::size
        
            typedef int ( ::SireMaths::NVector::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireMaths::NVector::size );
            
            NVector_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireMaths::NVector::sum
        
            typedef double ( ::SireMaths::NVector::*sum_function_type )(  ) const;
            sum_function_type sum_function_value( &::SireMaths::NVector::sum );
            
            NVector_exposer.def( 
                "sum"
                , sum_function_value );
        
        }
        { //::SireMaths::NVector::toString
        
            typedef ::QString ( ::SireMaths::NVector::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMaths::NVector::toString );
            
            NVector_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMaths::NVector::transpose
        
            typedef ::SireMaths::NMatrix ( ::SireMaths::NVector::*transpose_function_type )(  ) const;
            transpose_function_type transpose_function_value( &::SireMaths::NVector::transpose );
            
            NVector_exposer.def( 
                "transpose"
                , transpose_function_value );
        
        }
        { //::SireMaths::NVector::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::NVector::typeName );
            
            NVector_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMaths::NVector::what
        
            typedef char const * ( ::SireMaths::NVector::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMaths::NVector::what );
            
            NVector_exposer.def( 
                "what"
                , what_function_value );
        
        }
        NVector_exposer.staticmethod( "typeName" );
        NVector_exposer.def( bp::other< double >() * bp::self );
        NVector_exposer.def( "__copy__", &__copy__);
        NVector_exposer.def( "__deepcopy__", &__copy__);
        NVector_exposer.def( "clone", &__copy__);
        NVector_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::NVector >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        NVector_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::NVector >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        NVector_exposer.def( "__str__", &__str__< ::SireMaths::NVector > );
        NVector_exposer.def( "__repr__", &__str__< ::SireMaths::NVector > );
        NVector_exposer.def( "__len__", &__len_size< ::SireMaths::NVector > );
    }

}
Example #13
0
void register_PointRef_class(){

    { //::SireFF::PointRef
        typedef bp::class_< SireFF::PointRef > PointRef_exposer_t;
        PointRef_exposer_t PointRef_exposer = PointRef_exposer_t( "PointRef", bp::init< SireMol::Atom const & >(( bp::arg("atom") )) );
        bp::scope PointRef_scope( PointRef_exposer );
        PointRef_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("point") )) );
        PointRef_exposer.def( bp::init< SireFF::Point const & >(( bp::arg("point") )) );
        PointRef_exposer.def( bp::init< SireFF::PointPtr const & >(( bp::arg("point") )) );
        { //::SireFF::PointRef::addForce
        
            typedef bool ( ::SireFF::PointRef::*addForce_function_type )( ::SireFF::MolForceTable &,::SireMaths::Vector const & ) const;
            addForce_function_type addForce_function_value( &::SireFF::PointRef::addForce );
            
            PointRef_exposer.def( 
                "addForce"
                , addForce_function_value
                , ( bp::arg("molforces"), bp::arg("force") ) );
        
        }
        { //::SireFF::PointRef::addForce
        
            typedef bool ( ::SireFF::PointRef::*addForce_function_type )( ::SireFF::ForceTable &,::SireMaths::Vector const & ) const;
            addForce_function_type addForce_function_value( &::SireFF::PointRef::addForce );
            
            PointRef_exposer.def( 
                "addForce"
                , addForce_function_value
                , ( bp::arg("forces"), bp::arg("force") ) );
        
        }
        { //::SireFF::PointRef::operator()
        
            typedef ::SireMaths::Vector const & ( ::SireFF::PointRef::*__call___function_type )(  ) const;
            __call___function_type __call___function_value( &::SireFF::PointRef::operator() );
            
            PointRef_exposer.def( 
                "__call__"
                , __call___function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireFF::PointRef::point
        
            typedef ::SireMaths::Vector const & ( ::SireFF::PointRef::*point_function_type )(  ) const;
            point_function_type point_function_value( &::SireFF::PointRef::point );
            
            PointRef_exposer.def( 
                "point"
                , point_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        PointRef_exposer.def( "__copy__", &__copy__);
        PointRef_exposer.def( "__deepcopy__", &__copy__);
        PointRef_exposer.def( "clone", &__copy__);
        PointRef_exposer.def( "__str__", &pvt_get_name);
        PointRef_exposer.def( "__repr__", &pvt_get_name);
    }

}
void register_PackedArray2D_QString__class(){

    { //::SireBase::PackedArray2D< QString >
        typedef bp::class_< SireBase::PackedArray2D< QString > > PackedArray2D_QString__exposer_t;
        PackedArray2D_QString__exposer_t PackedArray2D_QString__exposer = PackedArray2D_QString__exposer_t( "PackedArray2D_QString_", bp::init< >() );
        bp::scope PackedArray2D_QString__scope( PackedArray2D_QString__exposer );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::detail::PackedArray2D_Array< QString > const & >(( bp::arg("array") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< SireBase::detail::PackedArray2D_Array< QString > > const & >(( bp::arg("arrays") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< QString > const & >(( bp::arg("values") )) );
        PackedArray2D_QString__exposer.def( bp::init< QVector< QVector< QString > > const & >(( bp::arg("values") )) );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const &, SireBase::PackedArray2D< QString > const & >(( bp::arg("array0"), bp::arg("array1") )) );
        PackedArray2D_QString__exposer.def( bp::init< SireBase::PackedArray2D< QString > const & >(( bp::arg("other") )) );
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("arrays") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QString > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::append
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*append_function_type )( ::QVector< QVector< QString > > const & ) ;
            append_function_type append_function_value( &::SireBase::PackedArray2D< QString >::append );
            
            PackedArray2D_QString__exposer.def( 
                "append"
                , append_function_value
                , ( bp::arg("arrays") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::assertValidIndex
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*assertValidIndex_function_type )( ::quint32 ) const;
            assertValidIndex_function_type assertValidIndex_function_value( &::SireBase::PackedArray2D< QString >::assertValidIndex );
            
            PackedArray2D_QString__exposer.def( 
                "assertValidIndex"
                , assertValidIndex_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::at
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32 ) const;
            at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
            
            PackedArray2D_QString__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::at
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*at_function_type )( ::quint32,::quint32 ) const;
            at_function_type at_function_value( &::SireBase::PackedArray2D< QString >::at );
            
            PackedArray2D_QString__exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::count
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireBase::PackedArray2D< QString >::count );
            
            PackedArray2D_QString__exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::fromVariant
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QString > ( *fromVariant_function_type )( ::SireBase::PackedArray2D< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireBase::PackedArray2D< QString >::fromVariant );
            
            PackedArray2D_QString__exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::isEmpty
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef bool ( ::SireBase::PackedArray2D< QString >::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireBase::PackedArray2D< QString >::isEmpty );
            
            PackedArray2D_QString__exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nArrays
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nArrays_function_type )(  ) const;
            nArrays_function_type nArrays_function_value( &::SireBase::PackedArray2D< QString >::nArrays );
            
            PackedArray2D_QString__exposer.def( 
                "nArrays"
                , nArrays_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nValues
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )(  ) const;
            nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
            
            PackedArray2D_QString__exposer.def( 
                "nValues"
                , nValues_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::nValues
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*nValues_function_type )( ::quint32 ) const;
            nValues_function_type nValues_function_value( &::SireBase::PackedArray2D< QString >::nValues );
            
            PackedArray2D_QString__exposer.def( 
                "nValues"
                , nValues_function_value
                , ( bp::arg("i") ) );
        
        }
        PackedArray2D_QString__exposer.def( bp::self != bp::self );
        { //::SireBase::PackedArray2D< QString >::operator()
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString const & ( ::SireBase::PackedArray2D< QString >::*__call___function_type )( ::quint32,::quint32 ) const;
            __call___function_type __call___function_value( &::SireBase::PackedArray2D< QString >::operator() );
            
            PackedArray2D_QString__exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("i"), bp::arg("j") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::operator=
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QString > & ( ::SireBase::PackedArray2D< QString >::*assign_function_type )( ::SireBase::PackedArray2D< QString > const & ) ;
            assign_function_type assign_function_value( &::SireBase::PackedArray2D< QString >::operator= );
            
            PackedArray2D_QString__exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PackedArray2D_QString__exposer.def( bp::self == bp::self );
        { //::SireBase::PackedArray2D< QString >::operator[]
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::detail::PackedArray2D_Array< QString > const & ( ::SireBase::PackedArray2D< QString >::*__getitem___function_type )( ::quint32 ) const;
            __getitem___function_type __getitem___function_value( &::SireBase::PackedArray2D< QString >::operator[] );
            
            PackedArray2D_QString__exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("i") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireBase::PackedArray2D< QString >::remove
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*remove_function_type )( ::quint32 ) ;
            remove_function_type remove_function_value( &::SireBase::PackedArray2D< QString >::remove );
            
            PackedArray2D_QString__exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::removeAll
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*removeAll_function_type )( ::QVarLengthArray< int, 256 > const & ) ;
            removeAll_function_type removeAll_function_value( &::SireBase::PackedArray2D< QString >::removeAll );
            
            PackedArray2D_QString__exposer.def( 
                "removeAll"
                , removeAll_function_value
                , ( bp::arg("idxs") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::size
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef int ( ::SireBase::PackedArray2D< QString >::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireBase::PackedArray2D< QString >::size );
            
            PackedArray2D_QString__exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toQVector
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QVector< QString > ( ::SireBase::PackedArray2D< QString >::*toQVector_function_type )(  ) const;
            toQVector_function_type toQVector_function_value( &::SireBase::PackedArray2D< QString >::toQVector );
            
            PackedArray2D_QString__exposer.def( 
                "toQVector"
                , toQVector_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toQVectorVector
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QVector< QVector< QString > > ( ::SireBase::PackedArray2D< QString >::*toQVectorVector_function_type )(  ) const;
            toQVectorVector_function_type toQVectorVector_function_value( &::SireBase::PackedArray2D< QString >::toQVectorVector );
            
            PackedArray2D_QString__exposer.def( 
                "toQVectorVector"
                , toQVectorVector_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toString
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::QString ( ::SireBase::PackedArray2D< QString >::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireBase::PackedArray2D< QString >::toString );
            
            PackedArray2D_QString__exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::toVariant
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef ::SireBase::PackedArray2D< QVariant > ( ::SireBase::PackedArray2D< QString >::*toVariant_function_type )(  ) const;
            toVariant_function_type toVariant_function_value( &::SireBase::PackedArray2D< QString >::toVariant );
            
            PackedArray2D_QString__exposer.def( 
                "toVariant"
                , toVariant_function_value );
        
        }
        { //::SireBase::PackedArray2D< QString >::update
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::SireBase::detail::PackedArray2D_Array< QString > const & ) ;
            update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
            
            PackedArray2D_QString__exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::update
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*update_function_type )( ::quint32,::QVector< QString > const & ) ;
            update_function_type update_function_value( &::SireBase::PackedArray2D< QString >::update );
            
            PackedArray2D_QString__exposer.def( 
                "update"
                , update_function_value
                , ( bp::arg("i"), bp::arg("array") ) );
        
        }
        { //::SireBase::PackedArray2D< QString >::updateAll
        
            typedef SireBase::PackedArray2D< QString > exported_class_t;
            typedef void ( ::SireBase::PackedArray2D< QString >::*updateAll_function_type )( ::QVarLengthArray< int, 256 > const &,::SireBase::PackedArray2D< QString > const & ) ;
            updateAll_function_type updateAll_function_value( &::SireBase::PackedArray2D< QString >::updateAll );
            
            PackedArray2D_QString__exposer.def( 
                "updateAll"
                , updateAll_function_value
                , ( bp::arg("idxs"), bp::arg("arrays") ) );
        
        }
        PackedArray2D_QString__exposer.staticmethod( "fromVariant" );
        PackedArray2D_QString__exposer.def( "__copy__", &__copy__);
        PackedArray2D_QString__exposer.def( "__deepcopy__", &__copy__);
        PackedArray2D_QString__exposer.def( "clone", &__copy__);
        PackedArray2D_QString__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PackedArray2D_QString__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PackedArray2D<QString> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PackedArray2D_QString__exposer.def( "__str__", &__str__< ::SireBase::PackedArray2D<QString> > );
        PackedArray2D_QString__exposer.def( "__repr__", &__str__< ::SireBase::PackedArray2D<QString> > );
        PackedArray2D_QString__exposer.def( "__len__", &__len_size< ::SireBase::PackedArray2D<QString> > );
    }

}
Example #15
0
void register_Transform_class(){

    { //::SireMaths::Transform
        typedef bp::class_< SireMaths::Transform > Transform_exposer_t;
        Transform_exposer_t Transform_exposer = Transform_exposer_t( "Transform", bp::init< >() );
        bp::scope Transform_scope( Transform_exposer );
        Transform_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("delta") )) );
        Transform_exposer.def( bp::init< SireMaths::Quaternion const &, SireMaths::Vector const & >(( bp::arg("rotmat"), bp::arg("center") )) );
        Transform_exposer.def( bp::init< SireMaths::Matrix const &, SireMaths::Vector const & >(( bp::arg("rotmat"), bp::arg("center") )) );
        Transform_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Quaternion const &, SireMaths::Vector const & >(( bp::arg("delta"), bp::arg("rotmat"), bp::arg("center") )) );
        Transform_exposer.def( bp::init< SireMaths::Vector const &, SireMaths::Matrix const &, SireMaths::Vector const & >(( bp::arg("delta"), bp::arg("rotmat"), bp::arg("center") )) );
        Transform_exposer.def( bp::init< SireMaths::Transform const & >(( bp::arg("other") )) );
        { //::SireMaths::Transform::apply
        
            typedef ::SireMaths::Vector ( ::SireMaths::Transform::*apply_function_type )( ::SireMaths::Vector const & ) const;
            apply_function_type apply_function_value( &::SireMaths::Transform::apply );
            
            Transform_exposer.def( 
                "apply"
                , apply_function_value
                , ( bp::arg("point") ) );
        
        }
        { //::SireMaths::Transform::apply
        
            typedef ::QVector< SireMaths::Vector > ( ::SireMaths::Transform::*apply_function_type )( ::QVector< SireMaths::Vector > const & ) const;
            apply_function_type apply_function_value( &::SireMaths::Transform::apply );
            
            Transform_exposer.def( 
                "apply"
                , apply_function_value
                , ( bp::arg("points") ) );
        
        }
        { //::SireMaths::Transform::isNull
        
            typedef bool ( ::SireMaths::Transform::*isNull_function_type )(  ) const;
            isNull_function_type isNull_function_value( &::SireMaths::Transform::isNull );
            
            Transform_exposer.def( 
                "isNull"
                , isNull_function_value );
        
        }
        { //::SireMaths::Transform::isZero
        
            typedef bool ( ::SireMaths::Transform::*isZero_function_type )(  ) const;
            isZero_function_type isZero_function_value( &::SireMaths::Transform::isZero );
            
            Transform_exposer.def( 
                "isZero"
                , isZero_function_value );
        
        }
        Transform_exposer.def( bp::self != bp::self );
        { //::SireMaths::Transform::operator()
        
            typedef ::SireMaths::Vector ( ::SireMaths::Transform::*__call___function_type )( ::SireMaths::Vector const & ) const;
            __call___function_type __call___function_value( &::SireMaths::Transform::operator() );
            
            Transform_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("point") ) );
        
        }
        { //::SireMaths::Transform::operator()
        
            typedef ::QVector< SireMaths::Vector > ( ::SireMaths::Transform::*__call___function_type )( ::QVector< SireMaths::Vector > const & ) const;
            __call___function_type __call___function_value( &::SireMaths::Transform::operator() );
            
            Transform_exposer.def( 
                "__call__"
                , __call___function_value
                , ( bp::arg("point") ) );
        
        }
        { //::SireMaths::Transform::operator=
        
            typedef ::SireMaths::Transform & ( ::SireMaths::Transform::*assign_function_type )( ::SireMaths::Transform const & ) ;
            assign_function_type assign_function_value( &::SireMaths::Transform::operator= );
            
            Transform_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        Transform_exposer.def( bp::self == bp::self );
        { //::SireMaths::Transform::rotationCenter
        
            typedef ::SireMaths::Vector ( ::SireMaths::Transform::*rotationCenter_function_type )(  ) const;
            rotationCenter_function_type rotationCenter_function_value( &::SireMaths::Transform::rotationCenter );
            
            Transform_exposer.def( 
                "rotationCenter"
                , rotationCenter_function_value );
        
        }
        { //::SireMaths::Transform::rotationMatrix
        
            typedef ::SireMaths::Matrix ( ::SireMaths::Transform::*rotationMatrix_function_type )(  ) const;
            rotationMatrix_function_type rotationMatrix_function_value( &::SireMaths::Transform::rotationMatrix );
            
            Transform_exposer.def( 
                "rotationMatrix"
                , rotationMatrix_function_value );
        
        }
        { //::SireMaths::Transform::rotationQuaternion
        
            typedef ::SireMaths::Quaternion ( ::SireMaths::Transform::*rotationQuaternion_function_type )(  ) const;
            rotationQuaternion_function_type rotationQuaternion_function_value( &::SireMaths::Transform::rotationQuaternion );
            
            Transform_exposer.def( 
                "rotationQuaternion"
                , rotationQuaternion_function_value );
        
        }
        { //::SireMaths::Transform::toString
        
            typedef ::QString ( ::SireMaths::Transform::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMaths::Transform::toString );
            
            Transform_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMaths::Transform::translationDelta
        
            typedef ::SireMaths::Vector ( ::SireMaths::Transform::*translationDelta_function_type )(  ) const;
            translationDelta_function_type translationDelta_function_value( &::SireMaths::Transform::translationDelta );
            
            Transform_exposer.def( 
                "translationDelta"
                , translationDelta_function_value );
        
        }
        { //::SireMaths::Transform::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMaths::Transform::typeName );
            
            Transform_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMaths::Transform::what
        
            typedef char const * ( ::SireMaths::Transform::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMaths::Transform::what );
            
            Transform_exposer.def( 
                "what"
                , what_function_value );
        
        }
        Transform_exposer.staticmethod( "typeName" );
        Transform_exposer.def( "__copy__", &__copy__);
        Transform_exposer.def( "__deepcopy__", &__copy__);
        Transform_exposer.def( "clone", &__copy__);
        Transform_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMaths::Transform >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Transform_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMaths::Transform >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        Transform_exposer.def( "__str__", &__str__< ::SireMaths::Transform > );
        Transform_exposer.def( "__repr__", &__str__< ::SireMaths::Transform > );
    }

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

}