void register_MolPotentialTable_class(){
{ //::SireFF::MolPotentialTable
typedef bp::class_< SireFF::MolPotentialTable > MolPotentialTable_exposer_t;
MolPotentialTable_exposer_t MolPotentialTable_exposer = MolPotentialTable_exposer_t( "MolPotentialTable", bp::init< >() );
bp::scope MolPotentialTable_scope( MolPotentialTable_exposer );
MolPotentialTable_exposer.def( bp::init< SireMol::MoleculeView const & >(( bp::arg("molview") )) );
MolPotentialTable_exposer.def( bp::init< SireFF::MolPotentialTable const & >(( bp::arg("other") )) );
{ //::SireFF::MolPotentialTable::add
typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("cgatomidx"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef bool ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("selected_atoms"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireFF::MolPotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::MolPotentialTable::add
typedef void ( ::SireFF::MolPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::MolPotentialTable::add );
MolPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::divide
typedef void ( ::SireFF::MolPotentialTable::*divide_function_type )( double ) ;
divide_function_type divide_function_value( &::SireFF::MolPotentialTable::divide );
MolPotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::MolPotentialTable::initialise
typedef void ( ::SireFF::MolPotentialTable::*initialise_function_type )( ) ;
initialise_function_type initialise_function_value( &::SireFF::MolPotentialTable::initialise );
MolPotentialTable_exposer.def(
"initialise"
, initialise_function_value );
}
{ //::SireFF::MolPotentialTable::map
typedef int ( ::SireFF::MolPotentialTable::*map_function_type )( ::SireMol::CGIdx ) const;
map_function_type map_function_value( &::SireFF::MolPotentialTable::map );
MolPotentialTable_exposer.def(
"map"
, map_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireFF::MolPotentialTable::molNum
typedef ::SireMol::MolNum ( ::SireFF::MolPotentialTable::*molNum_function_type )( ) const;
molNum_function_type molNum_function_value( &::SireFF::MolPotentialTable::molNum );
MolPotentialTable_exposer.def(
"molNum"
, molNum_function_value );
}
{ //::SireFF::MolPotentialTable::molUID
typedef ::QUuid const & ( ::SireFF::MolPotentialTable::*molUID_function_type )( ) const;
molUID_function_type molUID_function_value( &::SireFF::MolPotentialTable::molUID );
MolPotentialTable_exposer.def(
"molUID"
, molUID_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::MolPotentialTable::multiply
typedef void ( ::SireFF::MolPotentialTable::*multiply_function_type )( double ) ;
multiply_function_type multiply_function_value( &::SireFF::MolPotentialTable::multiply );
MolPotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::MolPotentialTable::nCutGroups
typedef int ( ::SireFF::MolPotentialTable::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireFF::MolPotentialTable::nCutGroups );
MolPotentialTable_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
{ //::SireFF::MolPotentialTable::nSelectedCutGroups
typedef int ( ::SireFF::MolPotentialTable::*nSelectedCutGroups_function_type )( ) const;
nSelectedCutGroups_function_type nSelectedCutGroups_function_value( &::SireFF::MolPotentialTable::nSelectedCutGroups );
MolPotentialTable_exposer.def(
"nSelectedCutGroups"
, nSelectedCutGroups_function_value );
}
MolPotentialTable_exposer.def( bp::self != bp::self );
MolPotentialTable_exposer.def( bp::self * bp::other< double >() );
MolPotentialTable_exposer.def( bp::self + bp::self );
MolPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
MolPotentialTable_exposer.def( bp::self - bp::self );
MolPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
MolPotentialTable_exposer.def( -bp::self );
MolPotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::MolPotentialTable::operator=
typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireFF::MolPotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
MolPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireFF::MolPotentialTable::operator=
typedef ::SireFF::MolPotentialTable & ( ::SireFF::MolPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::MolPotentialTable::operator= );
MolPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >() );
}
MolPotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::MolPotentialTable::selected
typedef bool ( ::SireFF::MolPotentialTable::*selected_function_type )( ::SireMol::CGIdx ) const;
selected_function_type selected_function_value( &::SireFF::MolPotentialTable::selected );
MolPotentialTable_exposer.def(
"selected"
, selected_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireFF::MolPotentialTable::selectedAll
typedef bool ( ::SireFF::MolPotentialTable::*selectedAll_function_type )( ) const;
selectedAll_function_type selectedAll_function_value( &::SireFF::MolPotentialTable::selectedAll );
MolPotentialTable_exposer.def(
"selectedAll"
, selectedAll_function_value );
}
{ //::SireFF::MolPotentialTable::setAll
typedef void ( ::SireFF::MolPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::MolPotentialTable::setAll );
MolPotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::CGAtomIdx const &,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("cgatomidx"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef bool ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireMol::AtomSelection const &,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("selected_atoms"), bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireFF::MolPotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::MolPotentialTable::subtract
typedef void ( ::SireFF::MolPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::MolPotentialTable::subtract );
MolPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::MolPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
MolPotentialTable_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireFF::MolPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::MolPotentialTable::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireFF::MolPotentialTable::toVector );
MolPotentialTable_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") ) );
}
{ //::SireFF::MolPotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::MolPotentialTable::typeName );
MolPotentialTable_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireFF::MolPotentialTable::what
typedef char const * ( ::SireFF::MolPotentialTable::*what_function_type )( ) const;
what_function_type what_function_value( &::SireFF::MolPotentialTable::what );
MolPotentialTable_exposer.def(
"what"
, what_function_value );
}
MolPotentialTable_exposer.staticmethod( "typeName" );
MolPotentialTable_exposer.def( "__copy__", &__copy__);
MolPotentialTable_exposer.def( "__deepcopy__", &__copy__);
MolPotentialTable_exposer.def( "clone", &__copy__);
MolPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::MolPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::MolPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
MolPotentialTable_exposer.def( "__str__", &__str__< ::SireFF::MolPotentialTable > );
MolPotentialTable_exposer.def( "__repr__", &__str__< ::SireFF::MolPotentialTable > );
MolPotentialTable_exposer.def( "__len__", &__len_size< ::SireFF::MolPotentialTable > );
}
}
void register_GridPotentialTable_class(){
{ //::SireFF::GridPotentialTable
typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t;
GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", "A GridPotentialTable contains the potentials at point specified by a grid", bp::init< >("Null constructor") );
bp::scope GridPotentialTable_scope( GridPotentialTable_exposer );
GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") ), "Construct to hold the potential at each of the points of the passed grid") );
GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") ), "Copy constructor") );
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("ipoint"), bp::arg("potential") )
, "Add the potential potential onto the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireFF::GridPotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") )
, "Add the potential in other onto that for this table - this only\nadds the potential if the two grids are identical" );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") )
, "Add the potential potential to all of the points in this table" );
}
{ //::SireFF::GridPotentialTable::at
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type)( int ) const;
at_function_type at_function_value( &::SireFF::GridPotentialTable::at );
GridPotentialTable_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "Return the potential value of the ith grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::count
typedef int ( ::SireFF::GridPotentialTable::*count_function_type)( ) const;
count_function_type count_function_value( &::SireFF::GridPotentialTable::count );
GridPotentialTable_exposer.def(
"count"
, count_function_value
, "Return the number of grid points (and thus potential values)" );
}
{ //::SireFF::GridPotentialTable::divide
typedef void ( ::SireFF::GridPotentialTable::*divide_function_type)( double ) ;
divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide );
GridPotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") )
, "Divide the potential at all of the points in this table by value" );
}
{ //::SireFF::GridPotentialTable::grid
typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type)( ) const;
grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid );
GridPotentialTable_exposer.def(
"grid"
, grid_function_value
, bp::return_value_policy<bp::clone_const_reference>()
, "Return the grid that contains the points at which the potential is\nevaluated - the order of points in the grid is the same as the order\nof potential values in this table" );
}
{ //::SireFF::GridPotentialTable::initialise
typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type)( ) ;
initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise );
GridPotentialTable_exposer.def(
"initialise"
, initialise_function_value
, "Initialise the potential at each grid point to equal 0" );
}
{ //::SireFF::GridPotentialTable::multiply
typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type)( double ) ;
multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply );
GridPotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") )
, "Multiply the potential at all of the points in this table by value" );
}
{ //::SireFF::GridPotentialTable::nPoints
typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type)( ) const;
nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints );
GridPotentialTable_exposer.def(
"nPoints"
, nPoints_function_value
, "Return the number of grid points (and thus potential values)" );
}
GridPotentialTable_exposer.def( bp::self != bp::self );
GridPotentialTable_exposer.def( bp::self * bp::other< double >() );
GridPotentialTable_exposer.def( bp::self + bp::self );
GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( bp::self - bp::self );
GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( -bp::self );
GridPotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireFF::GridPotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >()
, "" );
}
GridPotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) ;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_internal_reference< >()
, "" );
}
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type)( int ) const;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireFF::GridPotentialTable::setAll
typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll );
GridPotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") )
, "Set the potential at all of the points in this table equal to potential" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( int,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("ipoint"), bp::arg("potential") )
, "Subtract the potential potential from the potential for the ipointth grid point\nThrow: SireError::invalid_index\n" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireFF::GridPotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") )
, "Subtract the potential in other from that for this table - this only\nsubtracts the potential if the two grids are identical" );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type)( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") )
, "Subtract the potential potential from all of the points in this table" );
}
{ //::SireFF::GridPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type)( ) const;
toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector );
GridPotentialTable_exposer.def(
"toVector"
, toVector_function_value
, "Return the array of potential values - the order is the same\nas the order of points in the grid" );
}
{ //::SireFF::GridPotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName );
GridPotentialTable_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
GridPotentialTable_exposer.staticmethod( "typeName" );
GridPotentialTable_exposer.def( "__copy__", &__copy__);
GridPotentialTable_exposer.def( "__deepcopy__", &__copy__);
GridPotentialTable_exposer.def( "clone", &__copy__);
GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__str__", &pvt_get_name);
GridPotentialTable_exposer.def( "__repr__", &pvt_get_name);
GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > );
}
}
void register_ChunkedVector_double__class(){
{ //::SireBase::ChunkedVector< double, 100 >
typedef bp::class_< SireBase::ChunkedVector< double, 100 > > ChunkedVector_double__exposer_t;
ChunkedVector_double__exposer_t ChunkedVector_double__exposer = ChunkedVector_double__exposer_t( "ChunkedVector_double_", bp::init< >() );
bp::scope ChunkedVector_double__scope( ChunkedVector_double__exposer );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::const_iterator > const_iterator_exposer_t;
const_iterator_exposer_t const_iterator_exposer = const_iterator_exposer_t( "const_iterator", bp::init< >() );
bp::scope const_iterator_scope( const_iterator_exposer );
const_iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::const_iterator const & >(( bp::arg("other") )) );
const_iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::const_iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator & ( ::SireBase::ChunkedVector< double, 100 >::const_iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::const_iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::const_iterator::operator= );
const_iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
const_iterator_exposer.def( bp::self == bp::self );
}
{ //::SireBase::ChunkedVector< double, 100 >::iterator
typedef bp::class_< SireBase::ChunkedVector< double, 100 >::iterator > iterator_exposer_t;
iterator_exposer_t iterator_exposer = iterator_exposer_t( "iterator", bp::init< >() );
bp::scope iterator_scope( iterator_exposer );
iterator_exposer.def( bp::init< SireBase::ChunkedVector< double, 100 >::iterator const & >(( bp::arg("other") )) );
iterator_exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::iterator::operator=
typedef ::SireBase::ChunkedVector< double, 100 >::iterator & ( ::SireBase::ChunkedVector< double, 100 >::iterator::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 >::iterator const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::iterator::operator= );
iterator_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
iterator_exposer.def( bp::self == bp::self );
}
ChunkedVector_double__exposer.def( bp::init< int >(( bp::arg("size") )) );
ChunkedVector_double__exposer.def( bp::init< int, double const & >(( bp::arg("size"), bp::arg("value") )) );
ChunkedVector_double__exposer.def( bp::init< SireBase::ChunkedVector< double, 100 > const & >(( bp::arg("other") )) );
{ //::SireBase::ChunkedVector< double, 100 >::append
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*append_function_type )( double const & ) ;
append_function_type append_function_value( &::SireBase::ChunkedVector< double, 100 >::append );
ChunkedVector_double__exposer.def(
"append"
, append_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::at
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::ChunkedVector< double, 100 >::at );
ChunkedVector_double__exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) ;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::begin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*begin_function_type )( ) const;
begin_function_type begin_function_value( &::SireBase::ChunkedVector< double, 100 >::begin );
ChunkedVector_double__exposer.def(
"begin"
, begin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::capacity
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*capacity_function_type )( ) const;
capacity_function_type capacity_function_value( &::SireBase::ChunkedVector< double, 100 >::capacity );
ChunkedVector_double__exposer.def(
"capacity"
, capacity_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::clear
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::ChunkedVector< double, 100 >::clear );
ChunkedVector_double__exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constBegin
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constBegin_function_type )( ) const;
constBegin_function_type constBegin_function_value( &::SireBase::ChunkedVector< double, 100 >::constBegin );
ChunkedVector_double__exposer.def(
"constBegin"
, constBegin_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::constEnd
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*constEnd_function_type )( ) const;
constEnd_function_type constEnd_function_value( &::SireBase::ChunkedVector< double, 100 >::constEnd );
ChunkedVector_double__exposer.def(
"constEnd"
, constEnd_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::count
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*count_function_type )( double const & ) const;
count_function_type count_function_value( &::SireBase::ChunkedVector< double, 100 >::count );
ChunkedVector_double__exposer.def(
"count"
, count_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) ;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::end
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 >::const_iterator ( ::SireBase::ChunkedVector< double, 100 >::*end_function_type )( ) const;
end_function_type end_function_value( &::SireBase::ChunkedVector< double, 100 >::end );
ChunkedVector_double__exposer.def(
"end"
, end_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromList_function_type )( ::QList< double > const & );
fromList_function_type fromList_function_value( &::SireBase::ChunkedVector< double, 100 >::fromList );
ChunkedVector_double__exposer.def(
"fromList"
, fromList_function_value
, ( bp::arg("list") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromStdVector_function_type )( ::std::vector< double > const & );
fromStdVector_function_type fromStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromStdVector );
ChunkedVector_double__exposer.def(
"fromStdVector"
, fromStdVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::fromVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > ( *fromVector_function_type )( ::QVector< double > const & );
fromVector_function_type fromVector_function_value( &::SireBase::ChunkedVector< double, 100 >::fromVector );
ChunkedVector_double__exposer.def(
"fromVector"
, fromVector_function_value
, ( bp::arg("vector") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::isEmpty
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef bool ( ::SireBase::ChunkedVector< double, 100 >::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::ChunkedVector< double, 100 >::isEmpty );
ChunkedVector_double__exposer.def(
"isEmpty"
, isEmpty_function_value );
}
ChunkedVector_double__exposer.def( bp::self != bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator=
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::SireBase::ChunkedVector< double, 100 > & ( ::SireBase::ChunkedVector< double, 100 >::*assign_function_type )( ::SireBase::ChunkedVector< double, 100 > const & ) ;
assign_function_type assign_function_value( &::SireBase::ChunkedVector< double, 100 >::operator= );
ChunkedVector_double__exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
ChunkedVector_double__exposer.def( bp::self == bp::self );
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_non_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::operator[]
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double const & ( ::SireBase::ChunkedVector< double, 100 >::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::ChunkedVector< double, 100 >::operator[] );
ChunkedVector_double__exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::remove
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*remove_function_type )( int,int ) ;
remove_function_type remove_function_value( &::SireBase::ChunkedVector< double, 100 >::remove );
ChunkedVector_double__exposer.def(
"remove"
, remove_function_value
, ( bp::arg("i"), bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::reserve
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*reserve_function_type )( int ) ;
reserve_function_type reserve_function_value( &::SireBase::ChunkedVector< double, 100 >::reserve );
ChunkedVector_double__exposer.def(
"reserve"
, reserve_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::resize
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*resize_function_type )( int ) ;
resize_function_type resize_function_value( &::SireBase::ChunkedVector< double, 100 >::resize );
ChunkedVector_double__exposer.def(
"resize"
, resize_function_value
, ( bp::arg("count") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::size
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef int ( ::SireBase::ChunkedVector< double, 100 >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::ChunkedVector< double, 100 >::size );
ChunkedVector_double__exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::squeeze
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef void ( ::SireBase::ChunkedVector< double, 100 >::*squeeze_function_type )( ) ;
squeeze_function_type squeeze_function_value( &::SireBase::ChunkedVector< double, 100 >::squeeze );
ChunkedVector_double__exposer.def(
"squeeze"
, squeeze_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toList
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QList< double > ( ::SireBase::ChunkedVector< double, 100 >::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::ChunkedVector< double, 100 >::toList );
ChunkedVector_double__exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toStdVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::std::vector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toStdVector_function_type )( ) const;
toStdVector_function_type toStdVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toStdVector );
ChunkedVector_double__exposer.def(
"toStdVector"
, toStdVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::toVector
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef ::QVector< double > ( ::SireBase::ChunkedVector< double, 100 >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::ChunkedVector< double, 100 >::toVector );
ChunkedVector_double__exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::ChunkedVector< double, 100 >::value
typedef SireBase::ChunkedVector< double, 100 > exported_class_t;
typedef double ( ::SireBase::ChunkedVector< double, 100 >::*value_function_type )( int,double const & ) const;
value_function_type value_function_value( &::SireBase::ChunkedVector< double, 100 >::value );
ChunkedVector_double__exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
ChunkedVector_double__exposer.staticmethod( "fromList" );
ChunkedVector_double__exposer.staticmethod( "fromStdVector" );
ChunkedVector_double__exposer.staticmethod( "fromVector" );
ChunkedVector_double__exposer.def( "__copy__", &__copy__);
ChunkedVector_double__exposer.def( "__deepcopy__", &__copy__);
ChunkedVector_double__exposer.def( "clone", &__copy__);
ChunkedVector_double__exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::ChunkedVector<double, 100> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
ChunkedVector_double__exposer.def( "__str__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__repr__", &pvt_get_name);
ChunkedVector_double__exposer.def( "__len__", &__len_size< ::SireBase::ChunkedVector<double, 100> > );
}
}
void register_PropertyList_class(){
{ //::SireBase::PropertyList
typedef bp::class_< SireBase::PropertyList, bp::bases< SireBase::Property > > PropertyList_exposer_t;
PropertyList_exposer_t PropertyList_exposer = PropertyList_exposer_t( "PropertyList", bp::init< >() );
bp::scope PropertyList_scope( PropertyList_exposer );
PropertyList_exposer.def( bp::init< QList< SireBase::PropPtr< SireBase::Property > > const & >(( bp::arg("props") )) );
PropertyList_exposer.def( bp::init< SireBase::PropertyList const & >(( bp::arg("other") )) );
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::SireBase::Property const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("property") ) );
}
{ //::SireBase::PropertyList::append
typedef void ( ::SireBase::PropertyList::*append_function_type )( ::QList< SireBase::PropPtr< SireBase::Property > > const & ) ;
append_function_type append_function_value( &::SireBase::PropertyList::append );
PropertyList_exposer.def(
"append"
, append_function_value
, ( bp::arg("props") ) );
}
{ //::SireBase::PropertyList::array
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*array_function_type )( ) const;
array_function_type array_function_value( &::SireBase::PropertyList::array );
PropertyList_exposer.def(
"array"
, array_function_value );
}
{ //::SireBase::PropertyList::at
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireBase::PropertyList::at );
PropertyList_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::clear
typedef void ( ::SireBase::PropertyList::*clear_function_type )( ) ;
clear_function_type clear_function_value( &::SireBase::PropertyList::clear );
PropertyList_exposer.def(
"clear"
, clear_function_value );
}
{ //::SireBase::PropertyList::count
typedef int ( ::SireBase::PropertyList::*count_function_type )( ) const;
count_function_type count_function_value( &::SireBase::PropertyList::count );
PropertyList_exposer.def(
"count"
, count_function_value );
}
{ //::SireBase::PropertyList::empty
typedef bool ( ::SireBase::PropertyList::*empty_function_type )( ) const;
empty_function_type empty_function_value( &::SireBase::PropertyList::empty );
PropertyList_exposer.def(
"empty"
, empty_function_value );
}
{ //::SireBase::PropertyList::insert
typedef void ( ::SireBase::PropertyList::*insert_function_type )( int,::SireBase::Property const & ) ;
insert_function_type insert_function_value( &::SireBase::PropertyList::insert );
PropertyList_exposer.def(
"insert"
, insert_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::isEmpty
typedef bool ( ::SireBase::PropertyList::*isEmpty_function_type )( ) const;
isEmpty_function_type isEmpty_function_value( &::SireBase::PropertyList::isEmpty );
PropertyList_exposer.def(
"isEmpty"
, isEmpty_function_value );
}
{ //::SireBase::PropertyList::mid
typedef ::SireBase::PropertyList ( ::SireBase::PropertyList::*mid_function_type )( int,int ) const;
mid_function_type mid_function_value( &::SireBase::PropertyList::mid );
PropertyList_exposer.def(
"mid"
, mid_function_value
, ( bp::arg("pos"), bp::arg("length")=(int)(-0x00000000000000001) ) );
}
{ //::SireBase::PropertyList::move
typedef void ( ::SireBase::PropertyList::*move_function_type )( int,int ) ;
move_function_type move_function_value( &::SireBase::PropertyList::move );
PropertyList_exposer.def(
"move"
, move_function_value
, ( bp::arg("from"), bp::arg("to") ) );
}
PropertyList_exposer.def( bp::self != bp::self );
PropertyList_exposer.def( bp::self + bp::self );
{ //::SireBase::PropertyList::operator=
typedef ::SireBase::PropertyList & ( ::SireBase::PropertyList::*assign_function_type )( ::SireBase::PropertyList const & ) ;
assign_function_type assign_function_value( &::SireBase::PropertyList::operator= );
PropertyList_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
PropertyList_exposer.def( bp::self == bp::self );
{ //::SireBase::PropertyList::operator[]
typedef ::SireBase::Property const & ( ::SireBase::PropertyList::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireBase::PropertyList::operator[] );
PropertyList_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireBase::PropertyList::pop_back
typedef void ( ::SireBase::PropertyList::*pop_back_function_type )( ) ;
pop_back_function_type pop_back_function_value( &::SireBase::PropertyList::pop_back );
PropertyList_exposer.def(
"pop_back"
, pop_back_function_value );
}
{ //::SireBase::PropertyList::pop_front
typedef void ( ::SireBase::PropertyList::*pop_front_function_type )( ) ;
pop_front_function_type pop_front_function_value( &::SireBase::PropertyList::pop_front );
PropertyList_exposer.def(
"pop_front"
, pop_front_function_value );
}
{ //::SireBase::PropertyList::prepend
typedef void ( ::SireBase::PropertyList::*prepend_function_type )( ::SireBase::Property const & ) ;
prepend_function_type prepend_function_value( &::SireBase::PropertyList::prepend );
PropertyList_exposer.def(
"prepend"
, prepend_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_back
typedef void ( ::SireBase::PropertyList::*push_back_function_type )( ::SireBase::Property const & ) ;
push_back_function_type push_back_function_value( &::SireBase::PropertyList::push_back );
PropertyList_exposer.def(
"push_back"
, push_back_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::push_front
typedef void ( ::SireBase::PropertyList::*push_front_function_type )( ::SireBase::Property const & ) ;
push_front_function_type push_front_function_value( &::SireBase::PropertyList::push_front );
PropertyList_exposer.def(
"push_front"
, push_front_function_value
, ( bp::arg("value") ) );
}
{ //::SireBase::PropertyList::removeAt
typedef void ( ::SireBase::PropertyList::*removeAt_function_type )( int ) ;
removeAt_function_type removeAt_function_value( &::SireBase::PropertyList::removeAt );
PropertyList_exposer.def(
"removeAt"
, removeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::removeFirst
typedef void ( ::SireBase::PropertyList::*removeFirst_function_type )( ) ;
removeFirst_function_type removeFirst_function_value( &::SireBase::PropertyList::removeFirst );
PropertyList_exposer.def(
"removeFirst"
, removeFirst_function_value );
}
{ //::SireBase::PropertyList::removeLast
typedef void ( ::SireBase::PropertyList::*removeLast_function_type )( ) ;
removeLast_function_type removeLast_function_value( &::SireBase::PropertyList::removeLast );
PropertyList_exposer.def(
"removeLast"
, removeLast_function_value );
}
{ //::SireBase::PropertyList::replace
typedef void ( ::SireBase::PropertyList::*replace_function_type )( int,::SireBase::Property const & ) ;
replace_function_type replace_function_value( &::SireBase::PropertyList::replace );
PropertyList_exposer.def(
"replace"
, replace_function_value
, ( bp::arg("i"), bp::arg("value") ) );
}
{ //::SireBase::PropertyList::size
typedef int ( ::SireBase::PropertyList::*size_function_type )( ) const;
size_function_type size_function_value( &::SireBase::PropertyList::size );
PropertyList_exposer.def(
"size"
, size_function_value );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( ::SireBase::PropertyList & ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("other") ) );
}
{ //::SireBase::PropertyList::swap
typedef void ( ::SireBase::PropertyList::*swap_function_type )( int,int ) ;
swap_function_type swap_function_value( &::SireBase::PropertyList::swap );
PropertyList_exposer.def(
"swap"
, swap_function_value
, ( bp::arg("i"), bp::arg("j") ) );
}
{ //::SireBase::PropertyList::takeAt
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeAt_function_type )( int ) ;
takeAt_function_type takeAt_function_value( &::SireBase::PropertyList::takeAt );
PropertyList_exposer.def(
"takeAt"
, takeAt_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::takeFirst
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeFirst_function_type )( ) ;
takeFirst_function_type takeFirst_function_value( &::SireBase::PropertyList::takeFirst );
PropertyList_exposer.def(
"takeFirst"
, takeFirst_function_value );
}
{ //::SireBase::PropertyList::takeLast
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*takeLast_function_type )( ) ;
takeLast_function_type takeLast_function_value( &::SireBase::PropertyList::takeLast );
PropertyList_exposer.def(
"takeLast"
, takeLast_function_value );
}
{ //::SireBase::PropertyList::toList
typedef ::QList< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toList_function_type )( ) const;
toList_function_type toList_function_value( &::SireBase::PropertyList::toList );
PropertyList_exposer.def(
"toList"
, toList_function_value );
}
{ //::SireBase::PropertyList::toString
typedef ::QString ( ::SireBase::PropertyList::*toString_function_type )( ) const;
toString_function_type toString_function_value( &::SireBase::PropertyList::toString );
PropertyList_exposer.def(
"toString"
, toString_function_value );
}
{ //::SireBase::PropertyList::toVector
typedef ::QVector< SireBase::PropPtr< SireBase::Property > > ( ::SireBase::PropertyList::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireBase::PropertyList::toVector );
PropertyList_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireBase::PropertyList::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireBase::PropertyList::typeName );
PropertyList_exposer.def(
"typeName"
, typeName_function_value );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i") ) );
}
{ //::SireBase::PropertyList::value
typedef ::SireBase::PropertyPtr ( ::SireBase::PropertyList::*value_function_type )( int,::SireBase::Property const & ) const;
value_function_type value_function_value( &::SireBase::PropertyList::value );
PropertyList_exposer.def(
"value"
, value_function_value
, ( bp::arg("i"), bp::arg("default_value") ) );
}
PropertyList_exposer.staticmethod( "typeName" );
PropertyList_exposer.def( "__copy__", &__copy__);
PropertyList_exposer.def( "__deepcopy__", &__copy__);
PropertyList_exposer.def( "clone", &__copy__);
PropertyList_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireBase::PropertyList >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
PropertyList_exposer.def( "__str__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__repr__", &__str__< ::SireBase::PropertyList > );
PropertyList_exposer.def( "__len__", &__len_size< ::SireBase::PropertyList > );
}
}
void register_AtomFloatProperty_class(){
{ //::SireMol::AtomProperty< double >
typedef bp::class_< SireMol::AtomProperty< double >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomFloatProperty_exposer_t;
AtomFloatProperty_exposer_t AtomFloatProperty_exposer = AtomFloatProperty_exposer_t( "AtomFloatProperty", "", bp::init< >("") );
bp::scope AtomFloatProperty_scope( AtomFloatProperty_exposer );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::MoleculeInfoData const &, double const & >(( bp::arg("molinfo"), bp::arg("default_value") ), "") );
AtomFloatProperty_exposer.def( bp::init< double const & >(( bp::arg("value") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireBase::PackedArray2D< double > const & >(( bp::arg("values") ), "") );
AtomFloatProperty_exposer.def( bp::init< SireMol::AtomProperty< double > const & >(( bp::arg("other") ), "") );
{ //::SireMol::AtomProperty< double >::array
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double > const & ( ::SireMol::AtomProperty< double >::*array_function_type)( ) const;
array_function_type array_function_value( &::SireMol::AtomProperty< double >::array );
AtomFloatProperty_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::assertCanConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assertCanConvert_function_type)( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< double >::assertCanConvert );
AtomFloatProperty_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::assignFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*assignFrom_function_type)( ::SireMol::AtomProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< double >::assignFrom );
AtomFloatProperty_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGIdx ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::at
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*at_function_type)( ::SireMol::CGAtomIdx const & ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< double >::at );
AtomFloatProperty_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::canConvert
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*canConvert_function_type)( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< double >::canConvert );
AtomFloatProperty_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values") )
, "" );
}
{ //::SireMol::AtomProperty< double >::copyFrom
typedef SireMol::AtomProperty< double > exported_class_t;
typedef void ( ::SireMol::AtomProperty< double >::*copyFrom_function_type)( ::QVector< double > const &,::SireMol::AtomSelection const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< double >::copyFrom );
AtomFloatProperty_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values"), bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::count
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*count_function_type)( ) const;
count_function_type count_function_value( &::SireMol::AtomProperty< double >::count );
AtomFloatProperty_exposer.def(
"count"
, count_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::divide
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divide_function_type)( ::QVector< SireMol::AtomSelection > const & ) const;
divide_function_type divide_function_value( &::SireMol::AtomProperty< double >::divide );
AtomFloatProperty_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("beads") )
, "" );
}
{ //::SireMol::AtomProperty< double >::divideByResidue
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*divideByResidue_function_type)( ::SireMol::MoleculeInfoData const & ) const;
divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< double >::divideByResidue );
AtomFloatProperty_exposer.def(
"divideByResidue"
, divideByResidue_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::fromVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< double >::fromVariant );
AtomFloatProperty_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") )
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGIdx ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::get
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*get_function_type)( ::SireMol::CGAtomIdx const & ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< double >::get );
AtomFloatProperty_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isCompatibleWith
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isCompatibleWith_function_type)( ::SireMol::MoleculeInfo const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< double >::isCompatibleWith );
AtomFloatProperty_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::isEmpty
typedef SireMol::AtomProperty< double > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< double >::*isEmpty_function_type)( ) const;
isEmpty_function_type isEmpty_function_value( &::SireMol::AtomProperty< double >::isEmpty );
AtomFloatProperty_exposer.def(
"isEmpty"
, isEmpty_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::matchToSelection
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > ( ::SireMol::AtomProperty< double >::*matchToSelection_function_type)( ::SireMol::AtomSelection const & ) const;
matchToSelection_function_type matchToSelection_function_value( &::SireMol::AtomProperty< double >::matchToSelection );
AtomFloatProperty_exposer.def(
"matchToSelection"
, matchToSelection_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::merge
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< double >::*merge_function_type)( ::SireMol::MoleculeInfoData const & ) const;
merge_function_type merge_function_value( &::SireMol::AtomProperty< double >::merge );
AtomFloatProperty_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("molinfo") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::nAtoms
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nAtoms_function_type)( ::SireMol::CGIdx ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< double >::nAtoms );
AtomFloatProperty_exposer.def(
"nAtoms"
, nAtoms_function_value
, ( bp::arg("cgidx") )
, "" );
}
{ //::SireMol::AtomProperty< double >::nCutGroups
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*nCutGroups_function_type)( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< double >::nCutGroups );
AtomFloatProperty_exposer.def(
"nCutGroups"
, nCutGroups_function_value
, "" );
}
AtomFloatProperty_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomProperty< double >::operator=
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*assign_function_type)( ::SireMol::AtomProperty< double > const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomProperty< double >::operator= );
AtomFloatProperty_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >()
, "" );
}
AtomFloatProperty_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireBase::PackedArray2D< double >::Array const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGIdx ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::operator[]
typedef SireMol::AtomProperty< double > exported_class_t;
typedef double const & ( ::SireMol::AtomProperty< double >::*__getitem___function_type)( ::SireMol::CGAtomIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< double >::operator[] );
AtomFloatProperty_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGAtomIdx const &,double const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgatomidx"), bp::arg("value") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::set
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< double > & ( ::SireMol::AtomProperty< double >::*set_function_type)( ::SireMol::CGIdx,::QVector< double > const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< double >::set );
AtomFloatProperty_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("values") )
, bp::return_self< >()
, "" );
}
{ //::SireMol::AtomProperty< double >::size
typedef SireMol::AtomProperty< double > exported_class_t;
typedef int ( ::SireMol::AtomProperty< double >::*size_function_type)( ) const;
size_function_type size_function_value( &::SireMol::AtomProperty< double >::size );
AtomFloatProperty_exposer.def(
"size"
, size_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toString
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QString ( ::SireMol::AtomProperty< double >::*toString_function_type)( ) const;
toString_function_type toString_function_value( &::SireMol::AtomProperty< double >::toString );
AtomFloatProperty_exposer.def(
"toString"
, toString_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVariant
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< double >::*toVariant_function_type)( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< double >::toVariant );
AtomFloatProperty_exposer.def(
"toVariant"
, toVariant_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, "" );
}
{ //::SireMol::AtomProperty< double >::toVector
typedef SireMol::AtomProperty< double > exported_class_t;
typedef ::QVector< double > ( ::SireMol::AtomProperty< double >::*toVector_function_type)( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< double >::toVector );
AtomFloatProperty_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") )
, "" );
}
{ //::SireMol::AtomProperty< double >::typeName
typedef SireMol::AtomProperty< double > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomProperty< double >::typeName );
AtomFloatProperty_exposer.def(
"typeName"
, typeName_function_value
, "" );
}
AtomFloatProperty_exposer.staticmethod( "fromVariant" );
AtomFloatProperty_exposer.staticmethod( "typeName" );
AtomFloatProperty_exposer.def( "__copy__", &__copy__);
AtomFloatProperty_exposer.def( "__deepcopy__", &__copy__);
AtomFloatProperty_exposer.def( "clone", &__copy__);
AtomFloatProperty_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<double> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomFloatProperty_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<double> > );
AtomFloatProperty_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<double> > );
}
}
void register_GridPotentialTable_class(){
{ //::SireFF::GridPotentialTable
typedef bp::class_< SireFF::GridPotentialTable > GridPotentialTable_exposer_t;
GridPotentialTable_exposer_t GridPotentialTable_exposer = GridPotentialTable_exposer_t( "GridPotentialTable", bp::init< >() );
bp::scope GridPotentialTable_scope( GridPotentialTable_exposer );
GridPotentialTable_exposer.def( bp::init< SireVol::Grid const & >(( bp::arg("grid") )) );
GridPotentialTable_exposer.def( bp::init< SireFF::GridPotentialTable const & >(( bp::arg("other") )) );
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("ipoint"), bp::arg("potential") ) );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireFF::GridPotentialTable const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::GridPotentialTable::add
typedef void ( ::SireFF::GridPotentialTable::*add_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
add_function_type add_function_value( &::SireFF::GridPotentialTable::add );
GridPotentialTable_exposer.def(
"add"
, add_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::GridPotentialTable::at
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*at_function_type )( int ) const;
at_function_type at_function_value( &::SireFF::GridPotentialTable::at );
GridPotentialTable_exposer.def(
"at"
, at_function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::GridPotentialTable::count
typedef int ( ::SireFF::GridPotentialTable::*count_function_type )( ) const;
count_function_type count_function_value( &::SireFF::GridPotentialTable::count );
GridPotentialTable_exposer.def(
"count"
, count_function_value );
}
{ //::SireFF::GridPotentialTable::divide
typedef void ( ::SireFF::GridPotentialTable::*divide_function_type )( double ) ;
divide_function_type divide_function_value( &::SireFF::GridPotentialTable::divide );
GridPotentialTable_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::GridPotentialTable::grid
typedef ::SireVol::Grid const & ( ::SireFF::GridPotentialTable::*grid_function_type )( ) const;
grid_function_type grid_function_value( &::SireFF::GridPotentialTable::grid );
GridPotentialTable_exposer.def(
"grid"
, grid_function_value
, bp::return_value_policy<bp::clone_const_reference>() );
}
{ //::SireFF::GridPotentialTable::initialise
typedef void ( ::SireFF::GridPotentialTable::*initialise_function_type )( ) ;
initialise_function_type initialise_function_value( &::SireFF::GridPotentialTable::initialise );
GridPotentialTable_exposer.def(
"initialise"
, initialise_function_value );
}
{ //::SireFF::GridPotentialTable::multiply
typedef void ( ::SireFF::GridPotentialTable::*multiply_function_type )( double ) ;
multiply_function_type multiply_function_value( &::SireFF::GridPotentialTable::multiply );
GridPotentialTable_exposer.def(
"multiply"
, multiply_function_value
, ( bp::arg("value") ) );
}
{ //::SireFF::GridPotentialTable::nPoints
typedef int ( ::SireFF::GridPotentialTable::*nPoints_function_type )( ) const;
nPoints_function_type nPoints_function_value( &::SireFF::GridPotentialTable::nPoints );
GridPotentialTable_exposer.def(
"nPoints"
, nPoints_function_value );
}
GridPotentialTable_exposer.def( bp::self != bp::self );
GridPotentialTable_exposer.def( bp::self * bp::other< double >() );
GridPotentialTable_exposer.def( bp::self + bp::self );
GridPotentialTable_exposer.def( bp::self + bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( bp::self - bp::self );
GridPotentialTable_exposer.def( bp::self - bp::other< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > >() );
GridPotentialTable_exposer.def( -bp::self );
GridPotentialTable_exposer.def( bp::self / bp::other< double >() );
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireFF::GridPotentialTable const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
{ //::SireFF::GridPotentialTable::operator=
typedef ::SireFF::GridPotentialTable & ( ::SireFF::GridPotentialTable::*assign_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
assign_function_type assign_function_value( &::SireFF::GridPotentialTable::operator= );
GridPotentialTable_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("potential") )
, bp::return_self< >() );
}
GridPotentialTable_exposer.def( bp::self == bp::self );
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) ;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_internal_reference< >() );
}
{ //::SireFF::GridPotentialTable::operator[]
typedef ::SireUnits::Dimension::MolarEnergy const & ( ::SireFF::GridPotentialTable::*__getitem___function_type )( int ) const;
__getitem___function_type __getitem___function_value( &::SireFF::GridPotentialTable::operator[] );
GridPotentialTable_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("i") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireFF::GridPotentialTable::setAll
typedef void ( ::SireFF::GridPotentialTable::*setAll_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
setAll_function_type setAll_function_value( &::SireFF::GridPotentialTable::setAll );
GridPotentialTable_exposer.def(
"setAll"
, setAll_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( int,::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("ipoint"), bp::arg("potential") ) );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireFF::GridPotentialTable const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("other") ) );
}
{ //::SireFF::GridPotentialTable::subtract
typedef void ( ::SireFF::GridPotentialTable::*subtract_function_type )( ::SireUnits::Dimension::MolarEnergy const & ) ;
subtract_function_type subtract_function_value( &::SireFF::GridPotentialTable::subtract );
GridPotentialTable_exposer.def(
"subtract"
, subtract_function_value
, ( bp::arg("potential") ) );
}
{ //::SireFF::GridPotentialTable::toVector
typedef ::QVector< SireUnits::Dimension::PhysUnit< 1, 2, -2, 0, 0, -1, 0 > > ( ::SireFF::GridPotentialTable::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireFF::GridPotentialTable::toVector );
GridPotentialTable_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireFF::GridPotentialTable::typeName
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireFF::GridPotentialTable::typeName );
GridPotentialTable_exposer.def(
"typeName"
, typeName_function_value );
}
GridPotentialTable_exposer.staticmethod( "typeName" );
GridPotentialTable_exposer.def( "__copy__", &__copy__);
GridPotentialTable_exposer.def( "__deepcopy__", &__copy__);
GridPotentialTable_exposer.def( "clone", &__copy__);
GridPotentialTable_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireFF::GridPotentialTable >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
GridPotentialTable_exposer.def( "__str__", &pvt_get_name);
GridPotentialTable_exposer.def( "__repr__", &pvt_get_name);
GridPotentialTable_exposer.def( "__len__", &__len_count< ::SireFF::GridPotentialTable > );
}
}
void register_AtomCoords_class(){
{ //::SireMol::AtomProperty< SireMaths::Vector >
typedef bp::class_< SireMol::AtomProperty< SireMaths::Vector >, bp::bases< SireMol::AtomProp, SireMol::MolViewProperty, SireBase::Property > > AtomCoords_exposer_t;
AtomCoords_exposer_t AtomCoords_exposer = AtomCoords_exposer_t( "AtomCoords", bp::init< >() );
bp::scope AtomCoords_scope( AtomCoords_exposer );
AtomCoords_exposer.def( bp::init< SireMol::MoleculeInfoData const & >(( bp::arg("molinfo") )) );
AtomCoords_exposer.def( bp::init< SireVol::CoordGroup const & >(( bp::arg("cgroup") )) );
AtomCoords_exposer.def( bp::init< SireVol::CoordGroupArray const & >(( bp::arg("cgroups") )) );
AtomCoords_exposer.def( bp::init< SireMol::AtomProperty< SireMaths::Vector > const & >(( bp::arg("other") )) );
{ //::SireMol::AtomProperty< SireMaths::Vector >::array
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroupArray const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*array_function_type )( ) const;
array_function_type array_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::array );
AtomCoords_exposer.def(
"array"
, array_function_value
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assertCanConvert_function_type )( ::QVariant const & ) const;
assertCanConvert_function_type assertCanConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assertCanConvert );
AtomCoords_exposer.def(
"assertCanConvert"
, assertCanConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::assignFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*assignFrom_function_type )( ::SireMol::AtomProperty< QVariant > const & ) ;
assignFrom_function_type assignFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::assignFrom );
AtomCoords_exposer.def(
"assignFrom"
, assignFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::at
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGIdx ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
AtomCoords_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::at
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*at_function_type )( ::SireMol::CGAtomIdx const & ) const;
at_function_type at_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::at );
AtomCoords_exposer.def(
"at"
, at_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::canConvert
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*canConvert_function_type )( ::QVariant const & ) const;
canConvert_function_type canConvert_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::canConvert );
AtomCoords_exposer.def(
"canConvert"
, canConvert_function_value
, ( bp::arg("value") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
AtomCoords_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("from_frame"), bp::arg("to_frame") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::changeFrame
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*changeFrame_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const &,::SireMaths::AxisSet const & ) ;
changeFrame_function_type changeFrame_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::changeFrame );
AtomCoords_exposer.def(
"changeFrame"
, changeFrame_function_value
, ( bp::arg("cgidx"), bp::arg("from_frame"), bp::arg("to_frame") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
AtomCoords_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::copyFrom
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*copyFrom_function_type )( ::QVector< SireMaths::Vector > const &,::SireMol::AtomSelection const & ) ;
copyFrom_function_type copyFrom_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::copyFrom );
AtomCoords_exposer.def(
"copyFrom"
, copyFrom_function_value
, ( bp::arg("values"), bp::arg("selection") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::count
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*count_function_type )( ) const;
count_function_type count_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::count );
AtomCoords_exposer.def(
"count"
, count_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::divide
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divide_function_type )( ::QVector< SireMol::AtomSelection > const & ) const;
divide_function_type divide_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divide );
AtomCoords_exposer.def(
"divide"
, divide_function_value
, ( bp::arg("beads") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*divideByResidue_function_type )( ::SireMol::MoleculeInfoData const & ) const;
divideByResidue_function_type divideByResidue_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::divideByResidue );
AtomCoords_exposer.def(
"divideByResidue"
, divideByResidue_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::fromVariant
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > ( *fromVariant_function_type )( ::SireMol::AtomProperty< QVariant > const & );
fromVariant_function_type fromVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::fromVariant );
AtomCoords_exposer.def(
"fromVariant"
, fromVariant_function_value
, ( bp::arg("variant") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::get
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGIdx ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
AtomCoords_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::get
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*get_function_type )( ::SireMol::CGAtomIdx const & ) const;
get_function_type get_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::get );
AtomCoords_exposer.def(
"get"
, get_function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef bool ( ::SireMol::AtomProperty< SireMaths::Vector >::*isCompatibleWith_function_type )( ::SireMol::MoleculeInfoData const & ) const;
isCompatibleWith_function_type isCompatibleWith_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::isCompatibleWith );
AtomCoords_exposer.def(
"isCompatibleWith"
, isCompatibleWith_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
AtomCoords_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("axes") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::mapInto
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*mapInto_function_type )( ::SireMol::CGIdx,::SireMaths::AxisSet const & ) ;
mapInto_function_type mapInto_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::mapInto );
AtomCoords_exposer.def(
"mapInto"
, mapInto_function_value
, ( bp::arg("cgidx"), bp::arg("axes") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::merge
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireBase::PropertyPtr ( ::SireMol::AtomProperty< SireMaths::Vector >::*merge_function_type )( ::SireMol::MoleculeInfoData const & ) const;
merge_function_type merge_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::merge );
AtomCoords_exposer.def(
"merge"
, merge_function_value
, ( bp::arg("molinfo") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
AtomCoords_exposer.def(
"nAtoms"
, nAtoms_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nAtoms
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nAtoms_function_type )( ::SireMol::CGIdx ) const;
nAtoms_function_type nAtoms_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nAtoms );
AtomCoords_exposer.def(
"nAtoms"
, nAtoms_function_value
, ( bp::arg("cgidx") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*nCutGroups_function_type )( ) const;
nCutGroups_function_type nCutGroups_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::nCutGroups );
AtomCoords_exposer.def(
"nCutGroups"
, nCutGroups_function_value );
}
AtomCoords_exposer.def( bp::self != bp::self );
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator=
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*assign_function_type )( ::SireMol::AtomProperty< SireMaths::Vector > const & ) ;
assign_function_type assign_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator= );
AtomCoords_exposer.def(
"assign"
, assign_function_value
, ( bp::arg("other") )
, bp::return_self< >() );
}
AtomCoords_exposer.def( bp::self == bp::self );
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireVol::CoordGroup const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGIdx ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
AtomCoords_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::operator[]
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMaths::Vector const & ( ::SireMol::AtomProperty< SireMaths::Vector >::*__getitem___function_type )( ::SireMol::CGAtomIdx const & ) const;
__getitem___function_type __getitem___function_value( &::SireMol::AtomProperty< SireMaths::Vector >::operator[] );
AtomCoords_exposer.def(
"__getitem__"
, __getitem___function_value
, ( bp::arg("cgatomidx") )
, bp::return_value_policy< bp::copy_const_reference >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("quat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("rotmat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Quaternion const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("cgidx"), bp::arg("quat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::rotate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*rotate_function_type )( ::SireMol::CGIdx,::SireMaths::Matrix const &,::SireMaths::Vector const & ) ;
rotate_function_type rotate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::rotate );
AtomCoords_exposer.def(
"rotate"
, rotate_function_value
, ( bp::arg("cgidx"), bp::arg("rotmat"), bp::arg("point") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGAtomIdx const &,::SireMaths::Vector const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgatomidx"), bp::arg("value") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::QVector< SireMaths::Vector > const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("values") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::set
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< SireMaths::Vector > & ( ::SireMol::AtomProperty< SireMaths::Vector >::*set_function_type )( ::SireMol::CGIdx,::SireVol::CoordGroup const & ) ;
set_function_type set_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::set );
AtomCoords_exposer.def(
"set"
, set_function_value
, ( bp::arg("cgidx"), bp::arg("cgroup") )
, bp::return_self< >() );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::size
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef int ( ::SireMol::AtomProperty< SireMaths::Vector >::*size_function_type )( ) const;
size_function_type size_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::size );
AtomCoords_exposer.def(
"size"
, size_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVariant
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::SireMol::AtomProperty< QVariant > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVariant_function_type )( ) const;
toVariant_function_type toVariant_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVariant );
AtomCoords_exposer.def(
"toVariant"
, toVariant_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVector
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
AtomCoords_exposer.def(
"toVector"
, toVector_function_value );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::toVector
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef ::QVector< SireMaths::Vector > ( ::SireMol::AtomProperty< SireMaths::Vector >::*toVector_function_type )( ::SireMol::AtomSelection const & ) const;
toVector_function_type toVector_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::toVector );
AtomCoords_exposer.def(
"toVector"
, toVector_function_value
, ( bp::arg("selection") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::transform
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
AtomCoords_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("t") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::transform
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*transform_function_type )( ::SireMol::CGIdx,::SireMaths::Transform const & ) ;
transform_function_type transform_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::transform );
AtomCoords_exposer.def(
"transform"
, transform_function_value
, ( bp::arg("cgidx"), bp::arg("t") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::translate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
AtomCoords_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("delta") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::translate
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef void ( ::SireMol::AtomProperty< SireMaths::Vector >::*translate_function_type )( ::SireMol::CGIdx,::SireMaths::Vector const & ) ;
translate_function_type translate_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::translate );
AtomCoords_exposer.def(
"translate"
, translate_function_value
, ( bp::arg("cgidx"), bp::arg("delta") ) );
}
{ //::SireMol::AtomProperty< SireMaths::Vector >::typeName
typedef SireMol::AtomProperty< SireMaths::Vector > exported_class_t;
typedef char const * ( *typeName_function_type )( );
typeName_function_type typeName_function_value( &::SireMol::AtomProperty< SireMaths::Vector >::typeName );
AtomCoords_exposer.def(
"typeName"
, typeName_function_value );
}
AtomCoords_exposer.staticmethod( "fromVariant" );
AtomCoords_exposer.staticmethod( "typeName" );
AtomCoords_exposer.def( "__copy__", &__copy__);
AtomCoords_exposer.def( "__deepcopy__", &__copy__);
AtomCoords_exposer.def( "clone", &__copy__);
AtomCoords_exposer.def( "__rlshift__", &__rlshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomCoords_exposer.def( "__rrshift__", &__rrshift__QDataStream< ::SireMol::AtomProperty<SireMaths::Vector> >,
bp::return_internal_reference<1, bp::with_custodian_and_ward<1,2> >() );
AtomCoords_exposer.def( "__str__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
AtomCoords_exposer.def( "__repr__", &__str__< ::SireMol::AtomProperty<SireMaths::Vector> > );
AtomCoords_exposer.def( "__len__", &__len_size< ::SireMol::AtomProperty<SireMaths::Vector> > );
}
}
