the safe handler of the tabular databases More...

#include <agrum/learning/IDatabaseTable.h>

Inheritance diagram for gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe:

Collaboration diagram for gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe:

Public Member Functions
Constructors / Destructors
	HandlerSafe (const IDatabaseTable< T_DATA, ALLOC > &db)
	default constructor More...

	HandlerSafe (const HandlerSafe &h)
	copy constructor More...

	HandlerSafe (HandlerSafe &&h)
	move constructor More...

virtual	~HandlerSafe ()
	destructor More...

Operators
virtual HandlerSafe &	operator= (const HandlerSafe &)
	copy operator More...

virtual HandlerSafe &	operator= (const Handler &)
	copy operator More...

virtual HandlerSafe &	operator= (HandlerSafe &&)
	move operator More...

virtual HandlerSafe &	operator= (Handler &&)
	move operator More...

Operators
virtual Handler &	operator++ () final
	makes the operator point to the next row in the database More...

virtual Handler &	operator-- () final
	makes the operator point to the previous row in the database More...

virtual Handler &	operator+= (const std::size_t i) final
	advances the handler by i rows in the database More...

virtual Handler &	operator-= (const std::size_t i) final
	moves back the handler by i rows in the database More...

virtual bool	operator== (const Handler &handler) const final
	checks whether two handlers point to the same row in the database More...

virtual bool	operator!= (const Handler &handler) const final
	checks whether two handlers point to different rows in the database More...

virtual const_reference	operator* () const final
	returns the current row pointed to by the handler (unsafe version) More...

virtual const_pointer	operator-> () const final
	Dereferences the value pointed to by the handler (unsafe version) More...

Accessors / Modifiers
virtual std::size_t	size () const final
	returns the number of rows managed by the handler More...

virtual std::size_t	DBSize () const final
	returns the number of rows of the whole database More...

virtual const_reference	rowSafe () const final
	returns the current row pointed to by the handler (safe version) More...

virtual reference	rowSafe () final
	returns the current row pointed to by the handler (safe version) More...

virtual const_reference	row () const final
	returns the current row pointed to by the handler (unsafe version) More...

virtual reference	row () final
	returns the current row pointed to by the handler (unsafe version) More...

virtual void	nextRow () final
	makes the handler point to the next row, equivalent to operator++ More...

virtual std::size_t	numRow () const final
	the number of the current row (0 = the 1st row managed by the handler) More...

virtual bool	hasRows () const final
	indicates whether the handler has reached its end or not More...

virtual void	reset () final
	puts the handler to the beginning of the database's area it handles More...

virtual Handler	begin () const
	returns a new handler that points to the beginning of the database's area of the current handler More...

virtual Handler	end () const
	returns a new handler that points to the end of the database's area of the current handler More...

virtual void	setRange (std::size_t begin, std::size_t end) final
	sets the area in the database the handler will handle More...

virtual std::pair< std::size_t, std::size_t >	range () const final
	returns the current range of the handler [begin,end) More...

virtual const DBVector< std::string > &	variableNames () const final
	returns the names of the variables More...

virtual std::size_t	nbVariables () const final
	returns the number of variables (columns) of the database More...

virtual const IDatabaseTable< T_DATA, ALLOC > &	database () const
	returns a pointer on the database More...

Public Types
template<typename TX_DATA >
using	DBVector = std::vector< TX_DATA, ALLOC< TX_DATA > >

template<typename TX_DATA >
using	Row = DBRow< TX_DATA, ALLOC >

template<typename TX_DATA >
using	Matrix = std::vector< DBRow< TX_DATA, ALLOC >, ALLOC< DBRow< TX_DATA, ALLOC > > >


using	iterator_category = std::random_access_iterator_tag
	Types for STL compliance. More...

using	value_type = typename Handler::value_type
	Types for STL compliance. More...

using	reference = value_type &
	Types for STL compliance. More...

using	const_reference = const value_type &
	Types for STL compliance. More...

using	pointer = value_type *
	Types for STL compliance. More...

using	const_pointer = const value_type *
	Types for STL compliance. More...

using	difference_type = std::ptrdiff_t
	Types for STL compliance. More...

using	allocator_type = ALLOC< T_DATA >
	Types for STL compliance. More...


using	size_type = std::size_t
	Types for STL compliance. More...

Detailed Description

template<typename T_DATA, template< typename > class ALLOC = std::allocator>
class gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe

the safe handler of the tabular databases

