示例#1
0
void register_ResID_class(){

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

}
示例#2
0
void register_ChainID_class(){

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

}
示例#3
0
void register_CLJBoxes_class(){

    { //::SireMM::CLJBoxes
        typedef bp::class_< SireMM::CLJBoxes > CLJBoxes_exposer_t;
        CLJBoxes_exposer_t CLJBoxes_exposer = CLJBoxes_exposer_t( "CLJBoxes", bp::init< >() );
        bp::scope CLJBoxes_scope( CLJBoxes_exposer );
        CLJBoxes_exposer.def( bp::init< SireUnits::Dimension::Length >(( bp::arg("box_size") )) );
        CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const & >(( bp::arg("atoms") )) );
        CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const & >(( bp::arg("atoms0"), bp::arg("atoms1") )) );
        CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms"), bp::arg("box_size") )) );
        CLJBoxes_exposer.def( bp::init< SireMM::CLJAtoms const &, SireMM::CLJAtoms const &, SireUnits::Dimension::Length >(( bp::arg("atoms0"), bp::arg("atoms1"), bp::arg("box_size") )) );
        CLJBoxes_exposer.def( bp::init< SireMM::CLJBoxes const & >(( bp::arg("other") )) );
        { //::SireMM::CLJBoxes::add
        
            typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*add_function_type )( ::SireMM::CLJAtoms const & ) ;
            add_function_type add_function_value( &::SireMM::CLJBoxes::add );
            
            CLJBoxes_exposer.def( 
                "add"
                , add_function_value
                , ( bp::arg("atoms") ) );
        
        }
        { //::SireMM::CLJBoxes::at
        
            typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*at_function_type )( ::SireMM::CLJBoxIndex const & ) const;
            at_function_type at_function_value( &::SireMM::CLJBoxes::at );
            
            CLJBoxes_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("idx") ) );
        
        }
        { //::SireMM::CLJBoxes::atoms
        
            typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )(  ) const;
            atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
            
            CLJBoxes_exposer.def( 
                "atoms"
                , atoms_function_value );
        
        }
        { //::SireMM::CLJBoxes::atoms
        
            typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*atoms_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
            atoms_function_type atoms_function_value( &::SireMM::CLJBoxes::atoms );
            
            CLJBoxes_exposer.def( 
                "atoms"
                , atoms_function_value
                , ( bp::arg("atoms") ) );
        
        }
        { //::SireMM::CLJBoxes::boxAt
        
            typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( int ) const;
            boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
            
            CLJBoxes_exposer.def( 
                "boxAt"
                , boxAt_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMM::CLJBoxes::boxAt
        
            typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
            boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
            
            CLJBoxes_exposer.def( 
                "boxAt"
                , boxAt_function_value
                , ( bp::arg("index") ) );
        
        }
        { //::SireMM::CLJBoxes::boxAt
        
            typedef ::SireMM::CLJBox ( ::SireMM::CLJBoxes::*boxAt_function_type )( ::SireMaths::Vector const & ) const;
            boxAt_function_type boxAt_function_value( &::SireMM::CLJBoxes::boxAt );
            
            CLJBoxes_exposer.def( 
                "boxAt"
                , boxAt_function_value
                , ( bp::arg("coords") ) );
        
        }
        { //::SireMM::CLJBoxes::boxDimensions
        
            typedef ::QVector< SireVol::AABox > ( ::SireMM::CLJBoxes::*boxDimensions_function_type )(  ) const;
            boxDimensions_function_type boxDimensions_function_value( &::SireMM::CLJBoxes::boxDimensions );
            
            CLJBoxes_exposer.def( 
                "boxDimensions"
                , boxDimensions_function_value );
        
        }
        { //::SireMM::CLJBoxes::boxDimensionsAt
        
            typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( int ) const;
            boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
            
            CLJBoxes_exposer.def( 
                "boxDimensionsAt"
                , boxDimensionsAt_function_value
                , ( bp::arg("i") ) );
        
        }
        { //::SireMM::CLJBoxes::boxDimensionsAt
        
            typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMM::CLJBoxIndex const & ) const;
            boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
            
            CLJBoxes_exposer.def( 
                "boxDimensionsAt"
                , boxDimensionsAt_function_value
                , ( bp::arg("index") ) );
        
        }
        { //::SireMM::CLJBoxes::boxDimensionsAt
        
            typedef ::SireVol::AABox ( ::SireMM::CLJBoxes::*boxDimensionsAt_function_type )( ::SireMaths::Vector const & ) const;
            boxDimensionsAt_function_type boxDimensionsAt_function_value( &::SireMM::CLJBoxes::boxDimensionsAt );
            
            CLJBoxes_exposer.def( 
                "boxDimensionsAt"
                , boxDimensionsAt_function_value
                , ( bp::arg("coords") ) );
        
        }
        { //::SireMM::CLJBoxes::boxes
        
            typedef ::QVector< SireMM::CLJBox > ( ::SireMM::CLJBoxes::*boxes_function_type )(  ) const;
            boxes_function_type boxes_function_value( &::SireMM::CLJBoxes::boxes );
            
            CLJBoxes_exposer.def( 
                "boxes"
                , boxes_function_value );
        
        }
        { //::SireMM::CLJBoxes::get
        
            typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*get_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) const;
            get_function_type get_function_value( &::SireMM::CLJBoxes::get );
            
            CLJBoxes_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("atoms") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistance
        
            typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
            getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
            
            CLJBoxes_exposer.def( 
                "getDistance"
                , getDistance_function_value
                , ( bp::arg("box0"), bp::arg("box1") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistance
        
            typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const & ) const;
            getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
            
            CLJBoxes_exposer.def( 
                "getDistance"
                , getDistance_function_value
                , ( bp::arg("space"), bp::arg("box0"), bp::arg("box1") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistance
        
            typedef float ( ::SireMM::CLJBoxes::*getDistance_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxIndex const &,::SireMM::CLJBoxIndex const &,::quint32,::quint32,::quint32 ) const;
            getDistance_function_type getDistance_function_value( &::SireMM::CLJBoxes::getDistance );
            
            CLJBoxes_exposer.def( 
                "getDistance"
                , getDistance_function_value
                , ( bp::arg("space"), bp::arg("box0"), bp::arg("box1"), bp::arg("nx"), bp::arg("ny"), bp::arg("nz") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const & );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("boxes") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("boxes"), bp::arg("cutoff") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const & );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJBoxes const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("boxes0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const & );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1") ) );
        
        }
        { //::SireMM::CLJBoxes::getDistances
        
            typedef ::QVector< SireMM::CLJBoxDistance > ( *getDistances_function_type )( ::SireVol::Space const &,::SireMM::CLJAtoms const &,::SireMM::CLJBoxes const &,::SireUnits::Dimension::Length );
            getDistances_function_type getDistances_function_value( &::SireMM::CLJBoxes::getDistances );
            
            CLJBoxes_exposer.def( 
                "getDistances"
                , getDistances_function_value
                , ( bp::arg("space"), bp::arg("atoms0"), bp::arg("boxes1"), bp::arg("cutoff") ) );
        
        }
        { //::SireMM::CLJBoxes::getitem
        
            typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*getitem_function_type )( ::SireMM::CLJBoxIndex const & ) const;
            getitem_function_type getitem_function_value( &::SireMM::CLJBoxes::getitem );
            
            CLJBoxes_exposer.def( 
                "getitem"
                , getitem_function_value
                , ( bp::arg("idx") ) );
        
        }
        { //::SireMM::CLJBoxes::isEmpty
        
            typedef bool ( ::SireMM::CLJBoxes::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMM::CLJBoxes::isEmpty );
            
            CLJBoxes_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireMM::CLJBoxes::length
        
            typedef ::SireUnits::Dimension::Length ( ::SireMM::CLJBoxes::*length_function_type )(  ) const;
            length_function_type length_function_value( &::SireMM::CLJBoxes::length );
            
            CLJBoxes_exposer.def( 
                "length"
                , length_function_value );
        
        }
        { //::SireMM::CLJBoxes::nAtoms
        
            typedef int ( ::SireMM::CLJBoxes::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMM::CLJBoxes::nAtoms );
            
            CLJBoxes_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMM::CLJBoxes::nOccupiedBoxes
        
            typedef int ( ::SireMM::CLJBoxes::*nOccupiedBoxes_function_type )(  ) const;
            nOccupiedBoxes_function_type nOccupiedBoxes_function_value( &::SireMM::CLJBoxes::nOccupiedBoxes );
            
            CLJBoxes_exposer.def( 
                "nOccupiedBoxes"
                , nOccupiedBoxes_function_value );
        
        }
        { //::SireMM::CLJBoxes::occupiedBoxIndicies
        
            typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJBoxes::*occupiedBoxIndicies_function_type )(  ) const;
            occupiedBoxIndicies_function_type occupiedBoxIndicies_function_value( &::SireMM::CLJBoxes::occupiedBoxIndicies );
            
            CLJBoxes_exposer.def( 
                "occupiedBoxIndicies"
                , occupiedBoxIndicies_function_value );
        
        }
        { //::SireMM::CLJBoxes::occupiedBoxes
        
            typedef ::QVector< SireMM::CLJBoxPtr > const & ( ::SireMM::CLJBoxes::*occupiedBoxes_function_type )(  ) const;
            occupiedBoxes_function_type occupiedBoxes_function_value( &::SireMM::CLJBoxes::occupiedBoxes );
            
            CLJBoxes_exposer.def( 
                "occupiedBoxes"
                , occupiedBoxes_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        CLJBoxes_exposer.def( bp::self != bp::self );
        CLJBoxes_exposer.def( bp::self + bp::self );
        { //::SireMM::CLJBoxes::operator=
        
            typedef ::SireMM::CLJBoxes & ( ::SireMM::CLJBoxes::*assign_function_type )( ::SireMM::CLJBoxes const & ) ;
            assign_function_type assign_function_value( &::SireMM::CLJBoxes::operator= );
            
            CLJBoxes_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        CLJBoxes_exposer.def( bp::self == bp::self );
        { //::SireMM::CLJBoxes::operator[]
        
            typedef ::SireMM::CLJAtom ( ::SireMM::CLJBoxes::*__getitem___function_type )( ::SireMM::CLJBoxIndex const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMM::CLJBoxes::operator[] );
            
            CLJBoxes_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("idx") ) );
        
        }
        { //::SireMM::CLJBoxes::remove
        
            typedef void ( ::SireMM::CLJBoxes::*remove_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
            remove_function_type remove_function_value( &::SireMM::CLJBoxes::remove );
            
            CLJBoxes_exposer.def( 
                "remove"
                , remove_function_value
                , ( bp::arg("atoms") ) );
        
        }
        { //::SireMM::CLJBoxes::squeeze
        
            typedef ::SireMM::CLJBoxes ( ::SireMM::CLJBoxes::*squeeze_function_type )(  ) const;
            squeeze_function_type squeeze_function_value( &::SireMM::CLJBoxes::squeeze );
            
            CLJBoxes_exposer.def( 
                "squeeze"
                , squeeze_function_value );
        
        }
        { //::SireMM::CLJBoxes::take
        
            typedef ::SireMM::CLJAtoms ( ::SireMM::CLJBoxes::*take_function_type )( ::QVector< SireMM::CLJBoxIndex > const & ) ;
            take_function_type take_function_value( &::SireMM::CLJBoxes::take );
            
            CLJBoxes_exposer.def( 
                "take"
                , take_function_value
                , ( bp::arg("atoms") ) );
        
        }
        { //::SireMM::CLJBoxes::toString
        
            typedef ::QString ( ::SireMM::CLJBoxes::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMM::CLJBoxes::toString );
            
            CLJBoxes_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMM::CLJBoxes::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::CLJBoxes::typeName );
            
            CLJBoxes_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::CLJBoxes::what
        
            typedef char const * ( ::SireMM::CLJBoxes::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::CLJBoxes::what );
            
            CLJBoxes_exposer.def( 
                "what"
                , what_function_value );
        
        }
        CLJBoxes_exposer.staticmethod( "getDistances" );
        CLJBoxes_exposer.staticmethod( "typeName" );
        CLJBoxes_exposer.def( "__copy__", &__copy__);
        CLJBoxes_exposer.def( "__deepcopy__", &__copy__);
        CLJBoxes_exposer.def( "clone", &__copy__);
        CLJBoxes_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJBoxes >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJBoxes_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJBoxes >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        CLJBoxes_exposer.def( "__str__", &__str__< ::SireMM::CLJBoxes > );
        CLJBoxes_exposer.def( "__repr__", &__str__< ::SireMM::CLJBoxes > );
        CLJBoxes_exposer.def( "__getitem__", &::SireMM::CLJBoxes::getitem );
    }

}