自学教程：C++ toString_function_value函数代码示例

//.........这里部分代码省略.........                        DoubleFunc_exposer.def(                 "isConstant"                , isConstant_function_value                , "Return whether or not this is constant" );                }        { //::SireCAS::DoubleFunc::isFunction                    typedef bool ( ::SireCAS::DoubleFunc::*isFunction_function_type)( ::SireCAS::Symbol const & ) const;            isFunction_function_type isFunction_function_value( &::SireCAS::DoubleFunc::isFunction );                        DoubleFunc_exposer.def(                 "isFunction"                , isFunction_function_value                , ( bp::arg("symbol") )                , "Return if this is a function of symbol" );                }        { //::SireCAS::DoubleFunc::operator=                    typedef ::SireCAS::DoubleFunc & ( ::SireCAS::DoubleFunc::*assign_function_type)( ::SireCAS::DoubleFunc const & ) ;            assign_function_type assign_function_value( &::SireCAS::DoubleFunc::operator= );                        DoubleFunc_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        { //::SireCAS::DoubleFunc::substitute                    typedef ::SireCAS::Expression ( ::SireCAS::DoubleFunc::*substitute_function_type)( ::SireCAS::Identities const & ) const;            substitute_function_type substitute_function_value( &::SireCAS::DoubleFunc::substitute );                        DoubleFunc_exposer.def(                 "substitute"                , substitute_function_value                , ( bp::arg("identities") )                , "Substitute into this expression" );                }        { //::SireCAS::DoubleFunc::symbols                    typedef ::SireCAS::Symbols ( ::SireCAS::DoubleFunc::*symbols_function_type)(  ) const;            symbols_function_type symbols_function_value( &::SireCAS::DoubleFunc::symbols );                        DoubleFunc_exposer.def(                 "symbols"                , symbols_function_value                , "Return the symbols used in this function" );                }        { //::SireCAS::DoubleFunc::toString                    typedef ::QString ( ::SireCAS::DoubleFunc::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireCAS::DoubleFunc::toString );                        DoubleFunc_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this function" );                }        { //::SireCAS::DoubleFunc::x                    typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*x_function_type)(  ) const;            x_function_type x_function_value( &::SireCAS::DoubleFunc::x );                        DoubleFunc_exposer.def(                 "x"                , x_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "" );                }        { //::SireCAS::DoubleFunc::y                    typedef ::SireCAS::Expression const & ( ::SireCAS::DoubleFunc::*y_function_type)(  ) const;            y_function_type y_function_value( &::SireCAS::DoubleFunc::y );                        DoubleFunc_exposer.def(                 "y"                , y_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "" );                }        DoubleFunc_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireCAS::DoubleFunc >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        DoubleFunc_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireCAS::DoubleFunc >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        DoubleFunc_exposer.def( "__str__", &__str__< ::SireCAS::DoubleFunc > );        DoubleFunc_exposer.def( "__repr__", &__str__< ::SireCAS::DoubleFunc > );        DoubleFunc_exposer.def( "__hash__", &::SireCAS::DoubleFunc::hash );    }}

//.........这里部分代码省略.........            typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( double ) const;            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );                        Expression_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("val") ) );                }        { //::SireCAS::Expression::subtract                    typedef ::SireCAS::Expression ( ::SireCAS::Expression::*subtract_function_type )( ::SireMaths::Complex const & ) const;            subtract_function_type subtract_function_value( &::SireCAS::Expression::subtract );                        Expression_exposer.def(                 "subtract"                , subtract_function_value                , ( bp::arg("val") ) );                }        { //::SireCAS::Expression::symbols                    typedef ::SireCAS::Symbols ( ::SireCAS::Expression::*symbols_function_type )(  ) const;            symbols_function_type symbols_function_value( &::SireCAS::Expression::symbols );                        Expression_exposer.def(                 "symbols"                , symbols_function_value );                }        { //::SireCAS::Expression::toString                    typedef ::QString ( ::SireCAS::Expression::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireCAS::Expression::toString );                        Expression_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireCAS::Expression::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireCAS::Expression::typeName );                        Expression_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireCAS::Expression::what                    typedef char const * ( ::SireCAS::Expression::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireCAS::Expression::what );                        Expression_exposer.def(                 "what"                , what_function_value );                }        Expression_exposer.staticmethod( "typeName" );        Expression_exposer.def( bp::self * bp::other< SireMaths::Complex >() );        Expression_exposer.def( bp::other< SireMaths::Complex >() * bp::self );        Expression_exposer.def( bp::self * bp::other< double >() );        Expression_exposer.def( bp::other< double >() * bp::self );        Expression_exposer.def( bp::self * bp::self );

//.........这里部分代码省略.........                "push"                , push_function_value                , ( bp::arg("boxes"), bp::arg("old_atoms"), bp::arg("new_atoms"), bp::arg("old_delta") )                , "Push the passed change onto the workspace. This changes the atoms in the/npassed CLJBoxes from their values in old_atoms to their values in the/npassed new_atoms. The last CLJDelta used for these atoms is supplied as/nold_delta, and this returns the new CLJDelta for these atoms." );                }        { //::SireMM::CLJWorkspace::recalculatingFromScratch                    typedef bool ( ::SireMM::CLJWorkspace::*recalculatingFromScratch_function_type)(  ) const;            recalculatingFromScratch_function_type recalculatingFromScratch_function_value( &::SireMM::CLJWorkspace::recalculatingFromScratch );                        CLJWorkspace_exposer.def(                 "recalculatingFromScratch"                , recalculatingFromScratch_function_value                , "Return whether or not we are recalculating everything from scratch" );                }        { //::SireMM::CLJWorkspace::removeSameIDAtoms                    typedef void ( ::SireMM::CLJWorkspace::*removeSameIDAtoms_function_type)( ::SireMM::CLJBoxes & ) ;            removeSameIDAtoms_function_type removeSameIDAtoms_function_value( &::SireMM::CLJWorkspace::removeSameIDAtoms );                        CLJWorkspace_exposer.def(                 "removeSameIDAtoms"                , removeSameIDAtoms_function_value                , ( bp::arg("boxes") )                , "Internal function used to fully remove atoms that have not been/nremoved because they all have the same ID. This is used when the/noptimisation of not removing same ID atoms would break the energy/ncalculation, e.g. if we have multiple CLJGroups and have multiple/nchanged IDs across these groups" );                }        { //::SireMM::CLJWorkspace::revert                    typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*revert_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;            revert_function_type revert_function_value( &::SireMM::CLJWorkspace::revert );                        CLJWorkspace_exposer.def(                 "revert"                , revert_function_value                , ( bp::arg("boxes"), bp::arg("delta") )                , "Revert the changes supplied in the passed delta" );                }        { //::SireMM::CLJWorkspace::size                    typedef int ( ::SireMM::CLJWorkspace::*size_function_type)(  ) const;            size_function_type size_function_value( &::SireMM::CLJWorkspace::size );                        CLJWorkspace_exposer.def(                 "size"                , size_function_value                , "Return the number of deltas" );                }        { //::SireMM::CLJWorkspace::toString                    typedef ::QString ( ::SireMM::CLJWorkspace::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMM::CLJWorkspace::toString );                        CLJWorkspace_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireMM::CLJWorkspace::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::CLJWorkspace::typeName );                        CLJWorkspace_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireMM::CLJWorkspace::what                    typedef char const * ( ::SireMM::CLJWorkspace::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireMM::CLJWorkspace::what );                        CLJWorkspace_exposer.def(                 "what"                , what_function_value                , "" );                }        CLJWorkspace_exposer.staticmethod( "typeName" );        CLJWorkspace_exposer.def( "__copy__", &__copy__);        CLJWorkspace_exposer.def( "__deepcopy__", &__copy__);        CLJWorkspace_exposer.def( "clone", &__copy__);        CLJWorkspace_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJWorkspace >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        CLJWorkspace_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJWorkspace >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        CLJWorkspace_exposer.def( "__str__", &__str__< ::SireMM::CLJWorkspace > );        CLJWorkspace_exposer.def( "__repr__", &__str__< ::SireMM::CLJWorkspace > );        CLJWorkspace_exposer.def( "__len__", &__len_size< ::SireMM::CLJWorkspace > );        CLJWorkspace_exposer.def( "__getitem__", &::SireMM::CLJWorkspace::getitem );    }}

//.........这里部分代码省略.........        }        LJParameter_exposer.def( bp::self != bp::self );        LJParameter_exposer.def( bp::self == bp::self );        { //::SireMM::LJParameter::rmin                    typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*rmin_function_type )(  ) const;            rmin_function_type rmin_function_value( &::SireMM::LJParameter::rmin );                        LJParameter_exposer.def(                 "rmin"                , rmin_function_value );                }        { //::SireMM::LJParameter::sigma                    typedef ::SireUnits::Dimension::Length ( ::SireMM::LJParameter::*sigma_function_type )(  ) const;            sigma_function_type sigma_function_value( &::SireMM::LJParameter::sigma );                        LJParameter_exposer.def(                 "sigma"                , sigma_function_value );                }        { //::SireMM::LJParameter::sqrtEpsilon                    typedef double ( ::SireMM::LJParameter::*sqrtEpsilon_function_type )(  ) const;            sqrtEpsilon_function_type sqrtEpsilon_function_value( &::SireMM::LJParameter::sqrtEpsilon );                        LJParameter_exposer.def(                 "sqrtEpsilon"                , sqrtEpsilon_function_value );                }        { //::SireMM::LJParameter::sqrtSigma                    typedef double ( ::SireMM::LJParameter::*sqrtSigma_function_type )(  ) const;            sqrtSigma_function_type sqrtSigma_function_value( &::SireMM::LJParameter::sqrtSigma );                        LJParameter_exposer.def(                 "sqrtSigma"                , sqrtSigma_function_value );                }        { //::SireMM::LJParameter::toString                    typedef ::QString ( ::SireMM::LJParameter::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMM::LJParameter::toString );                        LJParameter_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMM::LJParameter::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::LJParameter::typeName );                        LJParameter_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireMM::LJParameter::what                    typedef char const * ( ::SireMM::LJParameter::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireMM::LJParameter::what );                        LJParameter_exposer.def(                 "what"                , what_function_value );                }        { //::SireMM::LJParameter::zeroLJ                    typedef bool ( ::SireMM::LJParameter::*zeroLJ_function_type )(  ) const;            zeroLJ_function_type zeroLJ_function_value( &::SireMM::LJParameter::zeroLJ );                        LJParameter_exposer.def(                 "zeroLJ"                , zeroLJ_function_value );                }        LJParameter_exposer.staticmethod( "dummy" );        LJParameter_exposer.staticmethod( "fromAAndB" );        LJParameter_exposer.staticmethod( "fromRMinAndEpsilon" );        LJParameter_exposer.staticmethod( "fromSigmaAndEpsilon" );        LJParameter_exposer.staticmethod( "typeName" );        LJParameter_exposer.def( "__copy__", &__copy__);        LJParameter_exposer.def( "__deepcopy__", &__copy__);        LJParameter_exposer.def( "clone", &__copy__);        LJParameter_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJParameter >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        LJParameter_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJParameter >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        LJParameter_exposer.def( "__str__", &__str__< ::SireMM::LJParameter > );        LJParameter_exposer.def( "__repr__", &__str__< ::SireMM::LJParameter > );    }}