The IDatabaseTable class is provided with two types of handlers: unsafe handlers and safe ones. Compared to the former, the safe handlers incur a small overhead during their creation. But safe handlers are informed by their associated database when the structure of this one changes, i.e., when the number of rows/columns changes or when rows are added/removed, whereas unsafe handlers are not aware of such changes. For databases that are not affected by this kind of change, unsafe handlers should be used instead of safe ones because they are slightly faster. Both types of handlers are designed to be created in parallel by several threads.

Here is an example of how to use this class, illustrated on handlers for a RawDatabaseTable:

// create the database
gum::learning::RawDatabaseTable<> database;
database.setVariableNames( std::vector<std::string> {"v1","v2","v3"} );
// add one row to the database
gum::learning::DBRow<gum::learning::DBCell>
  row( 3, gum::learning::DBCell(2) );
database.insertRow( row );
// create a handler.
typename gum::learning::RawDatabaseTable<>::HandlerSafe handler(database);
// by default, the handlers range over the whole database, which
// currently contains only one row
// here, we add 95 new rows into the database
for ( int i = 0; i < 95; ++i ) database.insertRow( row );
// due to the addition of the rows, the safe handler updates its range
// and its area is now [0,96)
std::cout << handler.size ();   // displays 96 (handler's range)
std::cout << handler.DBSize (); // displays 96 (database's size)
// change the range of rows handled by the DBHandler
std::cout << handler.setRange ( 1, 40 ); // now parses rows [1,40)
std::cout << handler.size ();   // displays 39: rows 1,...,39
std::cout << handler.DBSize (); // displays 96: database's size
std::cout << handler.numRow (); // displays 0: the handler currently
// points on the first row of its managed area [1,40)
// move the handler to the next row
handler.nextRow();
std::cout << handler.numRow (); // displays 1: the handler points now
// on the second row of its managed area. This corresponds to the third
// DBRow of the database since the range of handler is [1,40)
++handler; // move again to the next row
std::cout << handler.numRow (); // displays 2
handler += 4; // advances the pointer by 4 rows
std::cout << handler.numRow (); // displays 6
// get the DBRow pointed to by the handler: this is the 7th DBRow
// of the database
const auto& xrow7 = handler.row ();     // get the DBRow, unsafe version
const auto& yrow7 = handler.rowSafe (); // get the DBRow, safe version
const std::vector<gum::learning::DBCell>& xrow = xrow7.row ();
const double xweight = xrow27.weight ();
// another way to access the row
const auto& zrow7 = *handler; // get the DBRow, unsafe version
// check whether there exist other rows managed by the handler after
// the current row
bool has_rows = handler.hasRows (); // true: there remains 33 rows
// makes the handler point again on the 2nd row of the database
handler.reset (); // the handler points to the beginning of its area
std::cout << handler.numRow (); // displays 0: the handler currently
// points on the first row of its managed area [1,40)
// see the variables' names, i.e., the names of the database's columns
const auto& vars = handler.variableNames();
// parse all the rows managed
handler.reset ();
for ( auto end = handler.end (); handler != end; ++handler )
  std::cout << handler.row ().weight () << std::endl;
// another possibility:
for ( const auto& row : handler )
  std::cout << row.weight () << std::endl;

Definition at line 693 of file IDatabaseTable.h.

Member Typedef Documentation

◆ allocator_type

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::allocator_type = ALLOC< T_DATA >

Types for STL compliance.

Definition at line 704 of file IDatabaseTable.h.

◆ const_pointer

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::const_pointer = const value_type*

Types for STL compliance.

Definition at line 702 of file IDatabaseTable.h.

◆ const_reference

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::const_reference = const value_type&

Types for STL compliance.

Definition at line 700 of file IDatabaseTable.h.

◆ DBVector

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

template<typename TX_DATA >

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::DBVector = std::vector< TX_DATA, ALLOC< TX_DATA > >

inherited

Definition at line 390 of file IDatabaseTable.h.

◆ difference_type

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::difference_type = std::ptrdiff_t

Types for STL compliance.

Definition at line 703 of file IDatabaseTable.h.

◆ iterator_category

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::iterator_category = std::random_access_iterator_tag

Types for STL compliance.

Definition at line 697 of file IDatabaseTable.h.

◆ Matrix

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

template<typename TX_DATA >

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::Matrix = std::vector< DBRow< TX_DATA, ALLOC >, ALLOC< DBRow< TX_DATA, ALLOC > > >

inherited

Definition at line 397 of file IDatabaseTable.h.

◆ pointer

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::pointer = value_type*

Types for STL compliance.

Definition at line 701 of file IDatabaseTable.h.

◆ reference

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::reference = value_type&

Types for STL compliance.

