casacore::TableCache Class Reference

Cache of open tables. More...

#include <TableCache.h>

Public Member Functions
	TableCache ()
	Construct an empty cache of open tables. More...
	~TableCache ()
PlainTable *	operator() (const String &tableName) const
	Try to find a table with the given name in the cache. More...
void	define (const String &tableName, PlainTable *)
	Add an open table to the cache. More...
void	remove (const String &tableName)
	Remove an open table. More...
void	rename (const String &newName, const String &oldName)
	Rename an open table. More...
uInt	nAutoLocks ()
	Determine the number of locked tables opened with the AutoLock option (Locked table means locked for read and/or write). More...
void	relinquishAutoLocks (Bool all)
	Unlock locked tables opened with the AutoLock option. More...
Vector< String >	getTableNames () const
	Get the names of the tables in the cache. More...
Vector< String >	getLockedTables (FileLocker::LockType, int lockOption)
	Get the names of tables locked in this process. More...
void	flushTable (const String &tableName, Bool fsync, Bool recursive)
	Flush a possibly cached Table. More...
PlainTable *	lookCache (const String &name, int tableOption, const TableLock &tableInfo)
	Look in the cache if the table is already open. More...

Private Member Functions
	TableCache (const TableCache &)
	The copy constructor is forbidden. More...
TableCache &	operator= (const TableCache &)
	The assignment operator is forbidden. More...
PlainTable *	getTable (const String &tableName) const
	Get the table without doing a mutex lock (for operator()). More...

Private Attributes
std::map< String, void * >	tableMap_p
std::mutex	itsMutex

Detailed Description

Cache of open tables.

Intended use:

Internal

Review Status

Reviewed By:

UNKNOWN

Date Reviewed:

before2004/08/25

Etymology

TableCache represents a cache of open tables.

Synopsis

A TableCache object keeps track of the tables which have already been opened in a program. It maps the name of a table to its PlainTable object. In principle only one TableCache object (statically defined in class PlainTable) exists in a process. The cache is used to prevent a table from being opened more than once, which is not only a waste of space, but more importantly, may give rise to synchronization problems. Synchronization between the same table in multiple processes must be done by a locking mechanism.

TableCache is used by class Table and PlainTable. Before opening a table, Table will first look in the cache. Newly opened or created tables will be added to the cache. When a table is actually closed, it will be removed from the cache.

Motivation

When a RefTable is read back, it will also read back the table it references. However, that table may have been opened before and it is bad to have a table open more than once in the same program. The TableCache class catches this and will not reopen the table.

To Do

• Currently only PlainTables are taken into account. Maybe RefTables should be too.

Definition at line 94 of file TableCache.h.

Constructor & Destructor Documentation

casacore::TableCache::TableCache

(

)

Construct an empty cache of open tables.

casacore::TableCache::~TableCache

(

)

casacore::TableCache::TableCache ( const TableCache &  )

private

The copy constructor is forbidden.

Member Function Documentation

void casacore::TableCache::define	(	const String &	tableName,
		PlainTable *
	)

Add an open table to the cache.

void casacore::TableCache::flushTable	(	const String &	tableName,
		Bool	fsync,
		Bool	recursive
	)

Flush a possibly cached Table.

Vector<String> casacore::TableCache::getLockedTables	(	FileLocker::LockType	,
		int	lockOption
	)

Get the names of tables locked in this process.

By default all locked tables are given (note that a write lock implies a read lock), but it is possible to select on lock type FileLocker::Write and on option (TableLock::AutoLocking, TableLock::ReadLocking, or TableLock::PermanentLocking).

PlainTable* casacore::TableCache::getTable ( const String &  tableName ) const

private

Get the table without doing a mutex lock (for operator()).

Vector<String> casacore::TableCache::getTableNames

(

)

const

Get the names of the tables in the cache.

PlainTable* casacore::TableCache::lookCache	(	const String &	name,
		int	tableOption,
		const TableLock &	tableInfo
	)

Look in the cache if the table is already open.

If so, check if table option matches. If needed reopen the table for read/write and merge the lock options.

uInt casacore::TableCache::nAutoLocks

(

)

Determine the number of locked tables opened with the AutoLock option (Locked table means locked for read and/or write).

PlainTable* casacore::TableCache::operator()

(

const String &

tableName

)

const

Try to find a table with the given name in the cache.

Return a pointer to a table if found (thus if already open). Return a zero pointer if not found.

TableCache& casacore::TableCache::operator= ( const TableCache &  )

private

The assignment operator is forbidden.

void casacore::TableCache::relinquishAutoLocks

(

Bool

all

)

Unlock locked tables opened with the AutoLock option.

If all=True all such tables will be unlocked. If all=False only tables requested by another process will be unlocked.

void casacore::TableCache::remove

(

const String &

tableName

)

Remove an open table.

void casacore::TableCache::rename	(	const String &	newName,
		const String &	oldName
	)

Rename an open table.

If oldName is not in the cache, nothing will be done.

Member Data Documentation

std::mutex casacore::TableCache::itsMutex

mutableprivate

Definition at line 163 of file TableCache.h.

std::map<String,void*> casacore::TableCache::tableMap_p

private

Definition at line 161 of file TableCache.h.

---

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

• tables/Tables/TableCache.h