void register_AtomMultiMatcher_class(){    { //::SireMol::AtomMultiMatcher        typedef bp::class_< SireMol::AtomMultiMatcher, bp::bases< SireMol::AtomMatcher, SireBase::Property > > AtomMultiMatcher_exposer_t;        AtomMultiMatcher_exposer_t AtomMultiMatcher_exposer = AtomMultiMatcher_exposer_t( "AtomMultiMatcher", "This is an atom matcher combines several sub-AtomMatchers together/n/nAuthor: Christopher Woods/n", bp::init< >("Constructor") );        bp::scope AtomMultiMatcher_scope( AtomMultiMatcher_exposer );        AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const & >(( bp::arg("matcher") ), "Construct from a single match") );        AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMatcher const &, SireMol::AtomMatcher const & >(( bp::arg("m0"), bp::arg("m1") ), "Construct from a pair of matches") );        AtomMultiMatcher_exposer.def( bp::init< SireMol::AtomMultiMatcher const & >(( bp::arg("other") ), "Copy constructor") );        { //::SireMol::AtomMultiMatcher::isNull                    typedef bool ( ::SireMol::AtomMultiMatcher::*isNull_function_type)(  ) const;            isNull_function_type isNull_function_value( &::SireMol::AtomMultiMatcher::isNull );                        AtomMultiMatcher_exposer.def(                 "isNull"                , isNull_function_value                , "Return whether or not this matcher is null (cannot be used for matching)" );                }        AtomMultiMatcher_exposer.def( bp::self != bp::self );        { //::SireMol::AtomMultiMatcher::operator=                    typedef ::SireMol::AtomMultiMatcher & ( ::SireMol::AtomMultiMatcher::*assign_function_type)( ::SireMol::AtomMultiMatcher const & ) ;            assign_function_type assign_function_value( &::SireMol::AtomMultiMatcher::operator= );                        AtomMultiMatcher_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        AtomMultiMatcher_exposer.def( bp::self == bp::self );        { //::SireMol::AtomMultiMatcher::toString                    typedef ::QString ( ::SireMol::AtomMultiMatcher::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMol::AtomMultiMatcher::toString );                        AtomMultiMatcher_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireMol::AtomMultiMatcher::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMol::AtomMultiMatcher::typeName );                        AtomMultiMatcher_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireMol::AtomMultiMatcher::what                    typedef char const * ( ::SireMol::AtomMultiMatcher::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireMol::AtomMultiMatcher::what );                        AtomMultiMatcher_exposer.def(                 "what"                , what_function_value                , "" );                }        AtomMultiMatcher_exposer.staticmethod( "typeName" );        AtomMultiMatcher_exposer.def( "__copy__", &__copy__);        AtomMultiMatcher_exposer.def( "__deepcopy__", &__copy__);        AtomMultiMatcher_exposer.def( "clone", &__copy__);        AtomMultiMatcher_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomMultiMatcher >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AtomMultiMatcher_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomMultiMatcher >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AtomMultiMatcher_exposer.def( "__str__", &__str__< ::SireMol::AtomMultiMatcher > );        AtomMultiMatcher_exposer.def( "__repr__", &__str__< ::SireMol::AtomMultiMatcher > );    }}

//.........这里部分代码省略.........            Nodes_exposer.def(                 "nBusy"                , nBusy_function_value );                }        { //::SireCluster::Nodes::nFree                    typedef int ( ::SireCluster::Nodes::*nFree_function_type )(  ) ;            nFree_function_type nFree_function_value( &::SireCluster::Nodes::nFree );                        Nodes_exposer.def(                 "nFree"                , nFree_function_value );                }        { //::SireCluster::Nodes::nNodes                    typedef int ( ::SireCluster::Nodes::*nNodes_function_type )(  ) ;            nNodes_function_type nNodes_function_value( &::SireCluster::Nodes::nNodes );                        Nodes_exposer.def(                 "nNodes"                , nNodes_function_value );                }        Nodes_exposer.def( bp::self != bp::self );        { //::SireCluster::Nodes::operator=                    typedef ::SireCluster::Nodes & ( ::SireCluster::Nodes::*assign_function_type )( ::SireCluster::Nodes const & ) ;            assign_function_type assign_function_value( &::SireCluster::Nodes::operator= );                        Nodes_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        Nodes_exposer.def( bp::self == bp::self );        { //::SireCluster::Nodes::remove                    typedef void ( ::SireCluster::Nodes::*remove_function_type )( ::SireCluster::Node ) ;            remove_function_type remove_function_value( &::SireCluster::Nodes::remove );                        Nodes_exposer.def(                 "remove"                , remove_function_value                , ( bp::arg("node") ) );                }        { //::SireCluster::Nodes::removeAll                    typedef void ( ::SireCluster::Nodes::*removeAll_function_type )(  ) ;            removeAll_function_type removeAll_function_value( &::SireCluster::Nodes::removeAll );                        Nodes_exposer.def(                 "removeAll"                , removeAll_function_value );                }        { //::SireCluster::Nodes::toString                    typedef ::QString ( ::SireCluster::Nodes::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireCluster::Nodes::toString );                        Nodes_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireCluster::Nodes::waitUntilAllFree                    typedef void ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )(  ) ;            waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );                        Nodes_exposer.def(                 "waitUntilAllFree"                , waitUntilAllFree_function_value );                }        { //::SireCluster::Nodes::waitUntilAllFree                    typedef bool ( ::SireCluster::Nodes::*waitUntilAllFree_function_type )( int ) ;            waitUntilAllFree_function_type waitUntilAllFree_function_value( &::SireCluster::Nodes::waitUntilAllFree );                        Nodes_exposer.def(                 "waitUntilAllFree"                , waitUntilAllFree_function_value                , ( bp::arg("timeout") ) );                }        Nodes_exposer.def( "__copy__", &__copy__);        Nodes_exposer.def( "__deepcopy__", &__copy__);        Nodes_exposer.def( "clone", &__copy__);        Nodes_exposer.def( "__str__", &__str__< ::SireCluster::Nodes > );        Nodes_exposer.def( "__repr__", &__str__< ::SireCluster::Nodes > );        Nodes_exposer.def( "__len__", &__len_count< ::SireCluster::Nodes > );    }}

//.........这里部分代码省略.........                }        { //::SireVol::GridInfo::pointToGridCorners                    typedef int ( ::SireVol::GridInfo::*pointToGridCorners_function_type )( ::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::SireMaths::MultiFloat const &,::QVector< SireMaths::MultiInt > &,::QVector< SireMaths::MultiFloat > & ) const;            pointToGridCorners_function_type pointToGridCorners_function_value( &::SireVol::GridInfo::pointToGridCorners );                        GridInfo_exposer.def(                 "pointToGridCorners"                , pointToGridCorners_function_value                , ( bp::arg("x"), bp::arg("y"), bp::arg("z"), bp::arg("indicies"), bp::arg("weights") ) );                }        { //::SireVol::GridInfo::pointToGridIndex                    typedef ::SireVol::GridIndex ( ::SireVol::GridInfo::*pointToGridIndex_function_type )( ::SireMaths::Vector const & ) const;            pointToGridIndex_function_type pointToGridIndex_function_value( &::SireVol::GridInfo::pointToGridIndex );                        GridInfo_exposer.def(                 "pointToGridIndex"                , pointToGridIndex_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::GridInfo::redimension                    typedef ::QVector< float > ( ::SireVol::GridInfo::*redimension_function_type )( ::QVector< float > const &,::SireVol::GridInfo const & ) const;            redimension_function_type redimension_function_value( &::SireVol::GridInfo::redimension );                        GridInfo_exposer.def(                 "redimension"                , redimension_function_value                , ( bp::arg("values"), bp::arg("new_grid") ) );                }        { //::SireVol::GridInfo::size                    typedef int ( ::SireVol::GridInfo::*size_function_type )(  ) const;            size_function_type size_function_value( &::SireVol::GridInfo::size );                        GridInfo_exposer.def(                 "size"                , size_function_value );                }        { //::SireVol::GridInfo::spacing                    typedef ::SireUnits::Dimension::Length ( ::SireVol::GridInfo::*spacing_function_type )(  ) const;            spacing_function_type spacing_function_value( &::SireVol::GridInfo::spacing );                        GridInfo_exposer.def(                 "spacing"                , spacing_function_value );                }        { //::SireVol::GridInfo::toString                    typedef ::QString ( ::SireVol::GridInfo::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireVol::GridInfo::toString );                        GridInfo_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireVol::GridInfo::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireVol::GridInfo::typeName );                        GridInfo_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireVol::GridInfo::what                    typedef char const * ( ::SireVol::GridInfo::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireVol::GridInfo::what );                        GridInfo_exposer.def(                 "what"                , what_function_value );                }        GridInfo_exposer.staticmethod( "typeName" );        GridInfo_exposer.def( "__copy__", &__copy__);        GridInfo_exposer.def( "__deepcopy__", &__copy__);        GridInfo_exposer.def( "clone", &__copy__);        GridInfo_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::GridInfo >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        GridInfo_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::GridInfo >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        GridInfo_exposer.def( "__str__", &__str__< ::SireVol::GridInfo > );        GridInfo_exposer.def( "__repr__", &__str__< ::SireVol::GridInfo > );        GridInfo_exposer.def( "__len__", &__len_size< ::SireVol::GridInfo > );        GridInfo_exposer.def( "__getitem__", &::SireVol::GridInfo::getitem );    }}

//.........这里部分代码省略.........        }        PackedArray2D_int_Array_exposer.def( bp::self != bp::self );        { //::SireBase::detail::PackedArray2D_Array< int >::operator=                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef ::SireBase::detail::PackedArray2D_Array< int > & ( ::SireBase::detail::PackedArray2D_Array< int >::*assign_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;            assign_function_type assign_function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator= );                        PackedArray2D_int_Array_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        PackedArray2D_int_Array_exposer.def( bp::self == bp::self );        { //::SireBase::detail::PackedArray2D_Array< int >::operator[]                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef int const & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) const;            __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );                        PackedArray2D_int_Array_exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireBase::detail::PackedArray2D_Array< int >::operator[]                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef int & ( ::SireBase::detail::PackedArray2D_Array< int >::*__getitem___function_type )( ::quint32 ) ;            __getitem___function_type __getitem___function_value( &::SireBase::detail::PackedArray2D_Array< int >::operator[] );                        PackedArray2D_int_Array_exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_non_const_reference >() );                }        { //::SireBase::detail::PackedArray2D_Array< int >::size                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef int ( ::SireBase::detail::PackedArray2D_Array< int >::*size_function_type )(  ) const;            size_function_type size_function_value( &::SireBase::detail::PackedArray2D_Array< int >::size );                        PackedArray2D_int_Array_exposer.def(                 "size"                , size_function_value );                }        { //::SireBase::detail::PackedArray2D_Array< int >::toQVector                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef ::QVector< int > ( ::SireBase::detail::PackedArray2D_Array< int >::*toQVector_function_type )(  ) const;            toQVector_function_type toQVector_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toQVector );                        PackedArray2D_int_Array_exposer.def(                 "toQVector"                , toQVector_function_value );                }        { //::SireBase::detail::PackedArray2D_Array< int >::toString                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef ::QString ( ::SireBase::detail::PackedArray2D_Array< int >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireBase::detail::PackedArray2D_Array< int >::toString );                        PackedArray2D_int_Array_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireBase::detail::PackedArray2D_Array< int >::update                    typedef SireBase::detail::PackedArray2D_Array< int > exported_class_t;            typedef void ( ::SireBase::detail::PackedArray2D_Array< int >::*update_function_type )( ::SireBase::detail::PackedArray2D_Array< int > const & ) ;            update_function_type update_function_value( &::SireBase::detail::PackedArray2D_Array< int >::update );                        PackedArray2D_int_Array_exposer.def(                 "update"                , update_function_value                , ( bp::arg("other") ) );                }        PackedArray2D_int_Array_exposer.def( "__copy__", &__copy__);        PackedArray2D_int_Array_exposer.def( "__deepcopy__", &__copy__);        PackedArray2D_int_Array_exposer.def( "clone", &__copy__);        PackedArray2D_int_Array_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PackedArray2D_int_Array_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::detail::PackedArray2D_Array<int> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        PackedArray2D_int_Array_exposer.def( "__str__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );        PackedArray2D_int_Array_exposer.def( "__repr__", &__str__< ::SireBase::detail::PackedArray2D_Array<int> > );        PackedArray2D_int_Array_exposer.def( "__len__", &__len_size< ::SireBase::detail::PackedArray2D_Array<int> > );    }}

void register_SupraSubMove_class(){    { //::SireMove::SupraSubMove        typedef bp::class_< SireMove::SupraSubMove, bp::bases< SireBase::Property >, boost::noncopyable > SupraSubMove_exposer_t;        SupraSubMove_exposer_t SupraSubMove_exposer = SupraSubMove_exposer_t( "SupraSubMove", bp::no_init );        bp::scope SupraSubMove_scope( SupraSubMove_exposer );        { //::SireMove::SupraSubMove::clearStatistics                    typedef void ( ::SireMove::SupraSubMove::*clearStatistics_function_type )(  ) ;            clearStatistics_function_type clearStatistics_function_value( &::SireMove::SupraSubMove::clearStatistics );                        SupraSubMove_exposer.def(                 "clearStatistics"                , clearStatistics_function_value );                }        { //::SireMove::SupraSubMove::move                    typedef void ( ::SireMove::SupraSubMove::*move_function_type )( ::SireMove::SupraSubSystem &,int,int,bool ) ;            move_function_type move_function_value( &::SireMove::SupraSubMove::move );                        SupraSubMove_exposer.def(                 "move"                , move_function_value                , ( bp::arg("system"), bp::arg("n_supra_moves"), bp::arg("n_supra_moves_per_block"), bp::arg("record_stats")=(bool)(true) ) );                }        { //::SireMove::SupraSubMove::null                    typedef ::SireMove::NullSupraSubMove const & ( *null_function_type )(  );            null_function_type null_function_value( &::SireMove::SupraSubMove::null );                        SupraSubMove_exposer.def(                 "null"                , null_function_value                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMove::SupraSubMove::toString                    typedef ::QString ( ::SireMove::SupraSubMove::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMove::SupraSubMove::toString );                        SupraSubMove_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMove::SupraSubMove::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMove::SupraSubMove::typeName );                        SupraSubMove_exposer.def(                 "typeName"                , typeName_function_value );                }        SupraSubMove_exposer.staticmethod( "null" );        SupraSubMove_exposer.staticmethod( "typeName" );        SupraSubMove_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::SupraSubMove >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SupraSubMove_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::SupraSubMove >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        SupraSubMove_exposer.def( "__str__", &__str__< ::SireMove::SupraSubMove > );        SupraSubMove_exposer.def( "__repr__", &__str__< ::SireMove::SupraSubMove > );    }}

//.........这里部分代码省略.........                , hasYError_function_value                , "Return whether or not there is any error in the y value" );                }        { //::SireAnalysis::DataPoint::hasYErrorRange                    typedef bool ( ::SireAnalysis::DataPoint::*hasYErrorRange_function_type)(  ) const;            hasYErrorRange_function_type hasYErrorRange_function_value( &::SireAnalysis::DataPoint::hasYErrorRange );                        DataPoint_exposer.def(                 "hasYErrorRange"                , hasYErrorRange_function_value                , "Return whether or not there is an error range on the x value" );                }        DataPoint_exposer.def( bp::self != bp::self );        { //::SireAnalysis::DataPoint::operator=                    typedef ::SireAnalysis::DataPoint & ( ::SireAnalysis::DataPoint::*assign_function_type)( ::SireAnalysis::DataPoint const & ) ;            assign_function_type assign_function_value( &::SireAnalysis::DataPoint::operator= );                        DataPoint_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        DataPoint_exposer.def( bp::self == bp::self );        { //::SireAnalysis::DataPoint::toString                    typedef ::QString ( ::SireAnalysis::DataPoint::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireAnalysis::DataPoint::toString );                        DataPoint_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireAnalysis::DataPoint::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireAnalysis::DataPoint::typeName );                        DataPoint_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireAnalysis::DataPoint::what                    typedef char const * ( ::SireAnalysis::DataPoint::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireAnalysis::DataPoint::what );                        DataPoint_exposer.def(                 "what"                , what_function_value                , "" );                }        { //::SireAnalysis::DataPoint::x                    typedef double ( ::SireAnalysis::DataPoint::*x_function_type)(  ) const;

//.........这里部分代码省略.........                }        { //::SireMM::CLJAtom::isDummy                    typedef bool ( ::SireMM::CLJAtom::*isDummy_function_type )(  ) const;            isDummy_function_type isDummy_function_value( &::SireMM::CLJAtom::isDummy );                        CLJAtom_exposer.def(                 "isDummy"                , isDummy_function_value );                }        { //::SireMM::CLJAtom::isNull                    typedef bool ( ::SireMM::CLJAtom::*isNull_function_type )(  ) const;            isNull_function_type isNull_function_value( &::SireMM::CLJAtom::isNull );                        CLJAtom_exposer.def(                 "isNull"                , isNull_function_value );                }        { //::SireMM::CLJAtom::ljParameter                    typedef ::SireMM::LJParameter ( ::SireMM::CLJAtom::*ljParameter_function_type )(  ) const;            ljParameter_function_type ljParameter_function_value( &::SireMM::CLJAtom::ljParameter );                        CLJAtom_exposer.def(                 "ljParameter"                , ljParameter_function_value );                }        { //::SireMM::CLJAtom::negate                    typedef ::SireMM::CLJAtom ( ::SireMM::CLJAtom::*negate_function_type )(  ) const;            negate_function_type negate_function_value( &::SireMM::CLJAtom::negate );                        CLJAtom_exposer.def(                 "negate"                , negate_function_value );                }        CLJAtom_exposer.def( bp::self != bp::self );        { //::SireMM::CLJAtom::operator=                    typedef ::SireMM::CLJAtom & ( ::SireMM::CLJAtom::*assign_function_type )( ::SireMM::CLJAtom const & ) ;            assign_function_type assign_function_value( &::SireMM::CLJAtom::operator= );                        CLJAtom_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        CLJAtom_exposer.def( bp::self == bp::self );        { //::SireMM::CLJAtom::toString                    typedef ::QString ( ::SireMM::CLJAtom::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMM::CLJAtom::toString );                        CLJAtom_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMM::CLJAtom::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::CLJAtom::typeName );                        CLJAtom_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireMM::CLJAtom::what                    typedef char const * ( ::SireMM::CLJAtom::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireMM::CLJAtom::what );                        CLJAtom_exposer.def(                 "what"                , what_function_value );                }        CLJAtom_exposer.staticmethod( "buildFrom" );        CLJAtom_exposer.staticmethod( "typeName" );        CLJAtom_exposer.def( "__copy__", &__copy__);        CLJAtom_exposer.def( "__deepcopy__", &__copy__);        CLJAtom_exposer.def( "clone", &__copy__);        CLJAtom_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::CLJAtom >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        CLJAtom_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::CLJAtom >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        CLJAtom_exposer.def( "__str__", &__str__< ::SireMM::CLJAtom > );        CLJAtom_exposer.def( "__repr__", &__str__< ::SireMM::CLJAtom > );    }}

//.........这里部分代码省略.........                    typedef ::SireMol::MolResNum & ( ::SireMol::MolResNum::*assign_function_type )( ::SireMol::MolResNum const & ) ;            assign_function_type assign_function_value( &::SireMol::MolResNum::operator= );                        MolResNum_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        MolResNum_exposer.def( bp::self == bp::other< SireID::ID >() );        MolResNum_exposer.def( bp::self == bp::self );        { //::SireMol::MolResNum::resNum                    typedef ::SireMol::ResNum const & ( ::SireMol::MolResNum::*resNum_function_type )(  ) const;            resNum_function_type resNum_function_value( &::SireMol::MolResNum::resNum );                        MolResNum_exposer.def(                 "resNum"                , resNum_function_value                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::SireMol::MolResNum::selectAllFrom                    typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::Molecules const &,::SireBase::PropertyMap const & ) const;            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );                        MolResNum_exposer.def(                 "selectAllFrom"                , selectAllFrom_function_value                , ( bp::arg("molecules"), bp::arg("map")=SireBase::PropertyMap() ) );                }        { //::SireMol::MolResNum::selectAllFrom                    typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );                        MolResNum_exposer.def(                 "selectAllFrom"                , selectAllFrom_function_value                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ) );                }        { //::SireMol::MolResNum::selectAllFrom                    typedef ::QHash< SireMol::MolNum, SireMol::Selector< SireMol::Residue > > ( ::SireMol::MolResNum::*selectAllFrom_function_type )( ::SireMol::MolGroupsBase const &,::SireBase::PropertyMap const & ) const;            selectAllFrom_function_type selectAllFrom_function_value( &::SireMol::MolResNum::selectAllFrom );                        MolResNum_exposer.def(                 "selectAllFrom"                , selectAllFrom_function_value                , ( bp::arg("molgroups"), bp::arg("map")=SireBase::PropertyMap() ) );                }        { //::SireMol::MolResNum::toString                    typedef ::QString ( ::SireMol::MolResNum::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMol::MolResNum::toString );                        MolResNum_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMol::MolResNum::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMol::MolResNum::typeName );                        MolResNum_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireMol::MolResNum::what                    typedef char const * ( ::SireMol::MolResNum::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireMol::MolResNum::what );                        MolResNum_exposer.def(                 "what"                , what_function_value );                }        MolResNum_exposer.staticmethod( "typeName" );        MolResNum_exposer.def( "__copy__", &__copy__);        MolResNum_exposer.def( "__deepcopy__", &__copy__);        MolResNum_exposer.def( "clone", &__copy__);        MolResNum_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolResNum >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        MolResNum_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolResNum >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        MolResNum_exposer.def( "__str__", &__str__< ::SireMol::MolResNum > );        MolResNum_exposer.def( "__repr__", &__str__< ::SireMol::MolResNum > );    }}

//.........这里部分代码省略.........            typedef ::SireCAS::Symbol const & ( *r12_function_type )(  );            r12_function_type r12_function_value( &::SireSystem::AngleComponent::r12 );                        AngleComponent_exposer.def(                 "r12"                , r12_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the 1-2 distance" );                }        { //::SireSystem::AngleComponent::theta                    typedef ::SireCAS::Symbol const & ( *theta_function_type )(  );            theta_function_type theta_function_value( &::SireSystem::AngleComponent::theta );                        AngleComponent_exposer.def(                 "theta"                , theta_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the central angle between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta012                    typedef ::SireCAS::Symbol const & ( *theta012_function_type )(  );            theta012_function_type theta012_function_value( &::SireSystem::AngleComponent::theta012 );                        AngleComponent_exposer.def(                 "theta012"                , theta012_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 012 between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta021                    typedef ::SireCAS::Symbol const & ( *theta021_function_type )(  );            theta021_function_type theta021_function_value( &::SireSystem::AngleComponent::theta021 );                        AngleComponent_exposer.def(                 "theta021"                , theta021_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 021 between/nthe three points" );                }        { //::SireSystem::AngleComponent::theta102                    typedef ::SireCAS::Symbol const & ( *theta102_function_type )(  );            theta102_function_type theta102_function_value( &::SireSystem::AngleComponent::theta102 );                        AngleComponent_exposer.def(                 "theta102"                , theta102_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the symbol that represents the angle 102 between/nthe three points" );                }        { //::SireSystem::AngleComponent::toString                    typedef ::QString ( ::SireSystem::AngleComponent::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireSystem::AngleComponent::toString );                        AngleComponent_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireSystem::AngleComponent::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireSystem::AngleComponent::typeName );                        AngleComponent_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        AngleComponent_exposer.staticmethod( "r01" );        AngleComponent_exposer.staticmethod( "r02" );        AngleComponent_exposer.staticmethod( "r12" );        AngleComponent_exposer.staticmethod( "theta" );        AngleComponent_exposer.staticmethod( "theta012" );        AngleComponent_exposer.staticmethod( "theta021" );        AngleComponent_exposer.staticmethod( "theta102" );        AngleComponent_exposer.staticmethod( "typeName" );        AngleComponent_exposer.def( "__copy__", &__copy__);        AngleComponent_exposer.def( "__deepcopy__", &__copy__);        AngleComponent_exposer.def( "clone", &__copy__);        AngleComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::AngleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AngleComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::AngleComponent >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        AngleComponent_exposer.def( "__str__", &__str__< ::SireSystem::AngleComponent > );        AngleComponent_exposer.def( "__repr__", &__str__< ::SireSystem::AngleComponent > );    }}

void register_IDAssigner_class(){    { //::SireSystem::IDAssigner        typedef bp::class_< SireSystem::IDAssigner, bp::bases< SireBase::Property > > IDAssigner_exposer_t;        IDAssigner_exposer_t IDAssigner_exposer = IDAssigner_exposer_t( "IDAssigner", "This class uses the machinery of the identity point to/npick out molecules that are associated with identity points./nThis is useful if you want to monitor a property or energy,/nbut dont actually want to change the coordinates of atoms/n/nAuthor: Christopher Woods/n", bp::init< >("Constructor") );        bp::scope IDAssigner_scope( IDAssigner_exposer );        IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );        IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from/nmolgroup that match the points in points -/nthis creates a list of n molecules, where the ith molecule/nis matched to the ith point") );        IDAssigner_exposer.def( bp::init< SireFF::PointRef const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("point"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Constructor") );        IDAssigner_exposer.def( bp::init< QVector< SireBase::PropPtr< SireFF::Point > > const &, SireMol::MoleculeGroup const &, SireVol::Space const &, bp::optional< SireBase::PropertyMap const & > >(( bp::arg("points"), bp::arg("molgroup"), bp::arg("space"), bp::arg("map")=SireBase::PropertyMap() ), "Construct to find the identity of the molecules from/nmolgroup that match the points in points -/nthis creates a list of n molecules, where the ith molecule/nis matched to the ith point") );        IDAssigner_exposer.def( bp::init< SireSystem::IDAssigner const & >(( bp::arg("other") ), "Copy constructor") );        { //::SireSystem::IDAssigner::identifiedMolecules                    typedef ::QVector< SireMol::PartialMolecule > ( ::SireSystem::IDAssigner::*identifiedMolecules_function_type)(  ) const;            identifiedMolecules_function_type identifiedMolecules_function_value( &::SireSystem::IDAssigner::identifiedMolecules );                        IDAssigner_exposer.def(                 "identifiedMolecules"                , identifiedMolecules_function_value                , "Returns the list of identified molecules from the system,/nwhich are returned in the same order as the list of identity points/n" );                }        { //::SireSystem::IDAssigner::moleculeGroup                    typedef ::SireMol::MoleculeGroup const & ( ::SireSystem::IDAssigner::*moleculeGroup_function_type)(  ) const;            moleculeGroup_function_type moleculeGroup_function_value( &::SireSystem::IDAssigner::moleculeGroup );                        IDAssigner_exposer.def(                 "moleculeGroup"                , moleculeGroup_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the molecule group operated on by this constraint" );                }        { //::SireSystem::IDAssigner::nPoints                    typedef int ( ::SireSystem::IDAssigner::*nPoints_function_type)(  ) const;            nPoints_function_type nPoints_function_value( &::SireSystem::IDAssigner::nPoints );                        IDAssigner_exposer.def(                 "nPoints"                , nPoints_function_value                , "Return the number of identity points (and thus the number of/nidentified molecules)" );                }        IDAssigner_exposer.def( bp::self != bp::self );        { //::SireSystem::IDAssigner::operator=                    typedef ::SireSystem::IDAssigner & ( ::SireSystem::IDAssigner::*assign_function_type)( ::SireSystem::IDAssigner const & ) ;            assign_function_type assign_function_value( &::SireSystem::IDAssigner::operator= );                        IDAssigner_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        IDAssigner_exposer.def( bp::self == bp::self );        { //::SireSystem::IDAssigner::points                    typedef ::QVector< SireBase::PropPtr< SireFF::Point > > ( ::SireSystem::IDAssigner::*points_function_type)(  ) const;            points_function_type points_function_value( &::SireSystem::IDAssigner::points );                        IDAssigner_exposer.def(                 "points"                , points_function_value                , "Return the points used to identify the molecules" );                }        { //::SireSystem::IDAssigner::propertyMap                    typedef ::SireBase::PropertyMap const & ( ::SireSystem::IDAssigner::*propertyMap_function_type)(  ) const;            propertyMap_function_type propertyMap_function_value( &::SireSystem::IDAssigner::propertyMap );                        IDAssigner_exposer.def(                 "propertyMap"                , propertyMap_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "Return the property map used to find the properties required/nby this constraint" );                }        { //::SireSystem::IDAssigner::space                    typedef ::SireVol::Space const & ( ::SireSystem::IDAssigner::*space_function_type)(  ) const;            space_function_type space_function_value( &::SireSystem::IDAssigner::space );                        IDAssigner_exposer.def(                 "space"                , space_function_value                , bp::return_value_policy<bp::clone_const_reference>()                , "Return the space used to calculate distances between the molecules/nand the identity points" );                }        { //::SireSystem::IDAssigner::toString                    typedef ::QString ( ::SireSystem::IDAssigner::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireSystem::IDAssigner::toString );            //.........这里部分代码省略.........

//.........这里部分代码省略.........        QDate_exposer.def( bp::self != bp::self );        QDate_exposer.def( bp::self < bp::self );        QDate_exposer.def( bp::self <= bp::self );        QDate_exposer.def( bp::self == bp::self );        QDate_exposer.def( bp::self > bp::self );        QDate_exposer.def( bp::self >= bp::self );        { //::QDate::setDate                    typedef bool ( ::QDate::*setDate_function_type )( int,int,int ) ;            setDate_function_type setDate_function_value( &::QDate::setDate );                        QDate_exposer.def(                 "setDate"                , setDate_function_value                , ( bp::arg("year"), bp::arg("month"), bp::arg("date") ) );                }        { //::QDate::shortDayName                    typedef ::QString ( *shortDayName_function_type )( int, QDate::MonthNameType );            shortDayName_function_type shortDayName_function_value( &::QDate::shortDayName );                        QDate_exposer.def(                 "shortDayName"                , shortDayName_function_value                , ( bp::arg("weekday") ) );                }        { //::QDate::shortMonthName                    typedef ::QString ( *shortMonthName_function_type )( int, QDate::MonthNameType );            shortMonthName_function_type shortMonthName_function_value( &::QDate::shortMonthName );                        QDate_exposer.def(                 "shortMonthName"                , shortMonthName_function_value                , ( bp::arg("month") ) );                }        { //::QDate::toJulianDay                    typedef qint64 ( ::QDate::*toJulianDay_function_type )(  ) const;            toJulianDay_function_type toJulianDay_function_value( &::QDate::toJulianDay );                        QDate_exposer.def(                 "toJulianDay"                , toJulianDay_function_value );                }        { //::QDate::toString                    typedef ::QString ( ::QDate::*toString_function_type )( ::QString const & ) const;            toString_function_type toString_function_value( &::QDate::toString );                        QDate_exposer.def(                 "toString"                , toString_function_value                , ( bp::arg("format") ) );                }        { //::QDate::weekNumber                    typedef int ( ::QDate::*weekNumber_function_type )( int * ) const;            weekNumber_function_type weekNumber_function_value( &::QDate::weekNumber );                        QDate_exposer.def(                 "weekNumber"                , weekNumber_function_value                , ( bp::arg("yearNum")=bp::object() ) );                }        { //::QDate::year                    typedef int ( ::QDate::*year_function_type )(  ) const;            year_function_type year_function_value( &::QDate::year );                        QDate_exposer.def(                 "year"                , year_function_value );                }        QDate_exposer.staticmethod( "currentDate" );        QDate_exposer.staticmethod( "fromJulianDay" );        QDate_exposer.staticmethod( "fromString" );        QDate_exposer.staticmethod( "isLeapYear" );        QDate_exposer.staticmethod( "isValid" );        QDate_exposer.staticmethod( "longDayName" );        QDate_exposer.staticmethod( "longMonthName" );        QDate_exposer.staticmethod( "shortDayName" );        QDate_exposer.staticmethod( "shortMonthName" );        QDate_exposer.def( "__copy__", &__copy__);        QDate_exposer.def( "__deepcopy__", &__copy__);        QDate_exposer.def( "clone", &__copy__);        QDate_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::QDate >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        QDate_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::QDate >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );    }}

void register_Velocity3D_class(){    { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >        typedef bp::class_< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > > Velocity3D_exposer_t;        Velocity3D_exposer_t Velocity3D_exposer = Velocity3D_exposer_t( "Velocity3D", bp::init< >() );        bp::scope Velocity3D_scope( Velocity3D_exposer );        Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("val") )) );        Velocity3D_exposer.def( bp::init< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const &, SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & >(( bp::arg("x"), bp::arg("y"), bp::arg("z") )) );        Velocity3D_exposer.def( bp::init< SireMaths::Vector const & >(( bp::arg("v") )) );        Velocity3D_exposer.def( bp::init< SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & >(( bp::arg("other") )) );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*at_function_type )( int ) const;            at_function_type at_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::at );                        Velocity3D_exposer.def(                 "at"                , at_function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef int ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*count_function_type )(  ) const;            count_function_type count_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::count );                        Velocity3D_exposer.def(                 "count"                , count_function_value );                }        Velocity3D_exposer.def( bp::self != bp::self );        Velocity3D_exposer.def( bp::self * bp::other< double >() );        Velocity3D_exposer.def( bp::self + bp::self );        Velocity3D_exposer.def( -bp::self );        Velocity3D_exposer.def( bp::self - bp::self );        Velocity3D_exposer.def( bp::self / bp::other< double >() );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator=                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*assign_function_type )( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > const & ) ;            assign_function_type assign_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator= );                        Velocity3D_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        Velocity3D_exposer.def( bp::self == bp::self );        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[]                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*__getitem___function_type )( int ) const;            __getitem___function_type __getitem___function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::operator[] );                        Velocity3D_exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef void ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*set_function_type )( int,::SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > const & ) ;            set_function_type set_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::set );                        Velocity3D_exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("value") ) );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef ::QString ( ::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::toString );                        Velocity3D_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName                    typedef SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > > exported_class_t;            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMaths::Vector3D< SireUnits::Dimension::PhysUnit< 0, 1, -1, 0, 0, 0, 0 > >::typeName );                        Velocity3D_exposer.def(                 "typeName"                , typeName_function_value );        //.........这里部分代码省略.........