Definition at line 699 of file IDatabaseTable.h.

◆ Row

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

template<typename TX_DATA >

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::Row = DBRow< TX_DATA, ALLOC >

inherited

Definition at line 393 of file IDatabaseTable.h.

◆ size_type

template<typename T_DATA , template< typename > class ALLOC = std::allocator>

using gum::learning::DBHandler< T_DATA, ALLOC >::size_type = std::size_t

inherited

Types for STL compliance.

Definition at line 131 of file DBHandler.h.

◆ value_type

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

using gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::value_type = typename Handler::value_type

Types for STL compliance.

Definition at line 698 of file IDatabaseTable.h.

Constructor & Destructor Documentation

◆ HandlerSafe() [1/3]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::HandlerSafe ( const IDatabaseTable< T_DATA, ALLOC > & db )

default constructor

Parameters

db	the database on which the handler will point to. By default, the range of the handler is the whole database.

◆ HandlerSafe() [2/3]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::HandlerSafe ( const HandlerSafe & h )

copy constructor

◆ HandlerSafe() [3/3]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::HandlerSafe ( HandlerSafe && h )

move constructor

◆ ~HandlerSafe()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::~HandlerSafe ( )

virtual

destructor

Member Function Documentation

◆ begin()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::begin ( ) const

virtualinherited

returns a new handler that points to the beginning of the database's area of the current handler

Warning: The handler returned manages precisely the same area as the handler on which begin() is called.

◆ database()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const IDatabaseTable< T_DATA, ALLOC >& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::database ( ) const

virtualinherited

returns a pointer on the database

Exceptions

NullElement is raised if the handler does not point toward any database.

◆ DBSize()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual std::size_t gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::DBSize ( ) const

finalvirtualinherited

returns the number of rows of the whole database

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ end()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::end ( ) const

virtualinherited

returns a new handler that points to the end of the database's area of the current handler

Warning: The handler returned manages precisely the same area as the handler on which end() is called.

◆ hasRows()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual bool gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::hasRows ( ) const

finalvirtualinherited

indicates whether the handler has reached its end or not

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ nbVariables()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual std::size_t gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::nbVariables ( ) const

finalvirtualinherited

returns the number of variables (columns) of the database

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ nextRow()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual void gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::nextRow ( )

finalvirtualinherited

makes the handler point to the next row, equivalent to operator++

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ numRow()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual std::size_t gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::numRow ( ) const

finalvirtualinherited

the number of the current row (0 = the 1st row managed by the handler)

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ operator!=()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual bool gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator!= ( const Handler & handler ) const

finalvirtualinherited

checks whether two handlers point to different rows in the database

◆ operator*()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const_reference gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator* ( ) const

finalvirtualinherited

returns the current row pointed to by the handler (unsafe version)

Warning: The method does not check whether the handler already points to the end of the area it manages. It is thus faster than method rowSafe () but, when you call it, you must be sure that the row actually exists, i.e., that the handler has not reached its end.

◆ operator++()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator++ ( )

finalvirtualinherited

makes the operator point to the next row in the database

if the pointer has already reached the end of the area managed by the handler, nothing happens. In particular, no exception is raised

◆ operator+=()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator+= ( const std::size_t i )

finalvirtualinherited

advances the handler by i rows in the database

if, applying this move would make the handler reach the end of the area managed by the handler, then the handler is kept at the end of the area, i.e., after the last element of the area.

◆ operator--()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator-- ( )

finalvirtualinherited

makes the operator point to the previous row in the database

if the pointer is already at the beginning of the area managed by the handler, nothing happens. In particular, no exception is raised

◆ operator-=()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual Handler& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator-= ( const std::size_t i )

finalvirtualinherited

moves back the handler by i rows in the database

if, applying this move would make the handler reach the beginning of the area managed by the handler, then the handler is kept at the beginning of the area, i.e., at the first element of the area.

◆ operator->()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const_pointer gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator-> ( ) const

finalvirtualinherited

Dereferences the value pointed to by the handler (unsafe version)

Warning: The method does not check whether the handler already points to the end of its area. It is thus faster than method rowSafe () but, when you call it, you must be sure that the row actually exists, i.e., that the handler has not reached its end.

◆ operator=() [1/4]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual HandlerSafe& gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::operator= ( const HandlerSafe & )

virtual

copy operator

◆ operator=() [2/4]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual HandlerSafe& gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::operator= ( const Handler & )

virtual

copy operator

Reimplemented from gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler.

