cow_ptr.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MultiThreaded.h"
 
#ifndef Q_MOC_RUN
#include <memory>
#endif
 
#include <mutex>
#include <vector>
 
namespace Mantid {
namespace Kernel {
template <typename DataType> class cow_ptr {
public:
  using ptr_type = std::shared_ptr<DataType>; 
  using value_type = DataType;                
 
private:
  ptr_type Data; 
  std::mutex copyMutex;
 
public:
  cow_ptr(ptr_type &&resourceSptr) noexcept;
  cow_ptr(const ptr_type &resourceSptr) noexcept;
  explicit cow_ptr(DataType *resourcePtr);
  cow_ptr();
  constexpr cow_ptr(std::nullptr_t) noexcept : Data(nullptr) {}
  cow_ptr(const cow_ptr<DataType> &) noexcept;
  // Move is hand-written, since std::mutex member prevents auto-generation.
  cow_ptr(cow_ptr<DataType> &&other) noexcept : Data(std::move(other.Data)) {}
  cow_ptr<DataType> &operator=(const cow_ptr<DataType> &) noexcept;
  // Move is hand-written, since std::mutex member prevents auto-generation.
  cow_ptr<DataType> &operator=(cow_ptr<DataType> &&rhs) noexcept {
    Data = std::move(rhs.Data);
    return *this;
  }
  cow_ptr<DataType> &operator=(const ptr_type &) noexcept;
 
  const DataType *get() const noexcept { return Data.get(); }
 
  explicit operator bool() const noexcept { return bool(Data); }
 
  long use_count() const noexcept { return Data.use_count(); }
 
  bool unique() const noexcept { return Data.unique(); }
 
  const DataType &operator*() const { return *Data; }       
  const DataType *operator->() const { return Data.get(); } 
  bool operator==(const cow_ptr<DataType> &A) const noexcept { return Data == A.Data; } 
  bool operator!=(const cow_ptr<DataType> &A) const noexcept { return Data != A.Data; } 
  DataType &access();
};
 
template <typename DataType> cow_ptr<DataType>::cow_ptr(DataType *resourcePtr) : Data(resourcePtr) {}
 
template <typename DataType> cow_ptr<DataType>::cow_ptr() : Data(std::make_shared<DataType>()) {}
 
// Note: Need custom implementation, since std::mutex is not copyable.
template <typename DataType>
cow_ptr<DataType>::cow_ptr(const cow_ptr<DataType> &A) noexcept : Data(std::atomic_load(&A.Data)) {}
 
// Note: Need custom implementation, since std::mutex is not copyable.
template <typename DataType> cow_ptr<DataType> &cow_ptr<DataType>::operator=(const cow_ptr<DataType> &A) noexcept {
  if (this != &A) {
    std::atomic_store(&Data, std::atomic_load(&A.Data));
  }
  return *this;
}
 
template <typename DataType> cow_ptr<DataType> &cow_ptr<DataType>::operator=(const ptr_type &A) noexcept {
  if (this->Data != A) {
    std::atomic_store(&Data, std::atomic_load(&A));
  }
  return *this;
}
 
template <typename DataType> DataType &cow_ptr<DataType>::access() {
  // Use a double-check for sharing so that we only acquire the lock if
  // absolutely necessary
  if (!Data.unique()) {
    std::lock_guard<std::mutex> lock{copyMutex};
    // Check again because another thread may have taken copy and dropped
    // reference count since previous check
    if (!Data.unique()) {
      std::atomic_store(&Data, std::make_shared<DataType>(*Data));
    }
  }
  return *Data;
}
 
template <typename DataType> cow_ptr<DataType>::cow_ptr(ptr_type &&resourceSptr) noexcept {
  std::atomic_store(&this->Data, std::move(resourceSptr));
}
 
template <typename DataType> cow_ptr<DataType>::cow_ptr(const ptr_type &resourceSptr) noexcept {
  std::atomic_store(&this->Data, std::atomic_load(&resourceSptr));
}
 
} // NAMESPACE Kernel
 
using MantidVec = std::vector<double>;
 
using MantidVecPtr = Kernel::cow_ptr<MantidVec>;
 
} // NAMESPACE Mantid