---

at_atomic.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_atomic_h_x
#define x_at_atomic_h_x 1

#include "at_exports.h"
#include "at_os.h"

//
// AT_ATOMIC_H is defined in at_os.h and provides a platform specific
// header file name. (at_gx86_atomic.h or at_win32_atomic.h)
#include AT_ATOMIC_H

// Austria namespace
namespace at
{

// ======== AtomicCount ===============================================
class AUSTRIA_EXPORT AtomicCount
{

    volatile AtomicCountType                m_atomic_count;

public:

    // ======== AtomicCount ===========================================
    inline AtomicCount( AtomicCountType l_atomic_count = 0 )
      : m_atomic_count( l_atomic_count )
    {
    }


    // ======== operator ++() =========================================
    inline AtomicCountType operator ++()
    {
        return AtomicIncrement( & m_atomic_count ) + 1;
    }

    // ======== operator --() =========================================
    inline AtomicCountType operator --()
    {
        return AtomicDecrement( & m_atomic_count ) - 1;
    }
    

    // ======== operator ++(int) ======================================
    inline AtomicCountType operator ++(int)
    {
        return AtomicIncrement( & m_atomic_count );
    }

    
    // ======== operator --(int) ======================================
    inline AtomicCountType operator --(int)
    {
        return AtomicDecrement( & m_atomic_count );
    }


    // ======== Get ===================================================
    inline AtomicCountType Get() const
    {
        return m_atomic_count;
    }


    // ======== Bump ==================================================
    inline AtomicCountType Bump(
        AtomicCountType         i_add_val
    ) {
        return AtomicBump( & m_atomic_count, i_add_val );
    }


    // ======== Exchange ==============================================
    inline AtomicCountType Exchange(
        AtomicCountType         i_new_val
    ) {
        return AtomicExchange(
            & m_atomic_count,
            i_new_val
        );
    }


    // ======== CompareExchange =======================================
    inline AtomicCountType CompareExchange(
        AtomicCountType         i_new_val,
        AtomicCountType         i_compare_val
    ) {
        return AtomicCompareExchange(
            & m_atomic_count,
            i_new_val,
            i_compare_val
        );
    }

    
};


// ======== AtomicExchangePtr =========================================
template <typename w_type>
class AtomicExchange_Ptr
{
    volatile AtomicExchangeablePointer      m_data;
    public:


    // ======== AtomicExchange_Ptr ====================================
    AtomicExchange_Ptr( w_type i_init_val )
      : m_data( static_cast<w_type>( i_init_val ) )
    {
    }

    AtomicExchange_Ptr()
      : m_data( 0 )
    {
    }

    // ======== Get ===================================================
    inline w_type Get() const
    {
        return static_cast<w_type>( m_data );
    }

    // ======== Exchange =============================================
    inline w_type Exchange( w_type i_val )
    {
        return static_cast<w_type>(
            AtomicExchange(
                & m_data,
                static_cast<AtomicExchangeablePointer>( i_val )
            )
        );
    }

    // ======== CompareExchange =======================================
    inline w_type CompareExchange(
        w_type                  i_val,
        w_type                  i_compare
    ) {
        return static_cast<w_type>(
            AtomicCompareExchange(
                & m_data,
                static_cast<AtomicExchangeablePointer>( i_val ),
                static_cast<AtomicExchangeablePointer>( i_compare )
            )
        );
    }    
    
};

// ======== AtomicExchange_Val =========================================
template <typename w_type>
class AtomicExchange_Val
{
    volatile AtomicExchangeableValue        m_data;
    public:


    // ======== AtomicExchange_Val ====================================
    AtomicExchange_Val( w_type i_init_val )
      : m_data( AtomicExchangeableValue( i_init_val ) )
    {
    }

    AtomicExchange_Val()
      : m_data( 0 )
    {
    }

    // ======== Get ===================================================
    inline w_type Get() const
    {
        return m_data;
    }

    // ======== Exchange =============================================
    inline w_type Exchange( w_type i_val )
    {
        return w_type(
            AtomicExchange(
                & m_data,
                AtomicExchangeableValue( i_val )
            )
        );
    }
    
    // ======== CompareExchange =======================================
    inline w_type CompareExchange(
        w_type                  i_val,
        w_type                  i_compare
    ) {
        return w_type(
            AtomicCompareExchange(
                & m_data,
                AtomicExchangeableValue( i_val ),
                AtomicExchangeableValue( i_compare )
            )
        );
    }    
    
};

}; // namespace

#endif // x_at_atomic_h_x

Generated for Austria by and MakeXS at Sun Oct 24 17:35:34 PDT 2004