◆ operator=() [3/4]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual HandlerSafe& gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::operator= ( HandlerSafe && )

virtual

move operator

◆ operator=() [4/4]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual HandlerSafe& gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe::operator= ( Handler && )

virtual

move operator

Reimplemented from gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler.

◆ operator==()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual bool gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::operator== ( const Handler & handler ) const

finalvirtualinherited

checks whether two handlers point to the same row in the database

◆ range()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual std::pair< std::size_t, std::size_t > gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::range ( ) const

finalvirtualinherited

returns the current range of the handler [begin,end)

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ reset()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual void gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::reset ( )

finalvirtualinherited

puts the handler to the beginning of the database's area it handles

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ row() [1/2]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const_reference gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::row ( ) const

finalvirtualinherited

returns the current row pointed to by the handler (unsafe version)

Warning: The method does not check whether the handler already points to the end of its area. It is thus faster than method rowSafe () but, when you call it, you must be sure that the row actually exists, i.e., that the handler has not reached its end.

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ row() [2/2]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual reference gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::row ( )

finalvirtualinherited

returns the current row pointed to by the handler (unsafe version)

Warning: The method does not check whether the handler already points to the end of its area. It is thus faster than method rowSafe () but, when you call it, you must be sure that the row actually exists, i.e., that the handler has not reached its end.

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ rowSafe() [1/2]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const_reference gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::rowSafe ( ) const

finalvirtualinherited

returns the current row pointed to by the handler (safe version)

Exceptions

OutOfBounds if the handler points to the end of its area

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ rowSafe() [2/2]

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual reference gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::rowSafe ( )

finalvirtualinherited

returns the current row pointed to by the handler (safe version)

Exceptions

OutOfBounds if the handler points to the end of its area

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ setRange()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual void gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::setRange	(	std::size_t	begin,
		std::size_t	end
	)

finalvirtualinherited

sets the area in the database the handler will handle

In addition to setting the area that will be parsed by the handler, this method makes the handler point to the beginning of the area.

Parameters

begin	the first row to be handled
end	the handler handles rows in interval [begin,end). Thus, the endth row is not included in the set of rows handled.

Warning: if begin is greater than end, these values are swapped.

Exceptions

NullElement	is raised if the handler does not point to any database
SizeError	is raised if end is greater than the number of rows of the database

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ size()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual std::size_t gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::size ( ) const

finalvirtualinherited

returns the number of rows managed by the handler

A handler needs not necessarily handle all the rows of the database. For instance, RecordCounters cut the database into several pieces and assign each piece to a handler. Then each handler is used in parallel to perform countings only on their subset of the database. The size reported by method "size" is therefore the number of rows managed by the handler. If you wish to retrieve the size of the whole database, then use method DBSize instead.

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

◆ variableNames()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>

virtual const DBVector< std::string >& gum::learning::IDatabaseTable< T_DATA, ALLOC >::Handler::variableNames ( ) const

finalvirtualinherited

returns the names of the variables

Implements gum::learning::DBHandler< T_DATA, ALLOC >.

The documentation for this class was generated from the following file:

agrum/learning/database/IDatabaseTable.h

Public Member Functions

Public Types

Detailed Description

template<typename T_DATA, template< typename > class ALLOC = std::allocator> class gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe

Member Typedef Documentation

◆ allocator_type

◆ const_pointer

◆ const_reference

◆ DBVector

◆ difference_type

◆ iterator_category

◆ Matrix

◆ pointer

◆ reference

◆ Row

◆ size_type

◆ value_type

Constructor & Destructor Documentation

◆ HandlerSafe() [1/3]

◆ HandlerSafe() [2/3]

◆ HandlerSafe() [3/3]

◆ ~HandlerSafe()

Member Function Documentation

◆ begin()

◆ database()

◆ DBSize()

◆ end()

◆ hasRows()

◆ nbVariables()

◆ nextRow()

◆ numRow()

◆ operator!=()

◆ operator*()

◆ operator++()

◆ operator+=()

◆ operator--()

◆ operator-=()

◆ operator->()

◆ operator=() [1/4]

◆ operator=() [2/4]

◆ operator=() [3/4]

◆ operator=() [4/4]

◆ operator==()

◆ range()

◆ reset()

◆ row() [1/2]

◆ row() [2/2]

◆ rowSafe() [1/2]

◆ rowSafe() [2/2]

◆ setRange()

◆ size()

◆ variableNames()

template<typename T_DATA, template< typename > class ALLOC = std::allocator>
class gum::learning::IDatabaseTable< T_DATA, ALLOC >::HandlerSafe