예제 #1
0
void register_InternalParameters3D_class(){

    { //::SireMM::InternalParameters3D
        typedef bp::class_< SireMM::InternalParameters3D, bp::bases< SireMM::InternalParameters > > InternalParameters3D_exposer_t;
        InternalParameters3D_exposer_t InternalParameters3D_exposer = InternalParameters3D_exposer_t( "InternalParameters3D", "This class holds intramolecular bonding parameters for 3D molecules\n(so it also contains the 3D coordinates of the molecule)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
        bp::scope InternalParameters3D_scope( InternalParameters3D_exposer );
        InternalParameters3D_exposer.def( bp::init< SireMol::PartialMolecule const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, bool >(( bp::arg("molecule"), bp::arg("coords_property"), bp::arg("bond_params"), bp::arg("angle_params"), bp::arg("dihedral_params"), bp::arg("improper_params"), bp::arg("ub_params"), bp::arg("ss_params"), bp::arg("sb_params"), bp::arg("bb_params"), bp::arg("sbt_params"), bp::arg("isstrict") ), "Construct, creating the parameters from the passed molecule\nusing the supplied property names\nThrow: SireBase::missing_property\nThrow: SireError::invalid_cast\nThrow: SireError::incompatible_error\n") );
        InternalParameters3D_exposer.def( bp::init< SireMM::InternalParameters3D const & >(( bp::arg("other") ), "Copy constructor") );
        { //::SireMM::InternalParameters3D::addChangedGroups
        
            typedef void ( ::SireMM::InternalParameters3D::*addChangedGroups_function_type)( ::SireMM::InternalParameters3D const &,::QSet< unsigned int > & ) const;
            addChangedGroups_function_type addChangedGroups_function_value( &::SireMM::InternalParameters3D::addChangedGroups );
            
            InternalParameters3D_exposer.def( 
                "addChangedGroups"
                , addChangedGroups_function_value
                , ( bp::arg("other"), bp::arg("changed_groups") )
                , "Add the changed groups that are different in other compared to this\nto changed_groups" );
        
        }
        { //::SireMM::InternalParameters3D::applyMask
        
            typedef ::SireMM::InternalParameters3D ( ::SireMM::InternalParameters3D::*applyMask_function_type)( ::QSet< unsigned int > const & ) const;
            applyMask_function_type applyMask_function_value( &::SireMM::InternalParameters3D::applyMask );
            
            InternalParameters3D_exposer.def( 
                "applyMask"
                , applyMask_function_value
                , ( bp::arg("cgidxs") )
                , "Mask these parameters so that only the parameters for the CutGroups\nwhose indicies are in cgidxs are contained." );
        
        }
        { //::SireMM::InternalParameters3D::atomicCoordinates
        
            typedef ::SireVol::CoordGroupArray const & ( ::SireMM::InternalParameters3D::*atomicCoordinates_function_type)(  ) const;
            atomicCoordinates_function_type atomicCoordinates_function_value( &::SireMM::InternalParameters3D::atomicCoordinates );
            
            InternalParameters3D_exposer.def( 
                "atomicCoordinates"
                , atomicCoordinates_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "Return the coordinates" );
        
        }
        { //::SireMM::InternalParameters3D::changedAllGroups
        
            typedef bool ( ::SireMM::InternalParameters3D::*changedAllGroups_function_type)( ::SireMM::InternalParameters3D const & ) const;
            changedAllGroups_function_type changedAllGroups_function_value( &::SireMM::InternalParameters3D::changedAllGroups );
            
            InternalParameters3D_exposer.def( 
                "changedAllGroups"
                , changedAllGroups_function_value
                , ( bp::arg("other") )
                , "Return whether or not all of the CutGroup have changed compared to other" );
        
        }
        { //::SireMM::InternalParameters3D::getChangedGroups
        
            typedef ::QSet< unsigned int > ( ::SireMM::InternalParameters3D::*getChangedGroups_function_type)( ::SireMM::InternalParameters3D const & ) const;
            getChangedGroups_function_type getChangedGroups_function_value( &::SireMM::InternalParameters3D::getChangedGroups );
            
            InternalParameters3D_exposer.def( 
                "getChangedGroups"
                , getChangedGroups_function_value
                , ( bp::arg("other") )
                , "Return the indicies of the CutGroups that have changed in other compared\nto this set of parameters" );
        
        }
        { //::SireMM::InternalParameters3D::nCutGroups
        
            typedef int ( ::SireMM::InternalParameters3D::*nCutGroups_function_type)(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMM::InternalParameters3D::nCutGroups );
            
            InternalParameters3D_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value
                , "Return the number of CutGroups in the molecule whose parameters are\ncontained in this object" );
        
        }
        InternalParameters3D_exposer.def( bp::self != bp::self );
        { //::SireMM::InternalParameters3D::operator=
        
            typedef ::SireMM::InternalParameters3D & ( ::SireMM::InternalParameters3D::*assign_function_type)( ::SireMM::InternalParameters3D const & ) ;
            assign_function_type assign_function_value( &::SireMM::InternalParameters3D::operator= );
            
            InternalParameters3D_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        InternalParameters3D_exposer.def( bp::self == bp::self );
        { //::SireMM::InternalParameters3D::setAtomicCoordinates
        
            typedef void ( ::SireMM::InternalParameters3D::*setAtomicCoordinates_function_type)( ::SireFF::detail::AtomicCoords3D const & ) ;
            setAtomicCoordinates_function_type setAtomicCoordinates_function_value( &::SireMM::InternalParameters3D::setAtomicCoordinates );
            
            InternalParameters3D_exposer.def( 
                "setAtomicCoordinates"
                , setAtomicCoordinates_function_value
                , ( bp::arg("coords") )
                , "Set the coordinates used by these parameters" );
        
        }
        { //::SireMM::InternalParameters3D::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::InternalParameters3D::typeName );
            
            InternalParameters3D_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        { //::SireMM::InternalParameters3D::what
        
            typedef char const * ( ::SireMM::InternalParameters3D::*what_function_type)(  ) const;
            what_function_type what_function_value( &::SireMM::InternalParameters3D::what );
            
            InternalParameters3D_exposer.def( 
                "what"
                , what_function_value
                , "" );
        
        }
        InternalParameters3D_exposer.staticmethod( "typeName" );
        InternalParameters3D_exposer.def( "__copy__", &__copy__);
        InternalParameters3D_exposer.def( "__deepcopy__", &__copy__);
        InternalParameters3D_exposer.def( "clone", &__copy__);
        InternalParameters3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__str__", &pvt_get_name);
        InternalParameters3D_exposer.def( "__repr__", &pvt_get_name);
    }

}
예제 #2
0
void register_MolPotentialTable_class(){

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

}
예제 #3
0
void register_AtomFloatProperty_class(){

    { //::SireMol::AtomProperty< double >
        typedef bp::class_< SireMol::AtomProperty< double >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomFloatProperty_exposer_t;
        AtomFloatProperty_exposer_t AtomFloatProperty_exposer = AtomFloatProperty_exposer_t( "AtomFloatProperty", "", bp::init< >("") );
        bp::scope AtomFloatProperty_scope( AtomFloatProperty_exposer );
        AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const &, double const & >(( bp::arg("molinfo"), bp::arg("default_value") ), "") );
        AtomFloatProperty_exposer.def( bp::init< double const & >(( bp::arg("value") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireBase::PackedArray2D< double > const & >(( bp::arg("values") ), "") );
        AtomFloatProperty_exposer.def( bp::init< SireMol::AtomProperty< double > const & >(( bp::arg("other") ), "") );
        { //::SireMol::AtomProperty< double >::array
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double > const & ( ::SireMol::AtomProperty< double >::*array_function_type)(  ) const;
            array_function_type array_function_value( &::SireMol::AtomProperty< double >::array );
            
            AtomFloatProperty_exposer.def( 
                "array"
                , array_function_value
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::assertCanConvert
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*assertCanConvert_function_type)( ::QVariant const & ) const;
            assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< double >::assertCanConvert );
            
            AtomFloatProperty_exposer.def( 
                "assertCanConvert"
                , assertCanConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::assignFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*assignFrom_function_type)( ::SireMol::AtomProperty< QVariant > const & ) ;
            assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< double >::assignFrom );
            
            AtomFloatProperty_exposer.def( 
                "assignFrom"
                , assignFrom_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::at
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGIdx ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
            
            AtomFloatProperty_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::at
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGAtomIdx const & ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
            
            AtomFloatProperty_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::canConvert
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*canConvert_function_type)( ::QVariant const & ) const;
            canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< double >::canConvert );
            
            AtomFloatProperty_exposer.def( 
                "canConvert"
                , canConvert_function_value
                , ( bp::arg("value") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::copyFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
            
            AtomFloatProperty_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::copyFrom
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const &,::SireMol::AtomSelection const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
            
            AtomFloatProperty_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values"), bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::count
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*count_function_type)(  ) const;
            count_function_type count_function_value( &::SireMol::AtomProperty< double >::count );
            
            AtomFloatProperty_exposer.def( 
                "count"
                , count_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::divide
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divide_function_type)( ::QVector< SireMol::AtomSelection > const & ) const;
            divide_function_type divide_function_value( &::SireMol::AtomProperty< double >::divide );
            
            AtomFloatProperty_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("beads") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::divideByResidue
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divideByResidue_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< double >::divideByResidue );
            
            AtomFloatProperty_exposer.def( 
                "divideByResidue"
                , divideByResidue_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::fromVariant
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< double >::fromVariant );
            
            AtomFloatProperty_exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::get
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGIdx ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
            
            AtomFloatProperty_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::get
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGAtomIdx const & ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
            
            AtomFloatProperty_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isCompatibleWith
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
            
            AtomFloatProperty_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isCompatibleWith
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfo const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
            
            AtomFloatProperty_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::isEmpty
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< double >::*isEmpty_function_type)(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::AtomProperty< double >::isEmpty );
            
            AtomFloatProperty_exposer.def( 
                "isEmpty"
                , isEmpty_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::matchToSelection
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > ( ::SireMol::AtomProperty< double >::*matchToSelection_function_type)( ::SireMol::AtomSelection const & ) const;
            matchToSelection_function_type matchToSelection_function_value( &::SireMol::AtomProperty< double >::matchToSelection );
            
            AtomFloatProperty_exposer.def( 
                "matchToSelection"
                , matchToSelection_function_value
                , ( bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::merge
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*merge_function_type)( ::SireMol::MoleculeInfoData const & ) const;
            merge_function_type merge_function_value( &::SireMol::AtomProperty< double >::merge );
            
            AtomFloatProperty_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("molinfo") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nAtoms
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
            
            AtomFloatProperty_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nAtoms
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ::SireMol::CGIdx ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
            
            AtomFloatProperty_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , ( bp::arg("cgidx") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::nCutGroups
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*nCutGroups_function_type)(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< double >::nCutGroups );
            
            AtomFloatProperty_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value
                , "" );
        
        }
        AtomFloatProperty_exposer.def( bp::self != bp::self );
        { //::SireMol::AtomProperty< double >::operator=
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*assign_function_type)( ::SireMol::AtomProperty< double > const & ) ;
            assign_function_type assign_function_value( &::SireMol::AtomProperty< double >::operator= );
            
            AtomFloatProperty_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >()
                , "" );
        
        }
        AtomFloatProperty_exposer.def( bp::self == bp::self );
        { //::SireMol::AtomProperty< double >::operator[]
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGIdx ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
            
            AtomFloatProperty_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::operator[]
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef double const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGAtomIdx const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
            
            AtomFloatProperty_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::set
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGAtomIdx const &,double const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
            
            AtomFloatProperty_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgatomidx"), bp::arg("value") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::set
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGIdx,::QVector< double > const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
            
            AtomFloatProperty_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("values") )
                , bp::return_self< >()
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::size
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< double >::*size_function_type)(  ) const;
            size_function_type size_function_value( &::SireMol::AtomProperty< double >::size );
            
            AtomFloatProperty_exposer.def( 
                "size"
                , size_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toString
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QString ( ::SireMol::AtomProperty< double >::*toString_function_type)(  ) const;
            toString_function_type toString_function_value( &::SireMol::AtomProperty< double >::toString );
            
            AtomFloatProperty_exposer.def( 
                "toString"
                , toString_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVariant
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< double >::*toVariant_function_type)(  ) const;
            toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< double >::toVariant );
            
            AtomFloatProperty_exposer.def( 
                "toVariant"
                , toVariant_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVector
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)(  ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
            
            AtomFloatProperty_exposer.def( 
                "toVector"
                , toVector_function_value
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::toVector
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ::SireMol::AtomSelection const & ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
            
            AtomFloatProperty_exposer.def( 
                "toVector"
                , toVector_function_value
                , ( bp::arg("selection") )
                , "" );
        
        }
        { //::SireMol::AtomProperty< double >::typeName
        
            typedef SireMol::AtomProperty< double > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::AtomProperty< double >::typeName );
            
            AtomFloatProperty_exposer.def( 
                "typeName"
                , typeName_function_value
                , "" );
        
        }
        AtomFloatProperty_exposer.staticmethod( "fromVariant" );
        AtomFloatProperty_exposer.staticmethod( "typeName" );
        AtomFloatProperty_exposer.def( "__copy__", &__copy__);
        AtomFloatProperty_exposer.def( "__deepcopy__", &__copy__);
        AtomFloatProperty_exposer.def( "clone", &__copy__);
        AtomFloatProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomFloatProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<double> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomFloatProperty_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<double> > );
        AtomFloatProperty_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<double> > );
        AtomFloatProperty_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<double> > );
    }

}
void register_InternalParameters3D_class(){

    { //::SireMM::InternalParameters3D
        typedef bp::class_< SireMM::InternalParameters3D, bp::bases< SireMM::InternalParameters > > InternalParameters3D_exposer_t;
        InternalParameters3D_exposer_t InternalParameters3D_exposer = InternalParameters3D_exposer_t( "InternalParameters3D", bp::init< >() );
        bp::scope InternalParameters3D_scope( InternalParameters3D_exposer );
        InternalParameters3D_exposer.def( bp::init< SireMol::PartialMolecule const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, SireBase::PropertyName const &, bool >(( bp::arg("molecule"), bp::arg("coords_property"), bp::arg("bond_params"), bp::arg("angle_params"), bp::arg("dihedral_params"), bp::arg("improper_params"), bp::arg("ub_params"), bp::arg("ss_params"), bp::arg("sb_params"), bp::arg("bb_params"), bp::arg("sbt_params"), bp::arg("isstrict") )) );
        InternalParameters3D_exposer.def( bp::init< SireMM::InternalParameters3D const & >(( bp::arg("other") )) );
        { //::SireMM::InternalParameters3D::addChangedGroups
        
            typedef void ( ::SireMM::InternalParameters3D::*addChangedGroups_function_type )( ::SireMM::InternalParameters3D const &,::QSet< unsigned int > & ) const;
            addChangedGroups_function_type addChangedGroups_function_value( &::SireMM::InternalParameters3D::addChangedGroups );
            
            InternalParameters3D_exposer.def( 
                "addChangedGroups"
                , addChangedGroups_function_value
                , ( bp::arg("other"), bp::arg("changed_groups") ) );
        
        }
        { //::SireMM::InternalParameters3D::applyMask
        
            typedef ::SireMM::InternalParameters3D ( ::SireMM::InternalParameters3D::*applyMask_function_type )( ::QSet< unsigned int > const & ) const;
            applyMask_function_type applyMask_function_value( &::SireMM::InternalParameters3D::applyMask );
            
            InternalParameters3D_exposer.def( 
                "applyMask"
                , applyMask_function_value
                , ( bp::arg("cgidxs") ) );
        
        }
        { //::SireMM::InternalParameters3D::atomicCoordinates
        
            typedef ::SireVol::CoordGroupArray const & ( ::SireMM::InternalParameters3D::*atomicCoordinates_function_type )(  ) const;
            atomicCoordinates_function_type atomicCoordinates_function_value( &::SireMM::InternalParameters3D::atomicCoordinates );
            
            InternalParameters3D_exposer.def( 
                "atomicCoordinates"
                , atomicCoordinates_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMM::InternalParameters3D::changedAllGroups
        
            typedef bool ( ::SireMM::InternalParameters3D::*changedAllGroups_function_type )( ::SireMM::InternalParameters3D const & ) const;
            changedAllGroups_function_type changedAllGroups_function_value( &::SireMM::InternalParameters3D::changedAllGroups );
            
            InternalParameters3D_exposer.def( 
                "changedAllGroups"
                , changedAllGroups_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMM::InternalParameters3D::getChangedGroups
        
            typedef ::QSet< unsigned int > ( ::SireMM::InternalParameters3D::*getChangedGroups_function_type )( ::SireMM::InternalParameters3D const & ) const;
            getChangedGroups_function_type getChangedGroups_function_value( &::SireMM::InternalParameters3D::getChangedGroups );
            
            InternalParameters3D_exposer.def( 
                "getChangedGroups"
                , getChangedGroups_function_value
                , ( bp::arg("other") ) );
        
        }
        { //::SireMM::InternalParameters3D::nCutGroups
        
            typedef int ( ::SireMM::InternalParameters3D::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMM::InternalParameters3D::nCutGroups );
            
            InternalParameters3D_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        InternalParameters3D_exposer.def( bp::self != bp::self );
        { //::SireMM::InternalParameters3D::operator=
        
            typedef ::SireMM::InternalParameters3D & ( ::SireMM::InternalParameters3D::*assign_function_type )( ::SireMM::InternalParameters3D const & ) ;
            assign_function_type assign_function_value( &::SireMM::InternalParameters3D::operator= );
            
            InternalParameters3D_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        InternalParameters3D_exposer.def( bp::self == bp::self );
        { //::SireMM::InternalParameters3D::setAtomicCoordinates
        
            typedef void ( ::SireMM::InternalParameters3D::*setAtomicCoordinates_function_type )( ::SireFF::detail::AtomicCoords3D const & ) ;
            setAtomicCoordinates_function_type setAtomicCoordinates_function_value( &::SireMM::InternalParameters3D::setAtomicCoordinates );
            
            InternalParameters3D_exposer.def( 
                "setAtomicCoordinates"
                , setAtomicCoordinates_function_value
                , ( bp::arg("coords") ) );
        
        }
        { //::SireMM::InternalParameters3D::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMM::InternalParameters3D::typeName );
            
            InternalParameters3D_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMM::InternalParameters3D::what
        
            typedef char const * ( ::SireMM::InternalParameters3D::*what_function_type )(  ) const;
            what_function_type what_function_value( &::SireMM::InternalParameters3D::what );
            
            InternalParameters3D_exposer.def( 
                "what"
                , what_function_value );
        
        }
        InternalParameters3D_exposer.staticmethod( "typeName" );
        InternalParameters3D_exposer.def( "__copy__", &__copy__);
        InternalParameters3D_exposer.def( "__deepcopy__", &__copy__);
        InternalParameters3D_exposer.def( "clone", &__copy__);
        InternalParameters3D_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::InternalParameters3D >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        InternalParameters3D_exposer.def( "__str__", &pvt_get_name);
        InternalParameters3D_exposer.def( "__repr__", &pvt_get_name);
    }

}
예제 #5
0
void register_AtomCoords_class(){

    { //::SireMol::AtomProperty< SireMaths::Vector >
        typedef bp::class_< SireMol::AtomProperty< SireMaths::Vector >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomCoords_exposer_t;
        AtomCoords_exposer_t AtomCoords_exposer = AtomCoords_exposer_t( "AtomCoords", bp::init< >() );
        bp::scope AtomCoords_scope( AtomCoords_exposer );
        AtomCoords_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
        AtomCoords_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") )) );
        AtomCoords_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgroups") )) );
        AtomCoords_exposer.def( bp::init< SireMol::AtomProperty< SireMaths::Vector > const & >(( bp::arg("other") )) );
        { //::SireMol::AtomProperty< SireMaths::Vector >::array
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroupArray const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*array_function_type )(  ) const;
            array_function_type array_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::array );
            
            AtomCoords_exposer.def( 
                "array"
                , array_function_value
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assertCanConvert_function_type )( ::QVariant const & ) const;
            assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert );
            
            AtomCoords_exposer.def( 
                "assertCanConvert"
                , assertCanConvert_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::assignFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assignFrom_function_type )( ::SireMol::AtomProperty< QVariant > const & ) ;
            assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assignFrom );
            
            AtomCoords_exposer.def( 
                "assignFrom"
                , assignFrom_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::at
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGIdx ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
            
            AtomCoords_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::at
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGAtomIdx const & ) const;
            at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
            
            AtomCoords_exposer.def( 
                "at"
                , at_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::canConvert
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*canConvert_function_type )( ::QVariant const & ) const;
            canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::canConvert );
            
            AtomCoords_exposer.def( 
                "canConvert"
                , canConvert_function_value
                , ( bp::arg("value") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
            
            AtomCoords_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("from_frame"), bp::arg("to_frame") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
            changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
            
            AtomCoords_exposer.def( 
                "changeFrame"
                , changeFrame_function_value
                , ( bp::arg("cgidx"), bp::arg("from_frame"), bp::arg("to_frame") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
            
            AtomCoords_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const &,::SireMol::AtomSelection const & ) ;
            copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
            
            AtomCoords_exposer.def( 
                "copyFrom"
                , copyFrom_function_value
                , ( bp::arg("values"), bp::arg("selection") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::count
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*count_function_type )(  ) const;
            count_function_type count_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::count );
            
            AtomCoords_exposer.def( 
                "count"
                , count_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::divide
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divide_function_type )( ::QVector< SireMol::AtomSelection > const & ) const;
            divide_function_type divide_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divide );
            
            AtomCoords_exposer.def( 
                "divide"
                , divide_function_value
                , ( bp::arg("beads") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divideByResidue_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue );
            
            AtomCoords_exposer.def( 
                "divideByResidue"
                , divideByResidue_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::fromVariant
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
            fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::fromVariant );
            
            AtomCoords_exposer.def( 
                "fromVariant"
                , fromVariant_function_value
                , ( bp::arg("variant") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::get
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGIdx ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
            
            AtomCoords_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::get
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGAtomIdx const & ) const;
            get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
            
            AtomCoords_exposer.def( 
                "get"
                , get_function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith );
            
            AtomCoords_exposer.def( 
                "isCompatibleWith"
                , isCompatibleWith_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
            
            AtomCoords_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("axes") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const & ) ;
            mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
            
            AtomCoords_exposer.def( 
                "mapInto"
                , mapInto_function_value
                , ( bp::arg("cgidx"), bp::arg("axes") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::merge
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*merge_function_type )( ::SireMol::MoleculeInfoData const & ) const;
            merge_function_type merge_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::merge );
            
            AtomCoords_exposer.def( 
                "merge"
                , merge_function_value
                , ( bp::arg("molinfo") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
            
            AtomCoords_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ::SireMol::CGIdx ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
            
            AtomCoords_exposer.def( 
                "nAtoms"
                , nAtoms_function_value
                , ( bp::arg("cgidx") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups );
            
            AtomCoords_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        AtomCoords_exposer.def( bp::self != bp::self );
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator=
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*assign_function_type )( ::SireMol::AtomProperty< SireMaths::Vector > const & ) ;
            assign_function_type assign_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator= );
            
            AtomCoords_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        AtomCoords_exposer.def( bp::self == bp::self );
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGIdx ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
            
            AtomCoords_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGAtomIdx const & ) const;
            __getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
            
            AtomCoords_exposer.def( 
                "__getitem__"
                , __getitem___function_value
                , ( bp::arg("cgatomidx") )
                , bp::return_value_policy< bp::copy_const_reference >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("quat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("rotmat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("cgidx"), bp::arg("quat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::rotate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
            rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
            
            AtomCoords_exposer.def( 
                "rotate"
                , rotate_function_value
                , ( bp::arg("cgidx"), bp::arg("rotmat"), bp::arg("point") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGAtomIdx const &,::SireMaths::Vector const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgatomidx"), bp::arg("value") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::QVector< SireMaths::Vector > const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("values") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::set
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::SireVol::CoordGroup const & ) ;
            set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
            
            AtomCoords_exposer.def( 
                "set"
                , set_function_value
                , ( bp::arg("cgidx"), bp::arg("cgroup") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::size
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*size_function_type )(  ) const;
            size_function_type size_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::size );
            
            AtomCoords_exposer.def( 
                "size"
                , size_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVariant
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVariant_function_type )(  ) const;
            toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVariant );
            
            AtomCoords_exposer.def( 
                "toVariant"
                , toVariant_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVector
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )(  ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
            
            AtomCoords_exposer.def( 
                "toVector"
                , toVector_function_value );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::toVector
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
            toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
            
            AtomCoords_exposer.def( 
                "toVector"
                , toVector_function_value
                , ( bp::arg("selection") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::transform
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
            
            AtomCoords_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("t") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::transform
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMol::CGIdx,::SireMaths::Transform const & ) ;
            transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
            
            AtomCoords_exposer.def( 
                "transform"
                , transform_function_value
                , ( bp::arg("cgidx"), bp::arg("t") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::translate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
            
            AtomCoords_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("delta") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::translate
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMol::CGIdx,::SireMaths::Vector const & ) ;
            translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
            
            AtomCoords_exposer.def( 
                "translate"
                , translate_function_value
                , ( bp::arg("cgidx"), bp::arg("delta") ) );
        
        }
        { //::SireMol::AtomProperty< SireMaths::Vector >::typeName
        
            typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::typeName );
            
            AtomCoords_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        AtomCoords_exposer.staticmethod( "fromVariant" );
        AtomCoords_exposer.staticmethod( "typeName" );
        AtomCoords_exposer.def( "__copy__", &__copy__);
        AtomCoords_exposer.def( "__deepcopy__", &__copy__);
        AtomCoords_exposer.def( "clone", &__copy__);
        AtomCoords_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomCoords_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        AtomCoords_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
        AtomCoords_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
        AtomCoords_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<SireMaths::Vector> > );
    }

}
예제 #6
0
void register_PartialMolecule_class(){

    { //::SireMol::PartialMolecule
        typedef bp::class_< SireMol::PartialMolecule, bp::bases< SireMol::MoleculeView, SireBase::Property > > PartialMolecule_exposer_t;
        PartialMolecule_exposer_t PartialMolecule_exposer = PartialMolecule_exposer_t( "PartialMolecule", bp::init< >() );
        bp::scope PartialMolecule_scope( PartialMolecule_exposer );
        PartialMolecule_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molecule") )) );
        PartialMolecule_exposer.def( bp::init< SireMol::MoleculeData const &, SireMol::AtomSelection const & >(( bp::arg("moldata"), bp::arg("atoms") )) );
        PartialMolecule_exposer.def( bp::init< SireMol::PartialMolecule const & >(( bp::arg("other") )) );
        { //::SireMol::PartialMolecule::evaluate
        
            typedef ::SireMol::Evaluator ( ::SireMol::PartialMolecule::*evaluate_function_type )(  ) const;
            evaluate_function_type evaluate_function_value( &::SireMol::PartialMolecule::evaluate );
            
            PartialMolecule_exposer.def( 
                "evaluate"
                , evaluate_function_value );
        
        }
        { //::SireMol::PartialMolecule::extract
        
            typedef ::SireMol::PartialMolecule ( ::SireMol::PartialMolecule::*extract_function_type )(  ) const;
            extract_function_type extract_function_value( &::SireMol::PartialMolecule::extract );
            
            PartialMolecule_exposer.def( 
                "extract"
                , extract_function_value );
        
        }
        { //::SireMol::PartialMolecule::hasMetadata
        
            typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
            
            PartialMolecule_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("metakey") ) );
        
        }
        { //::SireMol::PartialMolecule::hasMetadata
        
            typedef bool ( ::SireMol::PartialMolecule::*hasMetadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            hasMetadata_function_type hasMetadata_function_value( &::SireMol::PartialMolecule::hasMetadata );
            
            PartialMolecule_exposer.def( 
                "hasMetadata"
                , hasMetadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") ) );
        
        }
        { //::SireMol::PartialMolecule::hasProperty
        
            typedef bool ( ::SireMol::PartialMolecule::*hasProperty_function_type )( ::SireBase::PropertyName const & ) const;
            hasProperty_function_type hasProperty_function_value( &::SireMol::PartialMolecule::hasProperty );
            
            PartialMolecule_exposer.def( 
                "hasProperty"
                , hasProperty_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::PartialMolecule::isEmpty
        
            typedef bool ( ::SireMol::PartialMolecule::*isEmpty_function_type )(  ) const;
            isEmpty_function_type isEmpty_function_value( &::SireMol::PartialMolecule::isEmpty );
            
            PartialMolecule_exposer.def( 
                "isEmpty"
                , isEmpty_function_value );
        
        }
        { //::SireMol::PartialMolecule::metadata
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const & ) const;
            metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
            
            PartialMolecule_exposer.def( 
                "metadata"
                , metadata_function_value
                , ( bp::arg("metakey") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::metadata
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*metadata_function_type )( ::SireBase::PropertyName const &,::SireBase::PropertyName const & ) const;
            metadata_function_type metadata_function_value( &::SireMol::PartialMolecule::metadata );
            
            PartialMolecule_exposer.def( 
                "metadata"
                , metadata_function_value
                , ( bp::arg("key"), bp::arg("metakey") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::metadataKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )(  ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
            
            PartialMolecule_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value );
        
        }
        { //::SireMol::PartialMolecule::metadataKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*metadataKeys_function_type )( ::SireBase::PropertyName const & ) const;
            metadataKeys_function_type metadataKeys_function_value( &::SireMol::PartialMolecule::metadataKeys );
            
            PartialMolecule_exposer.def( 
                "metadataKeys"
                , metadataKeys_function_value
                , ( bp::arg("key") ) );
        
        }
        { //::SireMol::PartialMolecule::move
        
            typedef ::SireMol::Mover< SireMol::PartialMolecule > ( ::SireMol::PartialMolecule::*move_function_type )(  ) const;
            move_function_type move_function_value( &::SireMol::PartialMolecule::move );
            
            PartialMolecule_exposer.def( 
                "move"
                , move_function_value );
        
        }
        { //::SireMol::PartialMolecule::nAtoms
        
            typedef int ( ::SireMol::PartialMolecule::*nAtoms_function_type )(  ) const;
            nAtoms_function_type nAtoms_function_value( &::SireMol::PartialMolecule::nAtoms );
            
            PartialMolecule_exposer.def( 
                "nAtoms"
                , nAtoms_function_value );
        
        }
        { //::SireMol::PartialMolecule::nChains
        
            typedef int ( ::SireMol::PartialMolecule::*nChains_function_type )(  ) const;
            nChains_function_type nChains_function_value( &::SireMol::PartialMolecule::nChains );
            
            PartialMolecule_exposer.def( 
                "nChains"
                , nChains_function_value );
        
        }
        { //::SireMol::PartialMolecule::nCutGroups
        
            typedef int ( ::SireMol::PartialMolecule::*nCutGroups_function_type )(  ) const;
            nCutGroups_function_type nCutGroups_function_value( &::SireMol::PartialMolecule::nCutGroups );
            
            PartialMolecule_exposer.def( 
                "nCutGroups"
                , nCutGroups_function_value );
        
        }
        { //::SireMol::PartialMolecule::nResidues
        
            typedef int ( ::SireMol::PartialMolecule::*nResidues_function_type )(  ) const;
            nResidues_function_type nResidues_function_value( &::SireMol::PartialMolecule::nResidues );
            
            PartialMolecule_exposer.def( 
                "nResidues"
                , nResidues_function_value );
        
        }
        { //::SireMol::PartialMolecule::nSegments
        
            typedef int ( ::SireMol::PartialMolecule::*nSegments_function_type )(  ) const;
            nSegments_function_type nSegments_function_value( &::SireMol::PartialMolecule::nSegments );
            
            PartialMolecule_exposer.def( 
                "nSegments"
                , nSegments_function_value );
        
        }
        { //::SireMol::PartialMolecule::name
        
            typedef ::SireMol::MolName const & ( ::SireMol::PartialMolecule::*name_function_type )(  ) const;
            name_function_type name_function_value( &::SireMol::PartialMolecule::name );
            
            PartialMolecule_exposer.def( 
                "name"
                , name_function_value
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::number
        
            typedef ::SireMol::MolNum ( ::SireMol::PartialMolecule::*number_function_type )(  ) const;
            number_function_type number_function_value( &::SireMol::PartialMolecule::number );
            
            PartialMolecule_exposer.def( 
                "number"
                , number_function_value );
        
        }
        PartialMolecule_exposer.def( bp::self != bp::self );
        { //::SireMol::PartialMolecule::operator=
        
            typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::MoleculeView const & ) ;
            assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
            
            PartialMolecule_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        { //::SireMol::PartialMolecule::operator=
        
            typedef ::SireMol::PartialMolecule & ( ::SireMol::PartialMolecule::*assign_function_type )( ::SireMol::PartialMolecule const & ) ;
            assign_function_type assign_function_value( &::SireMol::PartialMolecule::operator= );
            
            PartialMolecule_exposer.def( 
                "assign"
                , assign_function_value
                , ( bp::arg("other") )
                , bp::return_self< >() );
        
        }
        PartialMolecule_exposer.def( bp::self == bp::self );
        { //::SireMol::PartialMolecule::property
        
            typedef ::SireBase::Property const & ( ::SireMol::PartialMolecule::*property_function_type )( ::SireBase::PropertyName const & ) const;
            property_function_type property_function_value( &::SireMol::PartialMolecule::property );
            
            PartialMolecule_exposer.def( 
                "property"
                , property_function_value
                , ( bp::arg("key") )
                , bp::return_value_policy<bp::clone_const_reference>() );
        
        }
        { //::SireMol::PartialMolecule::propertyKeys
        
            typedef ::QStringList ( ::SireMol::PartialMolecule::*propertyKeys_function_type )(  ) const;
            propertyKeys_function_type propertyKeys_function_value( &::SireMol::PartialMolecule::propertyKeys );
            
            PartialMolecule_exposer.def( 
                "propertyKeys"
                , propertyKeys_function_value );
        
        }
        { //::SireMol::PartialMolecule::selectedAll
        
            typedef bool ( ::SireMol::PartialMolecule::*selectedAll_function_type )(  ) const;
            selectedAll_function_type selectedAll_function_value( &::SireMol::PartialMolecule::selectedAll );
            
            PartialMolecule_exposer.def( 
                "selectedAll"
                , selectedAll_function_value );
        
        }
        { //::SireMol::PartialMolecule::selection
        
            typedef ::SireMol::AtomSelection ( ::SireMol::PartialMolecule::*selection_function_type )(  ) const;
            selection_function_type selection_function_value( &::SireMol::PartialMolecule::selection );
            
            PartialMolecule_exposer.def( 
                "selection"
                , selection_function_value );
        
        }
        { //::SireMol::PartialMolecule::toString
        
            typedef ::QString ( ::SireMol::PartialMolecule::*toString_function_type )(  ) const;
            toString_function_type toString_function_value( &::SireMol::PartialMolecule::toString );
            
            PartialMolecule_exposer.def( 
                "toString"
                , toString_function_value );
        
        }
        { //::SireMol::PartialMolecule::typeName
        
            typedef char const * ( *typeName_function_type )(  );
            typeName_function_type typeName_function_value( &::SireMol::PartialMolecule::typeName );
            
            PartialMolecule_exposer.def( 
                "typeName"
                , typeName_function_value );
        
        }
        { //::SireMol::PartialMolecule::version
        
            typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )(  ) const;
            version_function_type version_function_value( &::SireMol::PartialMolecule::version );
            
            PartialMolecule_exposer.def( 
                "version"
                , version_function_value );
        
        }
        { //::SireMol::PartialMolecule::version
        
            typedef ::quint64 ( ::SireMol::PartialMolecule::*version_function_type )( ::SireBase::PropertyName const & ) const;
            version_function_type version_function_value( &::SireMol::PartialMolecule::version );
            
            PartialMolecule_exposer.def( 
                "version"
                , version_function_value
                , ( bp::arg("key") ) );
        
        }
        PartialMolecule_exposer.staticmethod( "typeName" );
        PartialMolecule_exposer.def( "__copy__", &__copy__);
        PartialMolecule_exposer.def( "__deepcopy__", &__copy__);
        PartialMolecule_exposer.def( "clone", &__copy__);
        PartialMolecule_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::PartialMolecule >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PartialMolecule_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::PartialMolecule >,
                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
        PartialMolecule_exposer.def( "__str__", &__str__< ::SireMol::PartialMolecule > );
        PartialMolecule_exposer.def( "__repr__", &__str__< ::SireMol::PartialMolecule > );
    }

}