DtAtomicScalar.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once

#include <vrvGraphicsUtils/DtAssert.h>

namespace makVrv
{
#if _WIN32
   template<class T> class DtAtomicScalar
   {

   public:

      DtAtomicScalar (const T &initial)
         : mField(initial)
      {   }

      DtAtomicScalar (const DtAtomicScalar<T> &cousin)
         : mField(cousin.mField)
      {   }

      DtAtomicScalar () 
      {   }

      void operator= (const DtAtomicScalar<T> &cousin)
      {
         mField = cousin.mField;
      }

      T get (void) const
      {
         return mField;
      }

      void set (const T &v)
      {
         mField = v;
      }   

      bool cas (const T &old, const T &nu)
      {
         if (sizeof(T)==2) {
            return _InterlockedCompareExchange16((SHORT*)&mField, static_cast<SHORT>(nu), static_cast<SHORT>(old)) == static_cast<SHORT>(old);
         } 
         else if (sizeof(T)==4) 
         {
            return _InterlockedCompareExchange((LONG*)&mField, static_cast<LONG>(nu), static_cast<LONG>(old)) == static_cast<LONG>(old);
         } 
         else if (sizeof(T)==8) {
            return _InterlockedCompareExchange64((LONGLONG*)&mField, static_cast<LONGLONG>(nu), static_cast<LONGLONG>(old)) == static_cast<LONGLONG>(old);
         } 
         else {
            ASSERT_PREDICATE(false&&"AtomicScalar::cas: Only 16, 32, and 64 bit scalars supported in win32.");
            return false;
         }
      }

      T operator++ (void)
      {
         if (sizeof(T)==2) {
            return _InterlockedIncrement16((SHORT*)&mField);
         } else if (sizeof(T)==4) {
            return InterlockedIncrement((LONG*)&mField);
         } else if (sizeof(T)==8) {
            return InterlockedIncrement64((LONGLONG*)&mField);
         } else {
            ASSERT_PREDICATE(false&&"AtomicScalar::operator++(prefix): Only 16, 32, and 64 bit scalars supported in win32.");
            return T(0);
         }
      }

      T operator-- (void)
      {
         if (sizeof(T)==2) {
            return InterlockedDecrement16((SHORT*)&mField);
         } else if (sizeof(T)==4) {
            return InterlockedDecrement((LONG*)&mField);
         } else if (sizeof(T)==8) {
            return InterlockedDecrement64((LONGLONG*)&mField);
         } else {
            ASSERT_PREDICATE(false&&"AtomicScalar::operator--(prefix): Only 16, 32, and 64 bit scalars supported in win32.");
            return T(0);
         }
      }

      T operator++ (int)
      {
         if (sizeof(T)==2) {
            return _InterlockedIncrement16((SHORT*)&mField)-1;
         } else if (sizeof(T)==4) {
            return InterlockedIncrement((LONG*)&mField)-1;
         } else if (sizeof(T)==8) {
            return InterlockedIncrement64((LONGLONG*)&mField)-1;
         } else {
            ASSERT_PREDICATE(false&&"AtomicScalar::operator++(postfix): Only 16, 32, and 64 bit scalars supported in win32.");
            return T(0);
         }
      }

      T operator-- (int)
      {
         if (sizeof(T)==2) {
            return InterlockedDecrement16((SHORT*)&mField)+1;
         } else if (sizeof(T)==4) {
            return InterlockedDecrement((LONG*)&mField)+1;
         } else if (sizeof(T)==8) {
            return InterlockedDecrement64((LONGLONG*)&mField)+1;
         } else {
            ASSERT_PREDICATE(false&&"AtomicScalar::operator--(postfix): Only 16, 32, and 64 bit scalars supported in win32.");
            return T(0);
         }
      }

      volatile T mField;

   };
#else
   template<class T> class DtAtomicScalar
   {

   public:

      DtAtomicScalar (const T &initial)
         : mField(initial)
      {   }

      DtAtomicScalar (const DtAtomicScalar<T> &cousin)
         : mField(cousin.mField)
      {   }

      DtAtomicScalar () 
      {   }

      void operator= (const DtAtomicScalar<T> &cousin)
      {
         mField = cousin.mField;
      }

      T get (void) const
      {
         return mField;
      }

      void set (const T &v)
      {
         mField = v; 
      }   

      bool cas (const T &old, const T &nu)
      {
         return __sync_bool_compare_and_swap (&mField, old, nu);
      }

      T operator++ (void)
      {
         __sync_add_and_fetch (&mField, 1);
      }

      T operator-- (void)
      {
         __sync_add_and_fetch (&mField, -1);
      }

      T operator++ (int)
      {
         __sync_fetch_and_add (&mField, 1);
      }

      T operator-- (int)
      {
         __sync_fetch_and_add (&mField, -1);
      }


      volatile T mField;

   };
#endif

}