ClonedPtr.h

/* Copyright (C) 2012-2020 IBM Corp.
 * This program is Licensed under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *   http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. See accompanying LICENSE file.
 */
#ifndef HELIB_CLONEDPTR_H
#define HELIB_CLONEDPTR_H
 
#include <utility> // std::swap
namespace helib {
 
template <typename PTR>
PTR clonePtr(PTR& ptr)
{
  static_assert(std::is_pointer<decltype(ptr->clone())>::value,
                "`clone` method must return raw pointer.");
 
  return PTR(ptr->clone());
}
 
template <typename T>
struct DeepCopy
{
  static T* apply(const T* ptr)
  {
    static_assert(std::is_pointer<decltype(ptr->clone())>::value,
                  "`clone` method must return raw pointer.");
 
    return ptr->clone();
  }
};
 
template <typename T>
struct ShallowCopy
{
  static T* apply(const T* ptr)
  {
    static_assert(std::is_copy_constructible<T>::value,
                  "Must be copy constructable.");
 
    return new T(*ptr);
  }
};
 
template <typename T, typename Cloner = DeepCopy<T>>
class ClonedPtr
{
public:
  using value_type = T;
 
  explicit ClonedPtr(T* p = nullptr) : ptr(p) {}
 
  ClonedPtr(std::nullptr_t) : ptr(nullptr) {}
 
  ~ClonedPtr()
  {
    if (ptr != nullptr)
      delete ptr;
  }
 
  ClonedPtr(const ClonedPtr& other) : ptr(copy(other.ptr)) {}
 
  ClonedPtr(ClonedPtr&& other) noexcept : ptr{std::exchange(other.ptr, nullptr)}
  {}
 
  ClonedPtr& operator=(const ClonedPtr& other)
  {
    if (this != &other) {
      delete ptr;
      ptr = copy(other.ptr);
    }
    return *this;
  }
 
  ClonedPtr& operator=(ClonedPtr&& other) noexcept
  {
    if (this != &other) {
      delete ptr;
      ptr = std::exchange(other.ptr, nullptr);
    }
    return *this;
  }
 
  void reset(T* p = nullptr)
  {
    if (ptr != p) {
      if (ptr != nullptr)
        delete ptr;
      ptr = p;
    }
  }
 
  T* release() noexcept
  {
    T* ptr_to_release = ptr;
    ptr = nullptr;
    return ptr_to_release;
  }
 
  explicit operator bool() const noexcept { return ptr != nullptr; }
 
  const T& operator*() const { return *ptr; }
 
  T& operator*() { return *ptr; }
 
  const T* operator->() const { return ptr; }
 
  T* operator->() { return ptr; }
 
  const T* get() const { return ptr; }
 
  T* get() { return ptr; }
 
  bool operator==(const ClonedPtr& other) const { return ptr == other.ptr; }
 
  bool operator!=(const ClonedPtr& other) const { return ptr != other.ptr; }
 
  bool operator<(const ClonedPtr& other) const { return ptr < other.ptr; }
 
  bool operator>(const ClonedPtr& other) const { return ptr > other.ptr; }
 
  bool operator<=(const ClonedPtr& other) const { return ptr <= other.ptr; }
 
  bool operator>=(const ClonedPtr& other) const { return ptr >= other.ptr; }
 
  void swap(ClonedPtr& other) { std::swap(ptr, other.ptr); }
 
private:
  // Copy function applies cloning policy.
  T* copy(T* p) { return (p ? Cloner::apply(p) : nullptr); }
 
  // The raw pointer to the managed object.
  T* ptr = nullptr;
};
 
template <typename T>
using CopiedPtr = ClonedPtr<T, ShallowCopy<T>>;
 
template <typename T, typename... Args>
ClonedPtr<T> makeClonedPtr(Args&&... args)
{
  return ClonedPtr<T>(new T(std::forward<Args>(args)...));
}
 
} // namespace helib
 
#endif // HELIB_CLONEDPTR_H