From 6bf9d5c35a157c12aa688a2781f0eb246dff74ad Mon Sep 17 00:00:00 2001 From: vng Date: Mon, 17 Sep 2012 19:12:15 +0300 Subject: [PATCH] Remove useless header. --- 3party/boost/boost/atomic.hpp | 204 ---------------------------------- 1 file changed, 204 deletions(-) delete mode 100644 3party/boost/boost/atomic.hpp diff --git a/3party/boost/boost/atomic.hpp b/3party/boost/boost/atomic.hpp deleted file mode 100644 index b2086b9f72..0000000000 --- a/3party/boost/boost/atomic.hpp +++ /dev/null @@ -1,204 +0,0 @@ -#ifndef BOOST_ATOMIC_HPP -#define BOOST_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 - -#include -#include -#include -#include - -namespace boost { - -template -class atomic : public detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(T v) : super(v) {} -private: - atomic(const atomic &); - void operator=(const atomic &); -}; - - -template<> -class atomic : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic 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 : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic 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 -class atomic : private detail::atomic::internal_atomic { -public: - typedef detail::atomic::internal_atomic super; - - atomic() {} - explicit atomic(T * p) : super((intptr_t)p) {} - - T *load(memory_order order=memory_order_seq_cst) const volatile - { - return (T*)super::load(order); - } - void store(T *v, memory_order order=memory_order_seq_cst) volatile - { - super::store((intptr_t)v, order); - } - bool compare_exchange_strong( - T * &expected, - T * desired, - memory_order order=memory_order_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_order order=memory_order_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_order success_order, - memory_order 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_order success_order, - memory_order 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_order order=memory_order_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_order order=memory_order_seq_cst) volatile - { - return (T*)super::fetch_add(diff*sizeof(T), order); - } - T * fetch_sub(ptrdiff_t diff, memory_order order=memory_order_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 { -public: - typedef atomic super; - using super::is_lock_free; - - atomic_flag(bool initial_state) : super(initial_state?1:0) {} - atomic_flag() {} - - bool test_and_set(memory_order order=memory_order_seq_cst) - { - return super::exchange(1, order) != 0; - } - void clear(memory_order order=memory_order_seq_cst) - { - super::store(0, order); - } -}; - -typedef atomic atomic_char; -typedef atomic atomic_uchar; -typedef atomic atomic_schar; -typedef atomic atomic_uint8_t; -typedef atomic atomic_int8_t; -typedef atomic atomic_ushort; -typedef atomic atomic_short; -typedef atomic atomic_uint16_t; -typedef atomic atomic_int16_t; -typedef atomic atomic_uint; -typedef atomic atomic_int; -typedef atomic atomic_uint32_t; -typedef atomic atomic_int32_t; -typedef atomic atomic_ulong; -typedef atomic atomic_long; -typedef atomic atomic_uint64_t; -typedef atomic atomic_int64_t; -typedef atomic atomic_ullong; -typedef atomic atomic_llong; -typedef atomic atomic_address; -typedef atomic atomic_bool; - -static inline void atomic_thread_fence(memory_order order) -{ - detail::atomic::platform_atomic_thread_fence(order); -} - -} - -#endif