Pointers.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef POINTERS_H
#define POINTERS_H
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/processor/types.h"
 
template <class T>
class UniqueCommon {
 public:
  UniqueCommon() : m_Pointer(nullptr) {}
 
  virtual ~UniqueCommon() {
    reset();
  }
 
  T* operator*() const {
    return get();
  }
 
  operator void*() const {
    return get();
  }
 
  T* get() const {
    return m_Pointer;
  }
 
  void reset() noexcept {
    if (m_Pointer) {
      destroy();
      m_Pointer = 0;
    }
  }
 
  NOT_COPYABLE_OR_ASSIGNABLE(UniqueCommon);
 
 protected:
  UniqueCommon(T* p) : m_Pointer(p) {}
 
  virtual void destroy() noexcept {
    delete m_Pointer;
  }
 
  void setPointer(T* p) noexcept {
    m_Pointer = p;
  }
 
  void release() noexcept {
    m_Pointer = nullptr;
  }
 
  T* m_Pointer;
};
 
template <class T>
class UniquePointer : public UniqueCommon<T> {
 public:
  UniquePointer() = default;
 
  virtual ~UniquePointer() {
    this->reset();
  }
 
  // move constructor
  UniquePointer(UniquePointer<T>&& p) noexcept {
    move_from(p);
  }
 
  // no copy construction permitted
  NOT_COPYABLE_OR_ASSIGNABLE(UniquePointer);
 
  UniquePointer<T>& operator=(UniquePointer<T>&& p) noexcept {
    move_from(p);
    return *this;
  }
 
  static UniquePointer<T> adopt(T* pointer) {
    return UniquePointer<T>(pointer);
  }
 
  T* releaseOwnership() noexcept {
    T* pointer = this->get();
    this->release();
    return pointer;
  }
 
  template <class... Args>
  static UniquePointer<T> allocate(Args&&... args) {
    return UniquePointer<T>(new T(args...));
  }
 
 private:
  UniquePointer(T* p) : UniqueCommon<T>(p) {}
 
  void move_from(UniquePointer<T>& p) noexcept {
    T* ptr = p.get();
    p.release();
 
    this->reset();
    this->setPointer(ptr);
  }
};
 
template <class T>
class UniqueArray : public UniqueCommon<T> {
 public:
  UniqueArray() = default;
 
  virtual ~UniqueArray() {
    this->reset();
  }
 
  // move constructor
  UniqueArray(UniqueArray<T>&& p) noexcept {
    move_from(p);
  }
 
  // no copy construction permitted
  NOT_COPYABLE_OR_ASSIGNABLE(UniqueArray);
 
  UniqueArray<T>& operator=(UniqueArray<T>&& p) noexcept {
    move_from(p);
    return *this;
  }
 
  static UniqueArray<T> allocate(size_t count) {
    return UniqueArray<T>(new T[count]);
  }
 
 protected:
  virtual void destroy() noexcept override {
    T* ptr = this->get();
    delete[] ptr;
  }
 
 private:
  UniqueArray(T* p) : UniqueCommon<T>(p) {}
 
  void move_from(UniqueArray<T>& p) noexcept {
    T* ptr = p.get();
    p.release();
 
    this->reset();
    this->setPointer(ptr);
  }
};
 
#endif