spl/threading/InterlockCounter.h

/* Ported to SPL, orignal attribution below. */
/* ---------------------------------------------------------------------------
   commonc++ - A C++ Common Class Library
   Copyright (C) 2005-2009  Mark A Lindner

   Ported from commonc++.

   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 Mass Ave, Cambridge, MA 02139, USA.
   ---------------------------------------------------------------------------
*/
#ifndef _interlockcount_h
#define _interlockcount_h

#include <spl/types.h>
#include <spl/Debug.h>

class InterlockCounter
{
private:
        volatile int32 _atomic;

public:

        InterlockCounter(int32 value = 0) throw();

        ~InterlockCounter() throw();

        InterlockCounter(const InterlockCounter& other) throw();

        InterlockCounter& operator =(const InterlockCounter& other) throw();

        int32 operator++() throw();

        int32 operator++(int) throw();

        int32 operator--() throw();

        int32 operator--(int) throw();

        int32 operator+=(int32 delta) throw();

        int32 operator-=(int32 delta) throw();

        int32 operator+(int32 delta) const throw();

        int32 operator-(int32 delta) const throw();

        int32 operator=(int32 value) throw();

        int32 Set(int32 value) throw();

        int32 Swap(int32 value) throw();

        inline bool operator >(int32 i) const
        {
                return Get() > i;
        }

        inline bool operator >=(int32 i) const
        {
                return Get() >= i;
        }

        inline bool operator <(int32 i) const
        {
                return Get() < i;
        }

        inline bool operator <=(int32 i) const
        {
                return Get() <= i;
        }

        inline bool operator !=(int32 i) const
        {
                return Get() != i;
        }

        int32 TestAndSet(int32 value, int32 comparand) throw();

        int32 Get() const throw();

        inline operator int32() const throw()
        { 
                return Get(); 
        }
};

inline void ValidateType(const InterlockCounter& i)
{
}

REGISTER_TYPEOF( 458, InterlockCounter );

#endif