Loading...
Searching...
No Matches
TableLock.h
Go to the documentation of this file.
//# TableLock.h: Class to hold table lock options
//# Copyright (C) 1997,1998,2000,2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//# Internet email: casa-feedback@nrao.edu.
//# Postal address: AIPS++ Project Office
//# National Radio Astronomy Observatory
//# 520 Edgemont Road
//# Charlottesville, VA 22903-2475 USA
#ifndef TABLES_TABLELOCK_H
#define TABLES_TABLELOCK_H
//# Includes
#include <casacore/casa/aips.h>
#include <casacore/casa/IO/LockFile.h>
namespace casacore { //# NAMESPACE CASACORE - BEGIN
// <summary>
// Class to hold table lock options.
// </summary>
// <use visibility=local>
// <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="tTable" demos="">
// </reviewed>
// <prerequisite>
// <li> class <linkto class=Table>Table</linkto>
// <li> class <linkto class=LockFile>LockFile</linkto>
// </prerequisite>
// <synopsis>
// This class keeps the Table lock options.
// Currently these are the LockingOption and the inspection interval.
// <p>
// It also keeps the <src>LockFile</src> object used to do the
// actual locking/unlocking.
//
// It is possible to disable locking by building casacore with -DAIPS_TABLE_NOLOCKING
// or by setting the aipsrc variable table.nolocking=true.
// <motivation>
// Encapsulate Table locking info.
// </motivation>
class TableLock
{
public:
// Define the possible table locking options.
// They offer the user the possibility to lock and synchronize access
// to the table. A lot of locking degrades table performance; not only
// because acquiring/releasing locks takes time, but especially
// because table data has to be synchronized (thus written to disk)
// when a lock is released. Otherwise the other processes see data
// which is not up-to-date.
//
// Building Casacore with -DTABLE_NOLOCKING or setting aipsrc variable
// table.nolocking=1 forces lock option NoLocking.
enum LockOption {
// The table is permanently locked.
// A lock is set at the beginning and only released when
// the table is closed. A read lock is used when the table is
// opened for readonly; otherwise a write lock is used.
// This means that multiple readers are possible.
// The Table constructor exits with an exception when the
// lock cannot be acquired.
PermanentLocking,
// The same as above, but the table constructor waits
// until the lock gets available.
PermanentLockingWait,
// The system takes care of acquiring/releasing locks.
// In principle it keeps the table locked, but from time to
// time (defined by the inspection interval) it is checked whether
// another process wants to access the table. If so, the lock
// is released and probably re-acquired later.
// This mode is the default mode.
AutoLocking,
// The user is taking care of locking the table by means
// of the Table functions <src>lock</src> and <src>unlock</src>.
// In this way transaction processing can be implemented.
UserLocking,
// The system takes care of acquiring/releasing locks.
// It is similar to AutoLocking, but no locks are needed for
// reading.
AutoNoReadLocking,
// The user is taking care of locking the table by means
// of the Table functions <src>lock</src> and <src>unlock</src>.
// It is similar to UserLocking, but no locks are needed for
// reading.
UserNoReadLocking,
// Do not do any locking at all. This should be used with care
// because concurrent access might result in table corruption.
NoLocking,
// This is the default locking option.
// It means that AutoLocking will be used if the table is not
// opened yet. Otherwise the locking options of the PlainTable
// object already in use will be used.
DefaultLocking
};
// Construct with given option and interval.
// The default <src>LockOption</src> is <src>AutoLocking</src>.
// In case of AutloLocking the inspection interval defines how often
// the table system checks if another process needs a lock on the table.
// It defaults to 5 seconds.
// The maxWait defines the maximum number of seconds the table system
// waits when acquiring a lock in AutoLocking mode. The default
// is 0 seconds meaning indefinitely.
// <group>
TableLock (LockOption option = DefaultLocking);
TableLock (LockOption option, double inspectionInterval, uInt maxWait = 0);
// </group>
// Copy constructor.
TableLock (const TableLock& that);
// Assignment.
TableLock& operator= (const TableLock& that);
// Merge that TableLock with this TableLock object by taking the
// maximum option and minimum inspection interval.
// The option order (ascending) is UserLocking, AutoLocking,
// PermanentLocking.
// When an interval was defaulted, it is not taken into account.
// An option DefaultLocking is not taken into account.
void merge (const TableLock& that);
// Get the locking option.
LockOption option() const;
// Is read locking needed?
Bool readLocking() const;
// Is permanent locking used?
Bool isPermanent() const;
// Get the inspection interval.
double interval() const;
// Get the maximum wait period in AutoLocking mode.
uInt maxWait() const;
// Is table locking disabled (because AIPS_TABLE_NOLOCKING or table.nolocking is set)?
static Bool lockingDisabled();
private:
LockOption itsOption;
Bool itsReadLocking;
uInt itsMaxWait;
double itsInterval;
Bool itsIsDefaultLocking;
Bool itsIsDefaultInterval;
// Set itsOption and itsReadLocking when needed.
void init();
};
inline TableLock::LockOption TableLock::option() const
{
return itsOption;
}
inline Bool TableLock::readLocking() const
{
return itsReadLocking;
}
inline Bool TableLock::isPermanent() const
{
return (itsOption == PermanentLocking
|| itsOption == PermanentLockingWait);
}
inline double TableLock::interval() const
{
return itsInterval;
}
inline uInt TableLock::maxWait() const
{
return itsMaxWait;
}
} //# NAMESPACE CASACORE - END
#endif
casacore::TableLock::TableLock
TableLock(LockOption option, double inspectionInterval, uInt maxWait=0)
casacore::TableLock::LockOption
LockOption
Define the possible table locking options.
Definition TableLock.h:79
casacore::TableLock::UserLocking
@ UserLocking
The user is taking care of locking the table by means of the Table functions lock and unlock.
Definition TableLock.h:101
casacore::TableLock::AutoLocking
@ AutoLocking
The system takes care of acquiring/releasing locks.
Definition TableLock.h:97
casacore::TableLock::AutoNoReadLocking
@ AutoNoReadLocking
The system takes care of acquiring/releasing locks.
Definition TableLock.h:105
casacore::TableLock::DefaultLocking
@ DefaultLocking
This is the default locking option.
Definition TableLock.h:118
casacore::TableLock::UserNoReadLocking
@ UserNoReadLocking
The user is taking care of locking the table by means of the Table functions lock and unlock.
Definition TableLock.h:110
casacore::TableLock::PermanentLocking
@ PermanentLocking
The table is permanently locked.
Definition TableLock.h:87
casacore::TableLock::NoLocking
@ NoLocking
Do not do any locking at all.
Definition TableLock.h:113
casacore::TableLock::PermanentLockingWait
@ PermanentLockingWait
The same as above, but the table constructor waits until the lock gets available.
Definition TableLock.h:90
casacore::TableLock::isPermanent
Bool isPermanent() const
Is permanent locking used?
Definition TableLock.h:192
casacore::TableLock::init
void init()
Set itsOption and itsReadLocking when needed.
casacore::TableLock::TableLock
TableLock(LockOption option=DefaultLocking)
Construct with given option and interval.
casacore::TableLock::readLocking
Bool readLocking() const
Is read locking needed?
Definition TableLock.h:187
casacore::TableLock::itsInterval
double itsInterval
Definition TableLock.h:171
casacore::TableLock::itsOption
LockOption itsOption
Definition TableLock.h:168
casacore::TableLock::operator=
TableLock & operator=(const TableLock &that)
Assignment.
casacore::TableLock::lockingDisabled
static Bool lockingDisabled()
Is table locking disabled (because AIPS_TABLE_NOLOCKING or table.nolocking is set)?
casacore::TableLock::interval
double interval() const
Get the inspection interval.
Definition TableLock.h:198
casacore::TableLock::maxWait
uInt maxWait() const
Get the maximum wait period in AutoLocking mode.
Definition TableLock.h:203
casacore::TableLock::itsIsDefaultInterval
Bool itsIsDefaultInterval
Definition TableLock.h:173
casacore::TableLock::itsIsDefaultLocking
Bool itsIsDefaultLocking
Definition TableLock.h:172
casacore::TableLock::itsMaxWait
uInt itsMaxWait
Definition TableLock.h:170
casacore::TableLock::itsReadLocking
Bool itsReadLocking
Definition TableLock.h:169
casacore::TableLock::TableLock
TableLock(const TableLock &that)
Copy constructor.
casacore::TableLock::merge
void merge(const TableLock &that)
Merge that TableLock with this TableLock object by taking the maximum option and minimum inspection i...
casacore::TableLock::option
LockOption option() const
Get the locking option.
Definition TableLock.h:182
casacore
this file contains all the compiler specific defines
Definition mainpage.dox:28
casacore::uInt
unsigned int uInt
Definition aipstype.h:49
casacore::Bool
bool Bool
Define the standard types used by Casacore.
Definition aipstype.h:40