atomic.hpp

Go to the documentation of this file.

#ifndef BOOST_ATOMIC_ATOMIC_HPP
#define BOOST_ATOMIC_ATOMIC_HPP

//  Copyright (c) 2009 Helge Bahmann
//
//  Distributed under the Boost Software License, Version 1.0.
//  See accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)

#include <cstddef>

#include "atomic/memory_order2.hpp"
#include "atomic/platform.hpp"
#include "atomic/detail/base.hpp"
#include "atomic/detail/integral-casts.hpp"

namespace boost_atomic {

template<typename T>
class atomic : public detail::atomic::internal_atomic<T> {
public:
        typedef detail::atomic::internal_atomic<T> super;
        
        atomic() {}
        explicit atomic(T v) : super(v) {}
private:
        atomic(const atomic &);
        void operator=(const atomic &);
};


template<>
class atomic<bool> : private detail::atomic::internal_atomic<bool> {
public:
        typedef detail::atomic::internal_atomic<bool> super;
        
        atomic() {}
        explicit atomic(bool v) : super(v) {}
        
        using super::load;
        using super::store;
        using super::compare_exchange_strong;
        using super::compare_exchange_weak;
        using super::exchange;
        using super::is_lock_free;
        
        operator bool(void) const volatile {return load();}
        bool operator=(bool v) volatile {store(v); return v;}   
private:
        atomic(const atomic &);
        void operator=(const atomic &);
};

template<>
class atomic<void *> : private detail::atomic::internal_atomic<void *, sizeof(void *), int> {
public:
        typedef detail::atomic::internal_atomic<void *, sizeof(void *), int> super;
        
        atomic() {}
        explicit atomic(void * p) : super(p) {}
        using super::load;
        using super::store;
        using super::compare_exchange_strong;
        using super::compare_exchange_weak;
        using super::exchange;
        using super::is_lock_free;
        
        operator void *(void) const volatile {return load();}
        void * operator=(void * v) volatile {store(v); return v;}
        
private:
        atomic(const atomic &);
        void * operator=(const atomic &);
};

/* FIXME: pointer arithmetic still missing */

template<typename T>
class atomic<T *> : private detail::atomic::internal_atomic<intptr_t> {
public:
        typedef detail::atomic::internal_atomic<intptr_t> super;
        
        atomic() {}
        explicit atomic(T * p) : super((intptr_t)p) {}
        
        T *load(memory_order2 order=memory_order2_seq_cst) const volatile
        {
                return (T*)super::load(order);
        }
        void store(T *v, memory_order2 order=memory_order2_seq_cst) volatile
        {
                super::store((intptr_t)v, order);
        }
        bool compare_exchange_strong(
                T * &expected,
                T * desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return compare_exchange_strong(expected, desired, order, detail::atomic::calculate_failure_order(order));
        }
        bool compare_exchange_weak(
                T * &expected,
                T *desired,
                memory_order2 order=memory_order2_seq_cst) volatile
        {
                return compare_exchange_weak(expected, desired, order, detail::atomic::calculate_failure_order(order));
        }
        bool compare_exchange_weak(
                T * &expected,
                T *desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                intptr_t expected_=(intptr_t)expected, desired_=(intptr_t)desired;
                bool success=super::compare_exchange_weak(expected_, desired_, success_order, failure_order);
                expected=(T*)expected_;
                return success;
        }
        bool compare_exchange_strong(
                T * &expected,
                T *desired,
                memory_order2 success_order,
                memory_order2 failure_order) volatile
        {
                intptr_t expected_=(intptr_t)expected, desired_=(intptr_t)desired;
                bool success=super::compare_exchange_strong(expected_, desired_, success_order, failure_order);
                expected=(T*)expected_;
                return success;
        }
        T *exchange(T * replacement, memory_order2 order=memory_order2_seq_cst) volatile
        {
                return (T*)super::exchange((intptr_t)replacement, order);
        }
        using super::is_lock_free;
        
        operator T *(void) const volatile {return load();}
        T * operator=(T * v) volatile {store(v); return v;}
        
        T * fetch_add(ptrdiff_t diff, memory_order2 order=memory_order2_seq_cst) volatile
        {
                return (T*)super::fetch_add(diff*sizeof(T), order);
        }
        T * fetch_sub(ptrdiff_t diff, memory_order2 order=memory_order2_seq_cst) volatile
        {
                return (T*)super::fetch_sub(diff*sizeof(T), order);
        }
        
        T *operator++(void) volatile {return fetch_add(1)+1;}
        T *operator++(int) volatile {return fetch_add(1);}
        T *operator--(void) volatile {return fetch_sub(1)-1;}
        T *operator--(int) volatile {return fetch_sub(1);}
private:
        atomic(const atomic &);
        T * operator=(const atomic &);
};

class atomic_flag : private atomic<int> {
public:
        typedef atomic<int> super;
        using super::is_lock_free;
        
        atomic_flag(bool initial_state) : super(initial_state?1:0) {}
        atomic_flag() {}
        
        bool test_and_set(memory_order2 order=memory_order2_seq_cst)
        {
                return super::exchange(1, order) != 0;
        }
        void clear(memory_order2 order=memory_order2_seq_cst)
        {
                super::store(0, order);
        }
};

typedef atomic<char> atomic_char;
typedef atomic<unsigned char> atomic_uchar;
typedef atomic<signed char> atomic_schar;
typedef atomic<uint8_t> atomic_uint8_t;
typedef atomic<int8_t> atomic_int8_t;
typedef atomic<unsigned short> atomic_ushort;
typedef atomic<short> atomic_short;
typedef atomic<uint16_t> atomic_uint16_t;
typedef atomic<int16_t> atomic_int16_t;
typedef atomic<unsigned int> atomic_uint;
typedef atomic<int> atomic_int;
typedef atomic<uint32_t> atomic_uint32_t;
typedef atomic<int32_t> atomic_int32_t;
typedef atomic<unsigned long> atomic_ulong;
typedef atomic<long> atomic_long;
typedef atomic<uint64_t> atomic_uint64_t;
typedef atomic<int64_t> atomic_int64_t;
typedef atomic<unsigned long long> atomic_ullong;
typedef atomic<long long> atomic_llong;
typedef atomic<void*> atomic_address;
typedef atomic<bool> atomic_bool;

static inline void atomic_thread_fence(memory_order2 order)
{
        detail::atomic::platform_atomic_thread_fence<memory_order2>(order);
}

}

#endif

---

rosatomic
Author(s): Josh Faust
autogenerated on Fri Jan 11 09:50:22 2013