AtomicPtrCache.h

Go to the documentation of this file.

#ifndef DataFormats_Common_AtomicPtrCache_h
#define DataFormats_Common_AtomicPtrCache_h
// -*- C++ -*-
//
// Package:     DataFormats/Common
// Class  :     AtomicPtrCache
// 
//
// Original Author:  Chris Jones
//         Created:  Thu, 07 Nov 2013 00:50:40 GMT
//

// system include files
#include <atomic>
#include <memory>
// user include files

// forward declarations

namespace edm {
  template <typename T>
  class AtomicPtrCache
  {
    
  public:
    AtomicPtrCache();
    
    explicit AtomicPtrCache(T*);
    
    AtomicPtrCache(const AtomicPtrCache<T>&);
    AtomicPtrCache& operator=(const AtomicPtrCache<T>&);

    ~AtomicPtrCache();
    
    // ---------- const member functions ---------------------
    T const* operator->() const { return load();}
    T const& operator*() const {return *load(); }
    T const* load() const;

    bool isSet() const;
    bool set(std::unique_ptr<T> iNewValue) const;
    // ---------- static member functions --------------------
    
    // ---------- member functions ---------------------------
    T* operator->() { return load();}
    T& operator*() {return *load();}
    
    T* load();
    
    void reset();

    T* release();
    
  private:
    
    // ---------- member data --------------------------------
    mutable std::atomic<T*> m_data;
  };
  template<typename T>
  inline AtomicPtrCache<T>::AtomicPtrCache():m_data{nullptr} {}
  
  template<typename T>
  inline AtomicPtrCache<T>::AtomicPtrCache(T* iValue): m_data{iValue} {}
  
  template<typename T>
  inline AtomicPtrCache<T>::AtomicPtrCache(const AtomicPtrCache<T>& iOther):
  m_data{nullptr}
  {
    auto ptr = iOther.m_data.load(std::memory_order_acquire);
    if(ptr != nullptr) {
      m_data.store( new T{*ptr}, std::memory_order_release);
    }
  }
  template<typename T>
  inline AtomicPtrCache<T>& AtomicPtrCache<T>::operator=(const AtomicPtrCache<T>& iOther) {
    auto ptr = iOther.m_data.load(std::memory_order_acquire);
    if(ptr != nullptr) {
      auto ourPtr =m_data.load(std::memory_order_acquire);
      if( ourPtr !=nullptr) {
        *ourPtr = *ptr;
      } else {
        m_data.store( new T{*ptr}, std::memory_order_release);
      }
    } else {
      delete m_data.exchange(nullptr, std::memory_order_acq_rel);
    }
    return *this;
  }

  
  template<typename T>
  inline AtomicPtrCache<T>::~AtomicPtrCache(){
    delete m_data.load(std::memory_order_acquire);
  }
  
  template<typename T>
  inline T* AtomicPtrCache<T>::load(){ return m_data.load(std::memory_order_acquire);}

  template<typename T>
  inline T const* AtomicPtrCache<T>::load() const{ return m_data.load(std::memory_order_acquire);}
  
  template<typename T>
  inline bool AtomicPtrCache<T>::isSet() const { return nullptr!=m_data.load(std::memory_order_acquire);}

  template<typename T>
  inline bool AtomicPtrCache<T>::set(std::unique_ptr<T> iNewValue) const {
    bool retValue;
    T* expected = nullptr;
    if( (retValue = m_data.compare_exchange_strong(expected,iNewValue.get(), std::memory_order_acq_rel)) ) {
      iNewValue.release();
    }
    return retValue;
  }

  template<typename T>
  inline void AtomicPtrCache<T>::reset() { delete m_data.exchange(nullptr,std::memory_order_acq_rel);}

  template<typename T>
  inline T* AtomicPtrCache<T>::release() {
    T* tmp = m_data.exchange(nullptr);
    return tmp;
  }
}
#endif