//.........这里部分代码省略.........            typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point3_function_type )(  ) const;            point3_function_type point3_function_value( &::SireSystem::TripleDistanceComponent::point3 );            TripleDistanceComponent_exposer.def(                "point3"                , point3_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::point4            typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point4_function_type )(  ) const;            point4_function_type point4_function_value( &::SireSystem::TripleDistanceComponent::point4 );            TripleDistanceComponent_exposer.def(                "point4"                , point4_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::point5            typedef ::SireFF::Point const & ( ::SireSystem::TripleDistanceComponent::*point5_function_type )(  ) const;            point5_function_type point5_function_value( &::SireSystem::TripleDistanceComponent::point5 );            TripleDistanceComponent_exposer.def(                "point5"                , point5_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::r01            typedef ::SireCAS::Symbol const & ( *r01_function_type )(  );            r01_function_type r01_function_value( &::SireSystem::TripleDistanceComponent::r01 );            TripleDistanceComponent_exposer.def(                "r01"                , r01_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::r23            typedef ::SireCAS::Symbol const & ( *r23_function_type )(  );            r23_function_type r23_function_value( &::SireSystem::TripleDistanceComponent::r23 );            TripleDistanceComponent_exposer.def(                "r23"                , r23_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::r45            typedef ::SireCAS::Symbol const & ( *r45_function_type )(  );            r45_function_type r45_function_value( &::SireSystem::TripleDistanceComponent::r45 );            TripleDistanceComponent_exposer.def(                "r45"                , r45_function_value                , bp::return_value_policy<bp::clone_const_reference>() );        }        {   //::SireSystem::TripleDistanceComponent::toString            typedef ::QString ( ::SireSystem::TripleDistanceComponent::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireSystem::TripleDistanceComponent::toString );            TripleDistanceComponent_exposer.def(                "toString"                , toString_function_value );        }        {   //::SireSystem::TripleDistanceComponent::typeName            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireSystem::TripleDistanceComponent::typeName );            TripleDistanceComponent_exposer.def(                "typeName"                , typeName_function_value );        }        TripleDistanceComponent_exposer.staticmethod( "r01" );        TripleDistanceComponent_exposer.staticmethod( "r23" );        TripleDistanceComponent_exposer.staticmethod( "r45" );        TripleDistanceComponent_exposer.staticmethod( "typeName" );        TripleDistanceComponent_exposer.def( "__copy__", &__copy__);        TripleDistanceComponent_exposer.def( "__deepcopy__", &__copy__);        TripleDistanceComponent_exposer.def( "clone", &__copy__);        TripleDistanceComponent_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireSystem::TripleDistanceComponent >,                                             bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        TripleDistanceComponent_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireSystem::TripleDistanceComponent >,                                             bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        TripleDistanceComponent_exposer.def( "__str__", &__str__< ::SireSystem::TripleDistanceComponent > );        TripleDistanceComponent_exposer.def( "__repr__", &__str__< ::SireSystem::TripleDistanceComponent > );    }}

