CyclicPtr.h

Go to the documentation of this file.

#ifndef CYCLIC_PTR_H_
#define CYCLIC_PTR_H_
 
#include <atomic>
#include <memory>
 
namespace casacore::details {
 
template<typename T>
class CyclicPtr;

class CyclicState {
public:
  ~CyclicState() noexcept = default;
 
private:
  CyclicState() = delete;
  constexpr CyclicState(unsigned value) noexcept : value_(value)
  {}
  template<typename T>
  friend class CyclicPtr;
 
  unsigned value_;
};

template<typename T>
class CyclicPtr {
public:
 
  CyclicPtr() = default;
 
  CyclicPtr(std::nullptr_t) {}
 
  explicit CyclicPtr(T* object) : data_(std::make_shared<Data>(object))
  {}
 
  CyclicPtr(const CyclicPtr& source) : data_(source.data_)
  {
    Increase();
  }
 
  CyclicPtr(CyclicPtr&& source) : data_(std::move(source.data_))
  {}
 
  ~CyclicPtr() {
    Decrease();
  }
 
  T* Get() const {
    return (data_ && data_->object_) ? data_->object_ : nullptr;
  }
 
  void Reset() {
    Decrease();
    data_.reset();
  }
 
  CyclicPtr& operator=(const CyclicPtr& other) {
    Decrease();
    data_ = other.data_;
    Increase();
    return *this;
  }
 
  CyclicPtr& operator=(CyclicPtr&& other) {
    Decrease();
    data_ = std::move(other.data_);
    return *this;
  }
 
  explicit operator bool() const { return data_ && data_->object_; }
 
  T& operator*() const { return *data_->object_; }
  T* operator->() const { return data_->object_; }
 
  friend bool operator==(const CyclicPtr<T>& lhs, const CyclicPtr<T>& rhs) {
    return lhs.data_ == rhs.data_;
  }
 
  friend bool operator!=(const CyclicPtr<T>& lhs, const CyclicPtr<T>& rhs) {
    return lhs.data_ != rhs.data_;
  }

  [[nodiscard]] CyclicState Freeze() const {
    return CyclicState(data_ ? data_->counter_.fetch_add(1) : 0);
  }

  void Unfreeze(const CyclicState& frozen_state) {
    if(data_)
      data_->counter_.store(frozen_state.value_);
  }
 
private:
  struct Data {
    Data(T* object) : object_(object)
    {}
 
    T* object_ = nullptr;
    std::atomic<unsigned> counter_ = 1;
  };
 
  void Increase() {
    if(data_ && data_->object_) {
      ++(data_->counter_);
    }
  }
 
  void Decrease() {
    if(data_ && data_->object_) {
      const unsigned previous_value = data_->counter_.fetch_sub(1);
      if(previous_value == 1) {
        delete data_->object_;
        data_->object_ = nullptr;
      }
    }
  }
 
  std::shared_ptr<Data> data_;
};
 
template<typename T, typename... Args>
CyclicPtr<T> MakeCyclic(Args&&... args) {
  return CyclicPtr<T>(new T(std::forward<Args>(args)...));
}
 
} // namespace casacore::details
 
#endif