void register_Mover_ViewsOfMol__class(){
{ //::SireMol::Mover< SireMol::ViewsOfMol >
typedef bp::class_< SireMol::Mover< SireMol::ViewsOfMol >, bp::bases< SireMol::MoverBase, SireMol::ViewsOfMol, SireMol::MoleculeView, SireBase::Property > > Mover_ViewsOfMol__exposer_t;
Mover_ViewsOfMol__exposer_t Mover_ViewsOfMol__exposer = Mover_ViewsOfMol__exposer_t( "Mover_ViewsOfMol_", bp::init< >() );
bp::scope Mover_ViewsOfMol__scope( Mover_ViewsOfMol__exposer );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const & >(( bp::arg("view") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::ViewsOfMol const &, SireMol::AtomSelection const & >(( bp::arg("view"), bp::arg("movable_atoms") )) );
Mover_ViewsOfMol__exposer.def( bp::init< SireMol::Mover< SireMol::ViewsOfMol > const & >(( bp::arg("other") )) );
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::align
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*align_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
align_function_type align_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::align );
Mover_ViewsOfMol__exposer.def(
"align"
, align_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::alignTo
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*alignTo_function_type )( ::SireMol::MoleculeView const &,::SireMol::AtomSelection const &,::SireMol::AtomMatcher const &,::SireBase::PropertyMap const &,::SireBase::PropertyMap const & ) ;
alignTo_function_type alignTo_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::alignTo );
Mover_ViewsOfMol__exposer.def(
"alignTo"
, alignTo_function_value
, ( bp::arg("other"), bp::arg("aligning_atoms"), bp::arg("matcher"), bp::arg("map0"), bp::arg("map1") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("angle"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("dihedral"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("bond"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::change
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*change_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
change_function_type change_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::change );
Mover_ViewsOfMol__exposer.def(
"change"
, change_function_value
, ( bp::arg("improper"), bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::changeFrame );
Mover_ViewsOfMol__exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::commit
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::ViewsOfMol ( ::SireMol::Mover< SireMol::ViewsOfMol >::*commit_function_type )( ) const;
commit_function_type commit_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::commit );
Mover_ViewsOfMol__exposer.def(
"commit"
, commit_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::mapInto
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*mapInto_function_type )( ::SireMaths::AxisSet const &,::SireBase::PropertyMap const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::mapInto );
Mover_ViewsOfMol__exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::Mover< SireMol::ViewsOfMol > const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::operator=
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*assign_function_type )( ::SireMol::ViewsOfMol const & ) ;
assign_function_type assign_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::operator= );
Mover_ViewsOfMol__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::rotate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
rotate_function_type rotate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::rotate );
Mover_ViewsOfMol__exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::BondID const &,::SireUnits::Dimension::PhysUnit< 0, 1, 0, 0, 0, 0, 0 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("bond"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::AngleID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("angle"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::set
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*set_function_type )( ::SireMol::ImproperID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
set_function_type set_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::set );
Mover_ViewsOfMol__exposer.def(
"set"
, set_function_value
, ( bp::arg("improper"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::setAll
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*setAll_function_type )( ::SireMol::DihedralID const &,::SireUnits::Dimension::PhysUnit< 0, 0, 0, 0, 0, 0, 1 >,::SireBase::PropertyMap const & ) ;
setAll_function_type setAll_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::setAll );
Mover_ViewsOfMol__exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("dihedral"), bp::arg("value"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::toString
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::QString ( ::SireMol::Mover< SireMol::ViewsOfMol >::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::toString );
Mover_ViewsOfMol__exposer.def(
"toString"
, toString_function_value );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::transform
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*transform_function_type )( ::SireMaths::Transform const &,::SireBase::PropertyMap const & ) ;
transform_function_type transform_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::transform );
Mover_ViewsOfMol__exposer.def(
"transform"
, transform_function_value
, ( bp::arg("transform"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::translate
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef ::SireMol::Mover< SireMol::ViewsOfMol > & ( ::SireMol::Mover< SireMol::ViewsOfMol >::*translate_function_type )( ::SireMaths::Vector const &,::SireBase::PropertyMap const & ) ;
translate_function_type translate_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::translate );
Mover_ViewsOfMol__exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta"), bp::arg("map")=SireBase::PropertyMap() )
, bp::return_self< >() );
}
{ //::SireMol::Mover< SireMol::ViewsOfMol >::typeName
typedef SireMol::Mover< SireMol::ViewsOfMol > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::Mover< SireMol::ViewsOfMol >::typeName );
Mover_ViewsOfMol__exposer.def(
"typeName"
, typeName_function_value );
}
Mover_ViewsOfMol__exposer.staticmethod( "typeName" );
Mover_ViewsOfMol__exposer.def( "__copy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "__deepcopy__", &__copy__);
Mover_ViewsOfMol__exposer.def( "clone", &__copy__);
Mover_ViewsOfMol__exposer.def( "__str__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__repr__", &__str__< ::SireMol::Mover<SireMol::ViewsOfMol> > );
Mover_ViewsOfMol__exposer.def( "__len__", &__len_count< ::SireMol::Mover<SireMol::ViewsOfMol> > );
}
}
void register_CLJWorkspace_class(){
{ //::SireMM::CLJWorkspace
typedef bp::class_< SireMM::CLJWorkspace > CLJWorkspace_exposer_t;
CLJWorkspace_exposer_t CLJWorkspace_exposer = CLJWorkspace_exposer_t( "CLJWorkspace", "This class provides a workspace in which to hold the details of the changes\nthat occur in a CLJ forcefield during a Monte Carlo move. The class is optimised\nto avoid copying or duplicating data during Sires copy-on-write copying\n(e.g. the memory allocated in a workspace will always be available for the\nnew copy of a forcefield rather than the old, which, if things work correctly,\nwill mean that there should be no memory allocation during simple MC moves...)\n\nAuthor: Christopher Woods\n", bp::init< >("Constructor") );
bp::scope CLJWorkspace_scope( CLJWorkspace_exposer );
CLJWorkspace_exposer.def( bp::init< SireMM::CLJWorkspace const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMM::CLJWorkspace::accept
typedef void ( ::SireMM::CLJWorkspace::*accept_function_type)( ::SireMM::CLJBoxes & ) ;
accept_function_type accept_function_value( &::SireMM::CLJWorkspace::accept );
CLJWorkspace_exposer.def(
"accept"
, accept_function_value
, ( bp::arg("boxes") )
, "Accept this workspace - this clears the recalc_from_scratch flag as it\nsignals that we have put the CLJBoxes into a sane state" );
}
{ //::SireMM::CLJWorkspace::at
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireMM::CLJWorkspace::at );
CLJWorkspace_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::changedAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*changedAtoms_function_type)( ) const;
changedAtoms_function_type changedAtoms_function_value( &::SireMM::CLJWorkspace::changedAtoms );
CLJWorkspace_exposer.def(
"changedAtoms"
, changedAtoms_function_value
, "Merge all of the deltas together into a single set of changed CLJAtoms that\ncan be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::clear
typedef void ( ::SireMM::CLJWorkspace::*clear_function_type)( ) ;
clear_function_type clear_function_value( &::SireMM::CLJWorkspace::clear );
CLJWorkspace_exposer.def(
"clear"
, clear_function_value
, "Clear this workspace" );
}
{ //::SireMM::CLJWorkspace::commit
typedef ::QVector< SireMM::CLJBoxIndex > ( ::SireMM::CLJWorkspace::*commit_function_type)( ::SireMM::CLJBoxes &,::SireMM::CLJDelta const & ) ;
commit_function_type commit_function_value( &::SireMM::CLJWorkspace::commit );
CLJWorkspace_exposer.def(
"commit"
, commit_function_value
, ( bp::arg("boxes"), bp::arg("delta") )
, "Commit the changes in the passed delta into the passed CLJBoxes" );
}
{ //::SireMM::CLJWorkspace::count
typedef int ( ::SireMM::CLJWorkspace::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMM::CLJWorkspace::count );
CLJWorkspace_exposer.def(
"count"
, count_function_value
, "Return the number of deltas" );
}
{ //::SireMM::CLJWorkspace::getitem
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*getitem_function_type)( int ) const;
getitem_function_type getitem_function_value( &::SireMM::CLJWorkspace::getitem );
CLJWorkspace_exposer.def(
"getitem"
, getitem_function_value
, ( bp::arg("i") )
, "Return the ith delta" );
}
{ //::SireMM::CLJWorkspace::isEmpty
typedef bool ( ::SireMM::CLJWorkspace::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMM::CLJWorkspace::isEmpty );
CLJWorkspace_exposer.def(
"isEmpty"
, isEmpty_function_value
, "Return whether or not this workspace is empty" );
}
{ //::SireMM::CLJWorkspace::isSingleID
typedef bool ( ::SireMM::CLJWorkspace::*isSingleID_function_type)( ) const;
isSingleID_function_type isSingleID_function_value( &::SireMM::CLJWorkspace::isSingleID );
CLJWorkspace_exposer.def(
"isSingleID"
, isSingleID_function_value
, "Return whether or not this workspace contains deltas with a single\nID (a single CLJAtoms ID)" );
}
{ //::SireMM::CLJWorkspace::merge
typedef ::boost::tuples::tuple< SireMM::CLJAtoms, SireMM::CLJAtoms, SireMM::CLJAtoms, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type, boost::tuples::null_type > ( ::SireMM::CLJWorkspace::*merge_function_type)( ) const;
merge_function_type merge_function_value( &::SireMM::CLJWorkspace::merge );
CLJWorkspace_exposer.def(
"merge"
, merge_function_value
, "Merge all of the deltas together to return the tuple of the\nchanged, old and new atoms. This is equivalent to calling\nchangedAtoms(), oldAtoms() and newAtoms() and placing them\ninto a tuple. This is more efficient than three separate calls" );
}
{ //::SireMM::CLJWorkspace::mustRecalculateFromScratch
typedef void ( ::SireMM::CLJWorkspace::*mustRecalculateFromScratch_function_type)( ::SireMM::CLJBoxes & ) ;
mustRecalculateFromScratch_function_type mustRecalculateFromScratch_function_value( &::SireMM::CLJWorkspace::mustRecalculateFromScratch );
CLJWorkspace_exposer.def(
"mustRecalculateFromScratch"
, mustRecalculateFromScratch_function_value
, ( bp::arg("boxes") )
, "Tell the workspace that we are now recalculating everything from scratch" );
}
{ //::SireMM::CLJWorkspace::nDeltas
typedef int ( ::SireMM::CLJWorkspace::*nDeltas_function_type)( ) const;
nDeltas_function_type nDeltas_function_value( &::SireMM::CLJWorkspace::nDeltas );
CLJWorkspace_exposer.def(
"nDeltas"
, nDeltas_function_value
, "Return the number of deltas in this workspace" );
}
{ //::SireMM::CLJWorkspace::needsAccepting
typedef bool ( ::SireMM::CLJWorkspace::*needsAccepting_function_type)( ) const;
needsAccepting_function_type needsAccepting_function_value( &::SireMM::CLJWorkspace::needsAccepting );
CLJWorkspace_exposer.def(
"needsAccepting"
, needsAccepting_function_value
, "Return whether or not this workspace needs accepting" );
}
{ //::SireMM::CLJWorkspace::newAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*newAtoms_function_type)( ) const;
newAtoms_function_type newAtoms_function_value( &::SireMM::CLJWorkspace::newAtoms );
CLJWorkspace_exposer.def(
"newAtoms"
, newAtoms_function_value
, "Merge all of the new atoms from the deltas together into a single\nset of new CLJAtoms that can be used for the change in energy calculation" );
}
{ //::SireMM::CLJWorkspace::oldAtoms
typedef ::SireMM::CLJAtoms ( ::SireMM::CLJWorkspace::*oldAtoms_function_type)( ) const;
oldAtoms_function_type oldAtoms_function_value( &::SireMM::CLJWorkspace::oldAtoms );
CLJWorkspace_exposer.def(
"oldAtoms"
, oldAtoms_function_value
, "Merge all of the old atoms from the deltas together into a single\nset of old CLJAtoms that can be used for the change in energy calculation" );
}
CLJWorkspace_exposer.def( bp::self != bp::self );
{ //::SireMM::CLJWorkspace::operator=
typedef ::SireMM::CLJWorkspace & ( ::SireMM::CLJWorkspace::*assign_function_type)( ::SireMM::CLJWorkspace const & ) ;
assign_function_type assign_function_value( &::SireMM::CLJWorkspace::operator= );
CLJWorkspace_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
CLJWorkspace_exposer.def( bp::self == bp::self );
{ //::SireMM::CLJWorkspace::operator[]
typedef ::SireMM::CLJDelta const & ( ::SireMM::CLJWorkspace::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireMM::CLJWorkspace::operator[] );
CLJWorkspace_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMM::CLJWorkspace::push
typedef ::SireMM::CLJDelta ( ::SireMM::CLJWorkspace::*push_function_type)( ::SireMM::CLJBoxes &,::QVector< SireMM::CLJBoxIndex > const &,::SireMM::CLJAtoms const &,::SireMM::CLJDelta const & ) ;
push_function_type push_function_value( &::SireMM::CLJWorkspace::push );
CLJWorkspace_exposer.def(
"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 );
}
}
void register_MolEditor_class(){
{ //::SireMol::MolEditor
typedef bp::class_< SireMol::MolEditor, bp::bases< SireMol::Editor<SireMol::MolEditor, SireMol::Molecule>, SireMol::Molecule, SireMol::MoleculeView, SireBase::Property > > MolEditor_exposer_t;
MolEditor_exposer_t MolEditor_exposer = MolEditor_exposer_t( "MolEditor", "This class is used to edit non-structural parts of a molecule\n(e.g. its name, number, properties etc.). To add, move or remove\natoms, residues, CutGroups, chains or segments, you need to\nuse a MolStructureEditor (which is created for you automatically\nby member functions that perform such editing)\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope MolEditor_scope( MolEditor_exposer );
MolEditor_exposer.def( bp::init< SireMol::Molecule const & >(( bp::arg("molecule") ), "Construct an editor to edit a copy of molecule") );
MolEditor_exposer.def( bp::init< SireMol::MolEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::MolEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atom") )
, "Add an atom called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::AtomNum const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atom") )
, "Add an atom with number number and return an editor that\ncan be used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("residue") )
, "Add a residue called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ResStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ResNum const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("residue") )
, "Add a residue with number number and return an editor that\ncan be used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::CGStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::CGName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("cutgroup") )
, "Add a CutGroup called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::ChainStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::ChainName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("chain") )
, "Add a chain called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::add
typedef ::SireMol::SegStructureEditor ( ::SireMol::MolEditor::*add_function_type)( ::SireMol::SegName const & ) const;
add_function_type add_function_value( &::SireMol::MolEditor::add );
MolEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("segment") )
, "Add a segment called name and return an editor that can\nbe used to edit it" );
}
{ //::SireMol::MolEditor::commit
typedef ::SireMol::Molecule ( ::SireMol::MolEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::MolEditor::commit );
MolEditor_exposer.def(
"commit"
, commit_function_value
, "Commit these changes and return a copy of the\nedited molecule" );
}
{ //::SireMol::MolEditor::operator=
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::Molecule const & ) ;
assign_function_type assign_function_value( &::SireMol::MolEditor::operator= );
MolEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("molecule") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::MolEditor::operator=
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*assign_function_type)( ::SireMol::MolEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::MolEditor::operator= );
MolEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::AtomID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atomid") )
, "Remove all atoms from this molecule that have the ID atomid.\nThis does nothing if there are no atoms with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::CGID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("cgid") )
, "Remove all CutGroups from this molecule that have the ID atomid.\nThis does nothing if there are no CutGroups with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ResID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("resid") )
, "Remove all residues from this molecule that have the ID atomid.\nThis does nothing if there are no residues with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::ChainID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("chainid") )
, "Remove all chains from this molecule that have the ID atomid.\nThis does nothing if there are no chains with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*remove_function_type)( ::SireMol::SegID const & ) const;
remove_function_type remove_function_value( &::SireMol::MolEditor::remove );
MolEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("segid") )
, "Remove all segments from this molecule that have the ID atomid.\nThis does nothing if there are no segments with this ID.\nThis returns an editor that can be used to further edit\nthe molecule" );
}
{ //::SireMol::MolEditor::removeAllAtoms
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllAtoms_function_type)( ) const;
removeAllAtoms_function_type removeAllAtoms_function_value( &::SireMol::MolEditor::removeAllAtoms );
MolEditor_exposer.def(
"removeAllAtoms"
, removeAllAtoms_function_value
, "Remove all atoms from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllChains
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllChains_function_type)( ) const;
removeAllChains_function_type removeAllChains_function_value( &::SireMol::MolEditor::removeAllChains );
MolEditor_exposer.def(
"removeAllChains"
, removeAllChains_function_value
, "Remove all chains from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllCutGroups
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllCutGroups_function_type)( ) const;
removeAllCutGroups_function_type removeAllCutGroups_function_value( &::SireMol::MolEditor::removeAllCutGroups );
MolEditor_exposer.def(
"removeAllCutGroups"
, removeAllCutGroups_function_value
, "Remove all CutGroups from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllResidues
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllResidues_function_type)( ) const;
removeAllResidues_function_type removeAllResidues_function_value( &::SireMol::MolEditor::removeAllResidues );
MolEditor_exposer.def(
"removeAllResidues"
, removeAllResidues_function_value
, "Remove all residues from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::removeAllSegments
typedef ::SireMol::MolStructureEditor ( ::SireMol::MolEditor::*removeAllSegments_function_type)( ) const;
removeAllSegments_function_type removeAllSegments_function_value( &::SireMol::MolEditor::removeAllSegments );
MolEditor_exposer.def(
"removeAllSegments"
, removeAllSegments_function_value
, "Remove all segments from this molecule. This returns an editor that\ncan be used to further edit the structure of this molecule" );
}
{ //::SireMol::MolEditor::rename
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*rename_function_type)( ::QString const & ) ;
rename_function_type rename_function_value( &::SireMol::MolEditor::rename );
MolEditor_exposer.def(
"rename"
, rename_function_value
, ( bp::arg("name") )
, bp::return_self< >()
, "Rename this molecule to newname" );
}
{ //::SireMol::MolEditor::renumber
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ) ;
renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber );
MolEditor_exposer.def(
"renumber"
, renumber_function_value
, bp::return_self< >()
, "Give this molecule a new, unique ID number" );
}
{ //::SireMol::MolEditor::renumber
typedef ::SireMol::MolEditor & ( ::SireMol::MolEditor::*renumber_function_type)( ::SireMol::MolNum ) ;
renumber_function_type renumber_function_value( &::SireMol::MolEditor::renumber );
MolEditor_exposer.def(
"renumber"
, renumber_function_value
, ( bp::arg("newnum") )
, bp::return_self< >()
, "Give this molecule the ID number newnum" );
}
{ //::SireMol::MolEditor::toString
typedef ::QString ( ::SireMol::MolEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::MolEditor::toString );
MolEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::MolEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::MolEditor::typeName );
MolEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
MolEditor_exposer.staticmethod( "typeName" );
MolEditor_exposer.def( "__copy__", &__copy__);
MolEditor_exposer.def( "__deepcopy__", &__copy__);
MolEditor_exposer.def( "clone", &__copy__);
MolEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::MolEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::MolEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolEditor_exposer.def( "__str__", &__str__< ::SireMol::MolEditor > );
MolEditor_exposer.def( "__repr__", &__str__< ::SireMol::MolEditor > );
}
}
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 > );
}
}
void register_ResStructureEditor_class(){
{ //::SireMol::ResStructureEditor
typedef bp::class_< SireMol::ResStructureEditor > ResStructureEditor_exposer_t;
ResStructureEditor_exposer_t ResStructureEditor_exposer = ResStructureEditor_exposer_t( "ResStructureEditor", "This is the class used to edit a residues structure\n\nAuthor: Christopher Woods\n", bp::init< >("Null constructor") );
bp::scope ResStructureEditor_scope( ResStructureEditor_exposer );
ResStructureEditor_exposer.def( bp::init< SireMol::Residue const & >(( bp::arg("residue") ), "Construct an editor to edit the structure of a copy of the\nresidue residue") );
ResStructureEditor_exposer.def( bp::init< SireMol::StructureEditor const &, SireMol::ResIdx >(( bp::arg("data"), bp::arg("residx") ), "Construct an editor to edit the residue at index residx in the\neditor whose data is in data\nThrow: SireError::invalid_index\n") );
ResStructureEditor_exposer.def( bp::init< SireMol::ResStructureEditor const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomName const & ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomname") )
, "Add a new atom called name to this residue - this returns\nan editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::add
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*add_function_type)( ::SireMol::AtomNum ) ;
add_function_type add_function_value( &::SireMol::ResStructureEditor::add );
ResStructureEditor_exposer.def(
"add"
, add_function_value
, ( bp::arg("atomnum") )
, "Add a new atom with the number number to this residue - this\nreturns an editor that can be used to further edit this atom" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( int ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::atom
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*atom_function_type)( ::SireMol::AtomID const & ) ;
atom_function_type atom_function_value( &::SireMol::ResStructureEditor::atom );
ResStructureEditor_exposer.def(
"atom"
, atom_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::chain
typedef ::SireMol::ChainStructureEditor ( ::SireMol::ResStructureEditor::*chain_function_type)( ) ;
chain_function_type chain_function_value( &::SireMol::ResStructureEditor::chain );
ResStructureEditor_exposer.def(
"chain"
, chain_function_value
, "Return an editor for the chain that contains this residue" );
}
{ //::SireMol::ResStructureEditor::commit
typedef ::SireMol::Residue ( ::SireMol::ResStructureEditor::*commit_function_type)( ) const;
commit_function_type commit_function_value( &::SireMol::ResStructureEditor::commit );
ResStructureEditor_exposer.def(
"commit"
, commit_function_value
, "Commit the changes made by this editor and return the updated residue" );
}
{ //::SireMol::ResStructureEditor::index
typedef ::SireMol::ResIdx ( ::SireMol::ResStructureEditor::*index_function_type)( ) const;
index_function_type index_function_value( &::SireMol::ResStructureEditor::index );
ResStructureEditor_exposer.def(
"index"
, index_function_value
, "Return the index of this residue in the molecule" );
}
{ //::SireMol::ResStructureEditor::molecule
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*molecule_function_type)( ) ;
molecule_function_type molecule_function_value( &::SireMol::ResStructureEditor::molecule );
ResStructureEditor_exposer.def(
"molecule"
, molecule_function_value
, "Return an editor for the molecule that contains this residue" );
}
{ //::SireMol::ResStructureEditor::nAtoms
typedef int ( ::SireMol::ResStructureEditor::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::ResStructureEditor::nAtoms );
ResStructureEditor_exposer.def(
"nAtoms"
, nAtoms_function_value
, "Return the number of atoms in this residue - this may be zero" );
}
{ //::SireMol::ResStructureEditor::name
typedef ::SireMol::ResName const & ( ::SireMol::ResStructureEditor::*name_function_type)( ) const;
name_function_type name_function_value( &::SireMol::ResStructureEditor::name );
ResStructureEditor_exposer.def(
"name"
, name_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the name of this residue" );
}
{ //::SireMol::ResStructureEditor::number
typedef ::SireMol::ResNum ( ::SireMol::ResStructureEditor::*number_function_type)( ) const;
number_function_type number_function_value( &::SireMol::ResStructureEditor::number );
ResStructureEditor_exposer.def(
"number"
, number_function_value
, "Return the number of this residue" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::Residue const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("residue") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::operator=
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*assign_function_type)( ::SireMol::ResStructureEditor const & ) ;
assign_function_type assign_function_value( &::SireMol::ResStructureEditor::operator= );
ResStructureEditor_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::ResStructureEditor::reindex
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reindex_function_type)( ::SireMol::ResIdx ) ;
reindex_function_type reindex_function_value( &::SireMol::ResStructureEditor::reindex );
ResStructureEditor_exposer.def(
"reindex"
, reindex_function_value
, ( bp::arg("index") )
, bp::return_self< >()
, "Change the index of this residue to newidx. If this\nis larger than the number of residues in the molecule\nthen this residue is moved to the end" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::MolStructureEditor ( ::SireMol::ResStructureEditor::*remove_function_type)( ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, bp::return_self< >()
, "Completely remove this residue from the molecule - this returns\na MolStructureEditor that can be used to further edit the molecule" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( ::SireMol::AtomID const & ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("atomid") )
, bp::return_self< >()
, "Remove all atoms with ID atomid from this residue\nThrow: SireMol::missing_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::remove
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*remove_function_type)( int ) ;
remove_function_type remove_function_value( &::SireMol::ResStructureEditor::remove );
ResStructureEditor_exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") )
, bp::return_self< >()
, "Remove the ith atom from this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::rename
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*rename_function_type)( ::SireMol::ResName const & ) ;
rename_function_type rename_function_value( &::SireMol::ResStructureEditor::rename );
ResStructureEditor_exposer.def(
"rename"
, rename_function_value
, ( bp::arg("name") )
, bp::return_self< >()
, "Rename this residue to newname" );
}
{ //::SireMol::ResStructureEditor::renumber
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*renumber_function_type)( ::SireMol::ResNum ) ;
renumber_function_type renumber_function_value( &::SireMol::ResStructureEditor::renumber );
ResStructureEditor_exposer.def(
"renumber"
, renumber_function_value
, ( bp::arg("number") )
, bp::return_self< >()
, "Renumber this residue to newnum" );
}
{ //::SireMol::ResStructureEditor::reparent
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*reparent_function_type)( ::SireMol::ChainID const & ) ;
reparent_function_type reparent_function_value( &::SireMol::ResStructureEditor::reparent );
ResStructureEditor_exposer.def(
"reparent"
, reparent_function_value
, ( bp::arg("chainid") )
, bp::return_self< >()
, "Move this residue into the chain with ID chainid\nThrow: SireMol::missing_chain\nThrow: SireMol::duplicate_chain\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( int ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("i") )
, "Return an editor for the ith atom in this residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::select
typedef ::SireMol::AtomStructureEditor ( ::SireMol::ResStructureEditor::*select_function_type)( ::SireMol::AtomID const & ) ;
select_function_type select_function_value( &::SireMol::ResStructureEditor::select );
ResStructureEditor_exposer.def(
"select"
, select_function_value
, ( bp::arg("atomid") )
, "Return an editor for the atom with ID == atomid in\nthis residue\nThrow: SireMol::missing_atom\nThrow: SireMol::duplicate_atom\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::selectedAll
typedef bool ( ::SireMol::ResStructureEditor::*selectedAll_function_type)( ) const;
selectedAll_function_type selectedAll_function_value( &::SireMol::ResStructureEditor::selectedAll );
ResStructureEditor_exposer.def(
"selectedAll"
, selectedAll_function_value
, "Is this editor editing the entire molecule?" );
}
{ //::SireMol::ResStructureEditor::toString
typedef ::QString ( ::SireMol::ResStructureEditor::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::ResStructureEditor::toString );
ResStructureEditor_exposer.def(
"toString"
, toString_function_value
, "Return a string representation of this editor" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( ::SireMol::AtomID const &,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("atomid"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms that match the ID atomid into the residue that\nmatches the ID resid\nThrow: SireMol::missing_atom\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transfer
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transfer_function_type)( int,::SireMol::ResID const & ) ;
transfer_function_type transfer_function_value( &::SireMol::ResStructureEditor::transfer );
ResStructureEditor_exposer.def(
"transfer"
, transfer_function_value
, ( bp::arg("i"), bp::arg("resid") )
, bp::return_self< >()
, "Transfer the ith atom from this residue into the residue that\nmatches the ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::transferAll
typedef ::SireMol::ResStructureEditor & ( ::SireMol::ResStructureEditor::*transferAll_function_type)( ::SireMol::ResID const & ) ;
transferAll_function_type transferAll_function_value( &::SireMol::ResStructureEditor::transferAll );
ResStructureEditor_exposer.def(
"transferAll"
, transferAll_function_value
, ( bp::arg("resid") )
, bp::return_self< >()
, "Transfer all atoms from this residue into the residue with ID resid\nThrow: SireMol::missing_residue\nThrow: SireMol::duplicate_residue\nThrow: SireError::invalid_index\n" );
}
{ //::SireMol::ResStructureEditor::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::ResStructureEditor::typeName );
ResStructureEditor_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
{ //::SireMol::ResStructureEditor::what
typedef char const * ( ::SireMol::ResStructureEditor::*what_function_type)( ) const;
what_function_type what_function_value( &::SireMol::ResStructureEditor::what );
ResStructureEditor_exposer.def(
"what"
, what_function_value
, "" );
}
ResStructureEditor_exposer.staticmethod( "typeName" );
ResStructureEditor_exposer.def( "__copy__", &__copy__);
ResStructureEditor_exposer.def( "__deepcopy__", &__copy__);
ResStructureEditor_exposer.def( "clone", &__copy__);
ResStructureEditor_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::ResStructureEditor >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ResStructureEditor_exposer.def( "__str__", &__str__< ::SireMol::ResStructureEditor > );
ResStructureEditor_exposer.def( "__repr__", &__str__< ::SireMol::ResStructureEditor > );
}
}
