AtomicValueType.hpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
 *****************************************************************************
 * Project    : Zeus Base Library
 * Module     : AtomicValueType
 * Package    : Zeus.ZeusBase.System
 * Author     : Benjamin Hadorn
 * Date       : 27.12.2011
 * System     : Zeus-Framework
 *****************************************************************************
 * Licence:                                                                  *
 *   This library is free software; you can redistribute it and/or modify    *
 *   it under the terms of the GNU Lesser General Public License as          *
 *   published by the Free Software Foundation; either version               *
 *   2.1 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 Lesser General Public License for more details.                     *
 *                                                                           *
 *   You should have received a copy of the GNU Lesser General Public        *
 *   License along with this library; if not, write to the Free Software     *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
 *****************************************************************************/

/*****************************************************************************
 * Changes:
 *  27.12.2011 bha: created zeus 2.0
 *****************************************************************************/

#ifndef AtomicValueTypeHPP
#define AtomicValueTypeHPP

#include <zeusbase/System/ZObject.h>
#include <zeusbase/System/CriticalScopeLock.hpp>
#include <zeusbase/System/CriticalSection.h>

BEGIN_NAMESPACE_Zeus

/***************************************************************************/
/***************************************************************************/
template <class T> class TAtomicValueType : public TZObject
{
  public:
    TAtomicValueType();
    TAtomicValueType(T tValue);
    TAtomicValueType(const TAtomicValueType<T>& rValue);
    virtual ~TAtomicValueType();

    //Methods
    T addAndGet(T tValue);
    bool compareAndSet(T tExpectedValue, T tUpdate);
    T decrementAndGet();
    T divideAndGet(T tValue);
    bool equals(T tExpectedValue) const;
    const T getAndDecrement();
    const T getAndIncrement();
    T getValue();
    T getValue() const;
    T incrementAndGet();
    T multiplyAndGet(T tValue);
    void setValue(T tValue);

    //Operators
    TAtomicValueType<T>& operator+= (const T tValue);
    TAtomicValueType<T>& operator-= (const T tValue);
    TAtomicValueType<T>& operator*= (const T tValue);
    TAtomicValueType<T>& operator/= (const T tValue);
    TAtomicValueType<T>& operator = (const TAtomicValueType<T>& rInVal) { setValue(rInVal.getValue()); return *this;}
    inline TAtomicValueType<T>& operator = (T tValue) { setValue(tValue); return *this; }
    inline bool operator ==(const T tValue)const { return equals(tValue); }
    inline bool operator ==(const int iValue)const { return equals(T(iValue)); }
    inline bool operator !=(const T tValue)const { return !equals(tValue); }
    inline bool operator !=(const int iValue)const { return !equals(T(iValue)); }
    inline const T operator++() { return incrementAndGet(); }
    inline const T operator--() { return decrementAndGet(); }
    inline T operator++(int) { return getAndIncrement(); }
    inline T operator--(int) { return getAndDecrement(); }
    inline operator T() const { return getValue(); }

  protected:
    T m_tValue;
    TCriticalSection& m_rLock;

  private:

};


/****************************************************************************/
/****************************************************************************/
template <class T> inline TAtomicValueType<T>::TAtomicValueType()
 : TZObject(),
   m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)),
   m_tValue(T())
{}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>::TAtomicValueType(T tValue)
 : TZObject(),
   m_rLock(*new TCriticalSection(TCriticalSection::etRecursive)),
   m_tValue(tValue)
{
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>::TAtomicValueType(const TAtomicValueType<T>& rValue)
 : TZObject(),
   m_rLock(*new TCriticalSection(TCriticalSection::etRecursive))
{
  m_tValue = rValue.getValue();
}


/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>::~TAtomicValueType()
{
  m_rLock.release();
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline const T TAtomicValueType<T>::getAndDecrement()
{
  TCriticalScopeLock Lock(m_rLock);
  T tRetval = m_tValue;
  --m_tValue;
  return tRetval;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline const T TAtomicValueType<T>::getAndIncrement()
{
  TCriticalScopeLock Lock(m_rLock);
  T tRetval = m_tValue;
  ++m_tValue;
  return tRetval;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::getValue()
{
  TCriticalScopeLock Lock(m_rLock);
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::getValue() const
{
  TCriticalScopeLock Lock(m_rLock);
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::incrementAndGet()
{
  TCriticalScopeLock Lock(m_rLock);
  ++m_tValue;
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::decrementAndGet()
{
  TCriticalScopeLock Lock(m_rLock);
  --m_tValue;
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline bool TAtomicValueType<T>::compareAndSet(T tExpectedValue, T tUpdate)
{
  TCriticalScopeLock Lock(m_rLock);
  bool bRetval = (m_tValue == tExpectedValue);
  if (bRetval)
  {
    m_tValue = tUpdate;
  }
  return bRetval;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline bool TAtomicValueType<T>::equals(T tExpectedValue) const
{
  TCriticalScopeLock Lock(m_rLock);
  return (m_tValue == tExpectedValue);
}


/**************************************************************************/
/**************************************************************************/
template <class T> inline void TAtomicValueType<T>::setValue(T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue = tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::addAndGet(T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue += tValue;
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::multiplyAndGet(T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue *= tValue;
  return m_tValue;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline T TAtomicValueType<T>::divideAndGet(T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue /= tValue;
  return m_tValue;
}


// OPERATORS
/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>& TAtomicValueType<T>::operator+= (const T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue += tValue;
  return *this;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>& TAtomicValueType<T>::operator-= (const T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue -= tValue;
  return *this;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>& TAtomicValueType<T>::operator*= (const T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue *= tValue;
  return *this;
}

/**************************************************************************/
/**************************************************************************/
template <class T> inline TAtomicValueType<T>& TAtomicValueType<T>::operator/= (const T tValue)
{
  TCriticalScopeLock Lock(m_rLock);
  m_tValue /= tValue;
  return *this;
}


END_NAMESPACE_Zeus

#endif