void register_IDOrSet_SegID__class(){    { //::SireID::IDOrSet< SireMol::SegID >        typedef bp::class_< SireID::IDOrSet< SireMol::SegID >, bp::bases< SireMol::SegID, SireID::ID > > IDOrSet_SegID__exposer_t;        IDOrSet_SegID__exposer_t IDOrSet_SegID__exposer = IDOrSet_SegID__exposer_t( "IDOrSet_SegID_", bp::init< >() );        bp::scope IDOrSet_SegID__scope( IDOrSet_SegID__exposer );        IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const & >(( bp::arg("id") )) );        IDOrSet_SegID__exposer.def( bp::init< SireMol::SegID const &, SireMol::SegID const & >(( bp::arg("id0"), bp::arg("id1") )) );        IDOrSet_SegID__exposer.def( bp::init< QList< SireMol::SegIdentifier > const & >(( bp::arg("ids") )) );        IDOrSet_SegID__exposer.def( bp::init< SireID::IDOrSet< SireMol::SegID > const & >(( bp::arg("other") )) );        { //::SireID::IDOrSet< SireMol::SegID >::IDs                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::QSet< SireMol::SegIdentifier > const & ( ::SireID::IDOrSet< SireMol::SegID >::*IDs_function_type )(  ) const;            IDs_function_type IDs_function_value( &::SireID::IDOrSet< SireMol::SegID >::IDs );                        IDOrSet_SegID__exposer.def(                 "IDs"                , IDs_function_value                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireID::IDOrSet< SireMol::SegID >::hash                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::uint ( ::SireID::IDOrSet< SireMol::SegID >::*hash_function_type )(  ) const;            hash_function_type hash_function_value( &::SireID::IDOrSet< SireMol::SegID >::hash );                        IDOrSet_SegID__exposer.def(                 "hash"                , hash_function_value );                }        { //::SireID::IDOrSet< SireMol::SegID >::isNull                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef bool ( ::SireID::IDOrSet< SireMol::SegID >::*isNull_function_type )(  ) const;            isNull_function_type isNull_function_value( &::SireID::IDOrSet< SireMol::SegID >::isNull );                        IDOrSet_SegID__exposer.def(                 "isNull"                , isNull_function_value );                }        { //::SireID::IDOrSet< SireMol::SegID >::map                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::QList< SireMol::SegIdx > ( ::SireID::IDOrSet< SireMol::SegID >::*map_function_type )( ::SireMol::MolInfo const & ) const;            map_function_type map_function_value( &::SireID::IDOrSet< SireMol::SegID >::map );                        IDOrSet_SegID__exposer.def(                 "map"                , map_function_value                , ( bp::arg("obj") ) );                }        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );        IDOrSet_SegID__exposer.def( bp::self != bp::self );        IDOrSet_SegID__exposer.def( bp::self != bp::other< SireMol::SegID >() );        { //::SireID::IDOrSet< SireMol::SegID >::operator=                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireID::IDOrSet< SireMol::SegID > const & ) ;            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );                        IDOrSet_SegID__exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        { //::SireID::IDOrSet< SireMol::SegID >::operator=                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::SireID::IDOrSet< SireMol::SegID > & ( ::SireID::IDOrSet< SireMol::SegID >::*assign_function_type )( ::SireMol::SegID const & ) ;            assign_function_type assign_function_value( &::SireID::IDOrSet< SireMol::SegID >::operator= );                        IDOrSet_SegID__exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );        IDOrSet_SegID__exposer.def( bp::self == bp::self );        IDOrSet_SegID__exposer.def( bp::self == bp::other< SireMol::SegID >() );        { //::SireID::IDOrSet< SireMol::SegID >::toString                    typedef SireID::IDOrSet< SireMol::SegID > exported_class_t;            typedef ::QString ( ::SireID::IDOrSet< SireMol::SegID >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireID::IDOrSet< SireMol::SegID >::toString );                        IDOrSet_SegID__exposer.def(                 "toString"                , toString_function_value );                }        { //::SireID::IDOrSet< SireMol::SegID >::typeName//.........这里部分代码省略.........

//.........这里部分代码省略.........                , bp::return_self< >() );                }        Segment_exposer.def( bp::self == bp::self );        { //::SireMol::Segment::propertyKeys                    typedef ::QStringList ( ::SireMol::Segment::*propertyKeys_function_type )(  ) const;            propertyKeys_function_type propertyKeys_function_value( &::SireMol::Segment::propertyKeys );                        Segment_exposer.def(                 "propertyKeys"                , propertyKeys_function_value );                }        { //::SireMol::Segment::selectedAll                    typedef bool ( ::SireMol::Segment::*selectedAll_function_type )(  ) const;            selectedAll_function_type selectedAll_function_value( &::SireMol::Segment::selectedAll );                        Segment_exposer.def(                 "selectedAll"                , selectedAll_function_value );                }        { //::SireMol::Segment::selection                    typedef ::SireMol::AtomSelection ( ::SireMol::Segment::*selection_function_type )(  ) const;            selection_function_type selection_function_value( &::SireMol::Segment::selection );                        Segment_exposer.def(                 "selection"                , selection_function_value );                }        { //::SireMol::Segment::selector                    typedef ::SireMol::Selector< SireMol::Segment > ( ::SireMol::Segment::*selector_function_type )(  ) const;            selector_function_type selector_function_value( &::SireMol::Segment::selector );                        Segment_exposer.def(                 "selector"                , selector_function_value );                }        { //::SireMol::Segment::toString                    typedef ::QString ( ::SireMol::Segment::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMol::Segment::toString );                        Segment_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMol::Segment::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMol::Segment::typeName );                        Segment_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireMol::Segment::update                    typedef void ( ::SireMol::Segment::*update_function_type )( ::SireMol::MoleculeData const & ) ;            update_function_type update_function_value( &::SireMol::Segment::update );                        Segment_exposer.def(                 "update"                , update_function_value                , ( bp::arg("moldata") ) );                }        Segment_exposer.staticmethod( "typeName" );        Segment_exposer.def( "_get_property_SireMol_SegStringProperty", &SireMol::Segment::property< QString >, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", get_Metadata_SireMol_SegStringProperty_function1, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegStringProperty", &get_Metadata_SireMol_SegStringProperty_function2, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_property_SireMol_SegIntProperty", &SireMol::Segment::property< qint64 >, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", get_Metadata_SireMol_SegIntProperty_function1, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegIntProperty", &get_Metadata_SireMol_SegIntProperty_function2, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_property_SireMol_SegFloatProperty", &SireMol::Segment::property< double >, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", get_Metadata_SireMol_SegFloatProperty_function1, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegFloatProperty", &get_Metadata_SireMol_SegFloatProperty_function2, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_property_SireMol_SegVariantProperty", &SireMol::Segment::property< QVariant >, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", get_Metadata_SireMol_SegVariantProperty_function1, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "_get_metadata_SireMol_SegVariantProperty", &get_Metadata_SireMol_SegVariantProperty_function2, bp::return_value_policy<bp::copy_const_reference>());        Segment_exposer.def( "__copy__", &__copy__);        Segment_exposer.def( "__deepcopy__", &__copy__);        Segment_exposer.def( "clone", &__copy__);        Segment_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::Segment >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Segment_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::Segment >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Segment_exposer.def( "__str__", &__str__< ::SireMol::Segment > );        Segment_exposer.def( "__repr__", &__str__< ::SireMol::Segment > );    }}

void register_MolWithResID_class(){    { //::SireMol::MolWithResID        typedef bp::class_< SireMol::MolWithResID, bp::bases< SireMol::MolID, SireID::ID > > MolWithResID_exposer_t;        MolWithResID_exposer_t MolWithResID_exposer = MolWithResID_exposer_t( "MolWithResID", bp::init< >() );        bp::scope MolWithResID_scope( MolWithResID_exposer );        MolWithResID_exposer.def( bp::init< QString const & >(( bp::arg("resname") )) );        MolWithResID_exposer.def( bp::init< int >(( bp::arg("resnum") )) );        MolWithResID_exposer.def( bp::init< SireMol::ResID const & >(( bp::arg("resid") )) );        MolWithResID_exposer.def( bp::init< QString const &, SireID::CaseSensitivity >(( bp::arg("resname"), bp::arg("case_sensitivity") )) );        MolWithResID_exposer.def( bp::init< SireMol::MolWithResID const & >(( bp::arg("other") )) );        { //::SireMol::MolWithResID::hash                    typedef ::uint ( ::SireMol::MolWithResID::*hash_function_type )(  ) const;            hash_function_type hash_function_value( &::SireMol::MolWithResID::hash );                        MolWithResID_exposer.def(                 "hash"                , hash_function_value );                }        { //::SireMol::MolWithResID::isNull                    typedef bool ( ::SireMol::MolWithResID::*isNull_function_type )(  ) const;            isNull_function_type isNull_function_value( &::SireMol::MolWithResID::isNull );                        MolWithResID_exposer.def(                 "isNull"                , isNull_function_value );                }        { //::SireMol::MolWithResID::map                    typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::Molecules const & ) const;            map_function_type map_function_value( &::SireMol::MolWithResID::map );                        MolWithResID_exposer.def(                 "map"                , map_function_value                , ( bp::arg("molecules") ) );                }        { //::SireMol::MolWithResID::map                    typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MoleculeGroup const & ) const;            map_function_type map_function_value( &::SireMol::MolWithResID::map );                        MolWithResID_exposer.def(                 "map"                , map_function_value                , ( bp::arg("molgroup") ) );                }        { //::SireMol::MolWithResID::map                    typedef ::QList< SireMol::MolNum > ( ::SireMol::MolWithResID::*map_function_type )( ::SireMol::MolGroupsBase const & ) const;            map_function_type map_function_value( &::SireMol::MolWithResID::map );                        MolWithResID_exposer.def(                 "map"                , map_function_value                , ( bp::arg("molgroups") ) );                }        MolWithResID_exposer.def( bp::self != bp::self );        { //::SireMol::MolWithResID::operator=                    typedef ::SireMol::MolWithResID & ( ::SireMol::MolWithResID::*assign_function_type )( ::SireMol::MolWithResID const & ) ;            assign_function_type assign_function_value( &::SireMol::MolWithResID::operator= );                        MolWithResID_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        MolWithResID_exposer.def( bp::self == bp::other< SireID::ID >() );        MolWithResID_exposer.def( bp::self == bp::self );        { //::SireMol::MolWithResID::resID                    typedef ::SireMol::ResID const & ( ::SireMol::MolWithResID::*resID_function_type )(  ) const;            resID_function_type resID_function_value( &::SireMol::MolWithResID::resID );                        MolWithResID_exposer.def(                 "resID"                , resID_function_value                , bp::return_value_policy<bp::clone_const_reference>() );                }        { //::SireMol::MolWithResID::toString                    typedef ::QString ( ::SireMol::MolWithResID::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMol::MolWithResID::toString );                        MolWithResID_exposer.def(                 "toString"                , toString_function_value );                }//.........这里部分代码省略.........

//.........这里部分代码省略.........                , TIME_function_value );                }        { //::SireUnits::Dimension::GeneralUnit::invert                    typedef ::SireUnits::Dimension::GeneralUnit ( ::SireUnits::Dimension::GeneralUnit::*invert_function_type )(  ) const;            invert_function_type invert_function_value( &::SireUnits::Dimension::GeneralUnit::invert );                        GeneralUnit_exposer.def(                 "invert"                , invert_function_value );                }        GeneralUnit_exposer.def( bp::self != bp::self );        GeneralUnit_exposer.def( bp::self * bp::self );        GeneralUnit_exposer.def( bp::self * bp::other< double >() );        GeneralUnit_exposer.def( bp::self * bp::other< int >() );        GeneralUnit_exposer.def( bp::self *= bp::self );        GeneralUnit_exposer.def( bp::self + bp::self );        GeneralUnit_exposer.def( -bp::self );        GeneralUnit_exposer.def( bp::self - bp::self );        GeneralUnit_exposer.def( bp::self / bp::self );        GeneralUnit_exposer.def( bp::self / bp::other< double >() );        GeneralUnit_exposer.def( bp::self / bp::other< int >() );        GeneralUnit_exposer.def( bp::self /= bp::self );        { //::SireUnits::Dimension::GeneralUnit::operator=                    typedef ::SireUnits::Dimension::GeneralUnit & ( ::SireUnits::Dimension::GeneralUnit::*assign_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) ;            assign_function_type assign_function_value( &::SireUnits::Dimension::GeneralUnit::operator= );                        GeneralUnit_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        GeneralUnit_exposer.def( bp::self == bp::self );        { //::SireUnits::Dimension::GeneralUnit::to                    typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::TempBase const & ) const;            to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );                        GeneralUnit_exposer.def(                 "to"                , to_function_value                , ( bp::arg("other") ) );                }        { //::SireUnits::Dimension::GeneralUnit::to                    typedef double ( ::SireUnits::Dimension::GeneralUnit::*to_function_type )( ::SireUnits::Dimension::GeneralUnit const & ) const;            to_function_type to_function_value( &::SireUnits::Dimension::GeneralUnit::to );                        GeneralUnit_exposer.def(                 "to"                , to_function_value                , ( bp::arg("other") ) );                }        { //::SireUnits::Dimension::GeneralUnit::toString                    typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireUnits::Dimension::GeneralUnit::toString );                        GeneralUnit_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireUnits::Dimension::GeneralUnit::typeName                    typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*typeName_function_type )(  ) const;            typeName_function_type typeName_function_value( &::SireUnits::Dimension::GeneralUnit::typeName );                        GeneralUnit_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireUnits::Dimension::GeneralUnit::what                    typedef ::QString ( ::SireUnits::Dimension::GeneralUnit::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireUnits::Dimension::GeneralUnit::what );                        GeneralUnit_exposer.def(                 "what"                , what_function_value );                }        GeneralUnit_exposer.def( bp::other<double>() * bp::self );        GeneralUnit_exposer.def( bp::other<double>() / bp::self );        GeneralUnit_exposer.def( "__copy__", &__copy__);        GeneralUnit_exposer.def( "__deepcopy__", &__copy__);        GeneralUnit_exposer.def( "clone", &__copy__);        GeneralUnit_exposer.def( "__str__", &__str__< ::SireUnits::Dimension::GeneralUnit > );        GeneralUnit_exposer.def( "__repr__", &__str__< ::SireUnits::Dimension::GeneralUnit > );    }}

//.........这里部分代码省略.........            setCombiningRules_function_type setCombiningRules_function_value( &::SireMM::CLJ14Group::setCombiningRules );                        CLJ14Group_exposer.def(                 "setCombiningRules"                , setCombiningRules_function_value                , ( bp::arg("rules") ) );                }        { //::SireMM::CLJ14Group::setGeometricCombiningRules                    typedef void ( ::SireMM::CLJ14Group::*setGeometricCombiningRules_function_type )( bool ) ;            setGeometricCombiningRules_function_type setGeometricCombiningRules_function_value( &::SireMM::CLJ14Group::setGeometricCombiningRules );                        CLJ14Group_exposer.def(                 "setGeometricCombiningRules"                , setGeometricCombiningRules_function_value                , ( bp::arg("on") ) );                }        { //::SireMM::CLJ14Group::setStrict                    typedef bool ( ::SireMM::CLJ14Group::*setStrict_function_type )( bool ) ;            setStrict_function_type setStrict_function_value( &::SireMM::CLJ14Group::setStrict );                        CLJ14Group_exposer.def(                 "setStrict"                , setStrict_function_value                , ( bp::arg("isstrict") ) );                }        { //::SireMM::CLJ14Group::toString                    typedef ::QString ( ::SireMM::CLJ14Group::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireMM::CLJ14Group::toString );                        CLJ14Group_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireMM::CLJ14Group::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::CLJ14Group::typeName );                        CLJ14Group_exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireMM::CLJ14Group::update                    typedef void ( ::SireMM::CLJ14Group::*update_function_type )( ::SireMol::MoleculeView const & ) ;            update_function_type update_function_value( &::SireMM::CLJ14Group::update );                        CLJ14Group_exposer.def(                 "update"                , update_function_value                , ( bp::arg("new_molecule") ) );                }        { //::SireMM::CLJ14Group::updateSelection                    typedef void ( ::SireMM::CLJ14Group::*updateSelection_function_type )( ::SireMol::AtomSelection const & ) ;            updateSelection_function_type updateSelection_function_value( &::SireMM::CLJ14Group::updateSelection );            

//.........这里部分代码省略.........            name_function_type name_function_value( &::SireMove::Ensemble::name );                        Ensemble_exposer.def(                 "name"                , name_function_value                , "Return the name of this ensemble (if it has a name)" );                }        Ensemble_exposer.def( bp::self != bp::self );        { //::SireMove::Ensemble::operator=                    typedef ::SireMove::Ensemble & ( ::SireMove::Ensemble::*assign_function_type)( ::SireMove::Ensemble const & ) ;            assign_function_type assign_function_value( &::SireMove::Ensemble::operator= );                        Ensemble_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        Ensemble_exposer.def( bp::self == bp::self );        { //::SireMove::Ensemble::pressure                    typedef ::SireUnits::Dimension::Pressure ( ::SireMove::Ensemble::*pressure_function_type)(  ) const;            pressure_function_type pressure_function_value( &::SireMove::Ensemble::pressure );                        Ensemble_exposer.def(                 "pressure"                , pressure_function_value                , "Return the pressure of this ensemble/nThrow: SireError::incompatible_error/n" );                }        { //::SireMove::Ensemble::shortHand                    typedef ::QString ( ::SireMove::Ensemble::*shortHand_function_type)(  ) const;            shortHand_function_type shortHand_function_value( &::SireMove::Ensemble::shortHand );                        Ensemble_exposer.def(                 "shortHand"                , shortHand_function_value                , "Return the shorthand string for this ensemble (e.g. NVT)" );                }        { //::SireMove::Ensemble::temperature                    typedef ::SireUnits::Dimension::Temperature ( ::SireMove::Ensemble::*temperature_function_type)(  ) const;            temperature_function_type temperature_function_value( &::SireMove::Ensemble::temperature );                        Ensemble_exposer.def(                 "temperature"                , temperature_function_value                , "Return the temperature of this ensemble/nThrow: SireError::incompatible_error/n" );                }        { //::SireMove::Ensemble::toString                    typedef ::QString ( ::SireMove::Ensemble::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMove::Ensemble::toString );                        Ensemble_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this ensemble" );                }        { //::SireMove::Ensemble::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMove::Ensemble::typeName );                        Ensemble_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        Ensemble_exposer.staticmethod( "MuVT" );        Ensemble_exposer.staticmethod( "NPT" );        Ensemble_exposer.staticmethod( "NVE" );        Ensemble_exposer.staticmethod( "NVT" );        Ensemble_exposer.staticmethod( "canonical" );        Ensemble_exposer.staticmethod( "grandCanonical" );        Ensemble_exposer.staticmethod( "isothermalIsobaric" );        Ensemble_exposer.staticmethod( "merge" );        Ensemble_exposer.staticmethod( "microcanonical" );        Ensemble_exposer.staticmethod( "typeName" );        Ensemble_exposer.def( "__copy__", &__copy__);        Ensemble_exposer.def( "__deepcopy__", &__copy__);        Ensemble_exposer.def( "clone", &__copy__);        Ensemble_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMove::Ensemble >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Ensemble_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMove::Ensemble >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Ensemble_exposer.def( "__str__", &__str__< ::SireMove::Ensemble > );        Ensemble_exposer.def( "__repr__", &__str__< ::SireMove::Ensemble > );    }}

//.........这里部分代码省略.........        }        TrigArray2D_double__exposer.def( bp::self != bp::self );        { //::SireBase::TrigArray2D< double >::operator()                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef double const & ( ::SireBase::TrigArray2D< double >::*__call___function_type )( int,int ) const;            __call___function_type __call___function_value( &::SireBase::TrigArray2D< double >::operator() );                        TrigArray2D_double__exposer.def(                 "__call__"                , __call___function_value                , ( bp::arg("i"), bp::arg("j") )                , bp::return_value_policy< bp::copy_const_reference >() );                }        { //::SireBase::TrigArray2D< double >::operator=                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef ::SireBase::TrigArray2D< double > & ( ::SireBase::TrigArray2D< double >::*assign_function_type )( ::SireBase::TrigArray2D< double > const & ) ;            assign_function_type assign_function_value( &::SireBase::TrigArray2D< double >::operator= );                        TrigArray2D_double__exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        TrigArray2D_double__exposer.def( bp::self == bp::self );        { //::SireBase::TrigArray2D< double >::redimension                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef void ( ::SireBase::TrigArray2D< double >::*redimension_function_type )( int ) ;            redimension_function_type redimension_function_value( &::SireBase::TrigArray2D< double >::redimension );                        TrigArray2D_double__exposer.def(                 "redimension"                , redimension_function_value                , ( bp::arg("dimension") ) );                }        { //::SireBase::TrigArray2D< double >::set                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef void ( ::SireBase::TrigArray2D< double >::*set_function_type )( int,int,double const & ) ;            set_function_type set_function_value( &::SireBase::TrigArray2D< double >::set );                        TrigArray2D_double__exposer.def(                 "set"                , set_function_value                , ( bp::arg("i"), bp::arg("j"), bp::arg("value") ) );                }        { //::SireBase::TrigArray2D< double >::setAll                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef void ( ::SireBase::TrigArray2D< double >::*setAll_function_type )( double const & ) ;            setAll_function_type setAll_function_value( &::SireBase::TrigArray2D< double >::setAll );                        TrigArray2D_double__exposer.def(                 "setAll"                , setAll_function_value                , ( bp::arg("value") ) );                }        { //::SireBase::TrigArray2D< double >::toString                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef ::QString ( ::SireBase::TrigArray2D< double >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireBase::TrigArray2D< double >::toString );                        TrigArray2D_double__exposer.def(                 "toString"                , toString_function_value );                }        { //::SireBase::TrigArray2D< double >::transpose                    typedef SireBase::TrigArray2D< double > exported_class_t;            typedef ::SireBase::TrigArray2D< double > ( ::SireBase::TrigArray2D< double >::*transpose_function_type )(  ) const;            transpose_function_type transpose_function_value( &::SireBase::TrigArray2D< double >::transpose );                        TrigArray2D_double__exposer.def(                 "transpose"                , transpose_function_value );                }        TrigArray2D_double__exposer.def( "__copy__", &__copy__);        TrigArray2D_double__exposer.def( "__deepcopy__", &__copy__);        TrigArray2D_double__exposer.def( "clone", &__copy__);        TrigArray2D_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::TrigArray2D<double> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        TrigArray2D_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::TrigArray2D<double> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        TrigArray2D_double__exposer.def( "__str__", &__str__< ::SireBase::TrigArray2D<double> > );        TrigArray2D_double__exposer.def( "__repr__", &__str__< ::SireBase::TrigArray2D<double> > );        TrigArray2D_double__exposer.def( "__len__", &__len_size< ::SireBase::TrigArray2D<double> > );    }}

void register_Integrator_class(){    { //::SireMove::Integrator        typedef bp::class_< SireMove::Integrator, bp::bases< SireBase::Property >, boost::noncopyable > Integrator_exposer_t;        Integrator_exposer_t Integrator_exposer = Integrator_exposer_t( "Integrator", "This is the virtual base class of all dynamics integrators. An integrator/nis the kernel used to advance the coordinates of the system from one/ntimestep to the next/n/nAuthor: Christopher Woods/n", bp::no_init );        bp::scope Integrator_scope( Integrator_exposer );        { //::SireMove::Integrator::createWorkspace                    typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireBase::PropertyMap const & ) const;            createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace );                        Integrator_exposer.def(                 "createWorkspace"                , createWorkspace_function_value                , ( bp::arg("map")=SireBase::PropertyMap() )                , "" );                }        { //::SireMove::Integrator::createWorkspace                    typedef ::SireMove::IntegratorWorkspacePtr ( ::SireMove::Integrator::*createWorkspace_function_type)( ::SireMol::MoleculeGroup const &,::SireBase::PropertyMap const & ) const;            createWorkspace_function_type createWorkspace_function_value( &::SireMove::Integrator::createWorkspace );                        Integrator_exposer.def(                 "createWorkspace"                , createWorkspace_function_value                , ( bp::arg("molgroup"), bp::arg("map")=SireBase::PropertyMap() )                , "" );                }        { //::SireMove::Integrator::ensemble                    typedef ::SireMove::Ensemble ( ::SireMove::Integrator::*ensemble_function_type)(  ) const;            ensemble_function_type ensemble_function_value( &::SireMove::Integrator::ensemble );                        Integrator_exposer.def(                 "ensemble"                , ensemble_function_value                , "" );                }        { //::SireMove::Integrator::integrate                    typedef void ( ::SireMove::Integrator::*integrate_function_type)( ::SireMove::IntegratorWorkspace &,::SireCAS::Symbol const &,::SireUnits::Dimension::Time,int,bool ) ;            integrate_function_type integrate_function_value( &::SireMove::Integrator::integrate );                        Integrator_exposer.def(                 "integrate"                , integrate_function_value                , ( bp::arg("workspace"), bp::arg("nrg_component"), bp::arg("timestep"), bp::arg("nmoves"), bp::arg("record_stats") )                , "" );                }        { //::SireMove::Integrator::isTimeReversible                    typedef bool ( ::SireMove::Integrator::*isTimeReversible_function_type)(  ) const;            isTimeReversible_function_type isTimeReversible_function_value( &::SireMove::Integrator::isTimeReversible );                        Integrator_exposer.def(                 "isTimeReversible"                , isTimeReversible_function_value                , "" );                }        { //::SireMove::Integrator::null                    typedef ::SireMove::NullIntegrator const & ( *null_function_type )(  );            null_function_type null_function_value( &::SireMove::Integrator::null );                        Integrator_exposer.def(                 "null"                , null_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "Return a NullIntegrator" );                }        { //::SireMove::Integrator::toString                    typedef ::QString ( ::SireMove::Integrator::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMove::Integrator::toString );                        Integrator_exposer.def(                 "toString"                , toString_function_value                , "" );                }        { //::SireMove::Integrator::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMove::Integrator::typeName );                        Integrator_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        Integrator_exposer.staticmethod( "null" );        Integrator_exposer.staticmethod( "typeName" );//.........这里部分代码省略.........

void register_BeadEditor_class(){    { //::SireMol::BeadEditor        typedef bp::class_< SireMol::BeadEditor, bp::bases< SireMol::Editor<SireMol::BeadEditor, SireMol::Bead>, SireMol::Bead, SireMol::MoleculeView, SireBase::Property > > BeadEditor_exposer_t;        BeadEditor_exposer_t BeadEditor_exposer = BeadEditor_exposer_t( "BeadEditor", "This is an editor for a single bead in a molecule/n/nAuthor: Christopher Woods/n", bp::init< >("Null constructor") );        bp::scope BeadEditor_scope( BeadEditor_exposer );        BeadEditor_exposer.def( bp::init< SireMol::Bead const & >(( bp::arg("bead") ), "Constructor an editor for the passed bead") );        BeadEditor_exposer.def( bp::init< SireMol::BeadEditor const & >(( bp::arg("other") ), "Copy constructor") );        { //::SireMol::BeadEditor::commit                    typedef ::SireMol::Bead ( ::SireMol::BeadEditor::*commit_function_type)(  ) const;            commit_function_type commit_function_value( &::SireMol::BeadEditor::commit );                        BeadEditor_exposer.def(                 "commit"                , commit_function_value                , "Commit the changes" );                }        { //::SireMol::BeadEditor::operator=                    typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::Bead const & ) ;            assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= );                        BeadEditor_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("bead") )                , bp::return_self< >()                , "" );                }        { //::SireMol::BeadEditor::operator=                    typedef ::SireMol::BeadEditor & ( ::SireMol::BeadEditor::*assign_function_type)( ::SireMol::BeadEditor const & ) ;            assign_function_type assign_function_value( &::SireMol::BeadEditor::operator= );                        BeadEditor_exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >()                , "" );                }        { //::SireMol::BeadEditor::toString                    typedef ::QString ( ::SireMol::BeadEditor::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMol::BeadEditor::toString );                        BeadEditor_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this editor" );                }        { //::SireMol::BeadEditor::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMol::BeadEditor::typeName );                        BeadEditor_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        BeadEditor_exposer.staticmethod( "typeName" );        BeadEditor_exposer.def( "__copy__", &__copy__);        BeadEditor_exposer.def( "__deepcopy__", &__copy__);        BeadEditor_exposer.def( "clone", &__copy__);        BeadEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::BeadEditor >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BeadEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::BeadEditor >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BeadEditor_exposer.def( "__str__", &__str__< ::SireMol::BeadEditor > );        BeadEditor_exposer.def( "__repr__", &__str__< ::SireMol::BeadEditor > );        BeadEditor_exposer.def( "__len__", &__len_size< ::SireMol::BeadEditor > );    }}

//.........这里部分代码省略.........        }        Specify_SegID__exposer.def( bp::self != bp::self );        Specify_SegID__exposer.def( bp::self != bp::other< SireID::ID >() );        { //::SireID::Specify< SireMol::SegID >::operator()                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int ) const;            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );                        Specify_SegID__exposer.def(                 "__call__"                , __call___function_value                , ( bp::arg("i") ) );                }        { //::SireID::Specify< SireMol::SegID >::operator()                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__call___function_type )( int,int ) const;            __call___function_type __call___function_value( &::SireID::Specify< SireMol::SegID >::operator() );                        Specify_SegID__exposer.def(                 "__call__"                , __call___function_value                , ( bp::arg("i"), bp::arg("j") ) );                }        { //::SireID::Specify< SireMol::SegID >::operator=                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef ::SireID::Specify< SireMol::SegID > & ( ::SireID::Specify< SireMol::SegID >::*assign_function_type )( ::SireID::Specify< SireMol::SegID > const & ) ;            assign_function_type assign_function_value( &::SireID::Specify< SireMol::SegID >::operator= );                        Specify_SegID__exposer.def(                 "assign"                , assign_function_value                , ( bp::arg("other") )                , bp::return_self< >() );                }        Specify_SegID__exposer.def( bp::self == bp::self );        Specify_SegID__exposer.def( bp::self == bp::other< SireID::ID >() );        { //::SireID::Specify< SireMol::SegID >::operator[]                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef ::SireID::Specify< SireMol::SegID > ( ::SireID::Specify< SireMol::SegID >::*__getitem___function_type )( int ) const;            __getitem___function_type __getitem___function_value( &::SireID::Specify< SireMol::SegID >::operator[] );                        Specify_SegID__exposer.def(                 "__getitem__"                , __getitem___function_value                , ( bp::arg("i") ) );                }        { //::SireID::Specify< SireMol::SegID >::toString                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef ::QString ( ::SireID::Specify< SireMol::SegID >::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireID::Specify< SireMol::SegID >::toString );                        Specify_SegID__exposer.def(                 "toString"                , toString_function_value );                }        { //::SireID::Specify< SireMol::SegID >::typeName                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireID::Specify< SireMol::SegID >::typeName );                        Specify_SegID__exposer.def(                 "typeName"                , typeName_function_value );                }        { //::SireID::Specify< SireMol::SegID >::what                    typedef SireID::Specify< SireMol::SegID > exported_class_t;            typedef char const * ( ::SireID::Specify< SireMol::SegID >::*what_function_type )(  ) const;            what_function_type what_function_value( &::SireID::Specify< SireMol::SegID >::what );                        Specify_SegID__exposer.def(                 "what"                , what_function_value );                }        Specify_SegID__exposer.staticmethod( "typeName" );        Specify_SegID__exposer.def( "__copy__", &__copy__);        Specify_SegID__exposer.def( "__deepcopy__", &__copy__);        Specify_SegID__exposer.def( "clone", &__copy__);        Specify_SegID__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Specify_SegID__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireID::Specify<SireMol::SegID> >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        Specify_SegID__exposer.def( "__str__", &__str__< ::SireID::Specify<SireMol::SegID> > );        Specify_SegID__exposer.def( "__repr__", &__str__< ::SireID::Specify<SireMol::SegID> > );    }}

//.........这里部分代码省略.........                "recreate"                , recreate_function_value                , ( bp::arg("mapping_function") )                , "" );                }        { //::SireMM::LJPerturbation::recreate                    typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*recreate_function_type)( ::SireCAS::Expression const &,::SireBase::PropertyMap const & ) const;            recreate_function_type recreate_function_value( &::SireMM::LJPerturbation::recreate );                        LJPerturbation_exposer.def(                 "recreate"                , recreate_function_value                , ( bp::arg("mapping_function"), bp::arg("map") )                , "" );                }        { //::SireMM::LJPerturbation::requiredProperties                    typedef ::QSet< QString > ( ::SireMM::LJPerturbation::*requiredProperties_function_type)(  ) const;            requiredProperties_function_type requiredProperties_function_value( &::SireMM::LJPerturbation::requiredProperties );                        LJPerturbation_exposer.def(                 "requiredProperties"                , requiredProperties_function_value                , "Return the properties required or changed by this perturbation" );                }        { //::SireMM::LJPerturbation::sigmaMappingFunction                    typedef ::SireCAS::Expression const & ( ::SireMM::LJPerturbation::*sigmaMappingFunction_function_type)(  ) const;            sigmaMappingFunction_function_type sigmaMappingFunction_function_value( &::SireMM::LJPerturbation::sigmaMappingFunction );                        LJPerturbation_exposer.def(                 "sigmaMappingFunction"                , sigmaMappingFunction_function_value                , bp::return_value_policy< bp::copy_const_reference >()                , "Return the function used to map sigma/nThrow: SireError::invalid_state/n" );                }        { //::SireMM::LJPerturbation::substitute                    typedef ::SireMol::PerturbationPtr ( ::SireMM::LJPerturbation::*substitute_function_type)( ::SireCAS::Identities const & ) const;            substitute_function_type substitute_function_value( &::SireMM::LJPerturbation::substitute );                        LJPerturbation_exposer.def(                 "substitute"                , substitute_function_value                , ( bp::arg("identities") )                , "Substitute the identities in identities in all of the mapping functions/nused by this perturbation. This is useful if, for example, you want to/nswitch from using lambda to control the perturbation to using alpha, e.g./n" );                }        { //::SireMM::LJPerturbation::toString                    typedef ::QString ( ::SireMM::LJPerturbation::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMM::LJPerturbation::toString );                        LJPerturbation_exposer.def(                 "toString"                , toString_function_value                , "Return a string representation of this perturbation" );                }        { //::SireMM::LJPerturbation::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMM::LJPerturbation::typeName );                        LJPerturbation_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireMM::LJPerturbation::wouldChange                    typedef bool ( ::SireMM::LJPerturbation::*wouldChange_function_type)( ::SireMol::Molecule const &,::SireCAS::Values const & ) const;            wouldChange_function_type wouldChange_function_value( &::SireMM::LJPerturbation::wouldChange );                        LJPerturbation_exposer.def(                 "wouldChange"                , wouldChange_function_value                , ( bp::arg("molecule"), bp::arg("values") )                , "Return whether or not this perturbation with the passed values would/nchange the molecule molecule" );                }        LJPerturbation_exposer.staticmethod( "typeName" );        LJPerturbation_exposer.def( "__copy__", &__copy__);        LJPerturbation_exposer.def( "__deepcopy__", &__copy__);        LJPerturbation_exposer.def( "clone", &__copy__);        LJPerturbation_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMM::LJPerturbation >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        LJPerturbation_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMM::LJPerturbation >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        LJPerturbation_exposer.def( "__str__", &__str__< ::SireMM::LJPerturbation > );        LJPerturbation_exposer.def( "__repr__", &__str__< ::SireMM::LJPerturbation > );    }}

//.........这里部分代码省略.........            MultiVector_exposer.def(                 "setZ"                , setZ_function_value                , ( bp::arg("val") )                , "Set individual values of the vector" );                }        { //::SireMaths::MultiVector::size                    typedef int ( *size_function_type )(  );            size_function_type size_function_value( &::SireMaths::MultiVector::size );                        MultiVector_exposer.def(                 "size"                , size_function_value                , "Return the number of vectors in this MultiVector" );                }        { //::SireMaths::MultiVector::swap                    typedef void ( *swap_function_type )( ::SireMaths::MultiVector &,int,::SireMaths::MultiVector &,int );            swap_function_type swap_function_value( &::SireMaths::MultiVector::swap );                        MultiVector_exposer.def(                 "swap"                , swap_function_value                , ( bp::arg("v0"), bp::arg("idx0"), bp::arg("v1"), bp::arg("idx1") )                , "Swap the values of the value at index idx0 in f0 with the value at index idx in f1" );                }        { //::SireMaths::MultiVector::toString                    typedef ::QString ( ::SireMaths::MultiVector::*toString_function_type)(  ) const;            toString_function_type toString_function_value( &::SireMaths::MultiVector::toString );                        MultiVector_exposer.def(                 "toString"                , toString_function_value                , "Return a QString representation of the vector" );                }        { //::SireMaths::MultiVector::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireMaths::MultiVector::typeName );                        MultiVector_exposer.def(                 "typeName"                , typeName_function_value                , "" );                }        { //::SireMaths::MultiVector::what                    typedef char const * ( ::SireMaths::MultiVector::*what_function_type)(  ) const;            what_function_type what_function_value( &::SireMaths::MultiVector::what );                        MultiVector_exposer.def(                 "what"                , what_function_value                , "" );                }        { //::SireMaths::MultiVector::x                    typedef ::SireMaths::MultiDouble const & ( ::SireMaths::MultiVector::*x_function_type)(  ) const;

//.........这里部分代码省略.........                , ( bp::arg("i") ) );                }        { //::SireVol::BoxPatching::patchBox                    typedef ::SireVol::AABox ( ::SireVol::BoxPatching::*patchBox_function_type )( ::SireMaths::Vector const & ) const;            patchBox_function_type patchBox_function_value( &::SireVol::BoxPatching::patchBox );                        BoxPatching_exposer.def(                 "patchBox"                , patchBox_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchDimension                    typedef ::SireMaths::Vector ( ::SireVol::BoxPatching::*patchDimension_function_type )(  ) const;            patchDimension_function_type patchDimension_function_value( &::SireVol::BoxPatching::patchDimension );                        BoxPatching_exposer.def(                 "patchDimension"                , patchDimension_function_value );                }        { //::SireVol::BoxPatching::patchIndex                    typedef int ( ::SireVol::BoxPatching::*patchIndex_function_type )( ::SireMaths::Vector const & ) const;            patchIndex_function_type patchIndex_function_value( &::SireVol::BoxPatching::patchIndex );                        BoxPatching_exposer.def(                 "patchIndex"                , patchIndex_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchIndexAndCenter                    typedef ::QPair< int, SireMaths::Vector > ( ::SireVol::BoxPatching::*patchIndexAndCenter_function_type )( ::SireMaths::Vector const & ) const;            patchIndexAndCenter_function_type patchIndexAndCenter_function_value( &::SireVol::BoxPatching::patchIndexAndCenter );                        BoxPatching_exposer.def(                 "patchIndexAndCenter"                , patchIndexAndCenter_function_value                , ( bp::arg("point") ) );                }        { //::SireVol::BoxPatching::patchSize                    typedef ::SireUnits::Dimension::Length ( ::SireVol::BoxPatching::*patchSize_function_type )(  ) const;            patchSize_function_type patchSize_function_value( &::SireVol::BoxPatching::patchSize );                        BoxPatching_exposer.def(                 "patchSize"                , patchSize_function_value );                }        { //::SireVol::BoxPatching::repatch                    typedef ::SireVol::PatchingPtr ( ::SireVol::BoxPatching::*repatch_function_type )( ::SireVol::Space const & ) const;            repatch_function_type repatch_function_value( &::SireVol::BoxPatching::repatch );                        BoxPatching_exposer.def(                 "repatch"                , repatch_function_value                , ( bp::arg("new_space") ) );                }        { //::SireVol::BoxPatching::toString                    typedef ::QString ( ::SireVol::BoxPatching::*toString_function_type )(  ) const;            toString_function_type toString_function_value( &::SireVol::BoxPatching::toString );                        BoxPatching_exposer.def(                 "toString"                , toString_function_value );                }        { //::SireVol::BoxPatching::typeName                    typedef char const * ( *typeName_function_type )(  );            typeName_function_type typeName_function_value( &::SireVol::BoxPatching::typeName );                        BoxPatching_exposer.def(                 "typeName"                , typeName_function_value );                }        BoxPatching_exposer.staticmethod( "typeName" );        BoxPatching_exposer.def( "__copy__", &__copy__);        BoxPatching_exposer.def( "__deepcopy__", &__copy__);        BoxPatching_exposer.def( "clone", &__copy__);        BoxPatching_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireVol::BoxPatching >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BoxPatching_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireVol::BoxPatching >,                            bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );        BoxPatching_exposer.def( "__str__", &__str__< ::SireVol::BoxPatching > );        BoxPatching_exposer.def( "__repr__", &__str__< ::SireVol::BoxPatching > );    }}