SharedPointer.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 SHAREDPOINTER_H
#define SHAREDPOINTER_H

#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/utility.h"

template <class T>
class SharedPointer
{
  public:
    SharedPointer();

    SharedPointer(T *ptr);

    SharedPointer(SharedPointer<T> &&other);

    virtual ~SharedPointer();

    SharedPointer(const SharedPointer<T> &p);

    void reset();
    void reset(T *ptr);

    T *get() const;

    T *operator->() const;

    T &operator*() const;

    SharedPointer<T> &operator=(const SharedPointer<T> &p);

    SharedPointer<T> &operator=(SharedPointer<T> &&p);

    explicit operator bool() const;

    bool unique() const;

    size_t refcount() const;

    template <class... Args>
    static SharedPointer<T> allocate(Args...);

    bool operator==(const SharedPointer &p) const;
    bool operator!=(const SharedPointer &p) const;
    bool operator<(const SharedPointer &p) const;
    bool operator<=(const SharedPointer &p) const;
    bool operator>(const SharedPointer &p) const;
    bool operator>=(const SharedPointer &p) const;

  private:
    void release();

    struct Control
    {
        T *ptr;
        size_t refcount;
    } * m_Control;
};

template <class T>
SharedPointer<T>::SharedPointer() : m_Control(0)
{
}

template <class T>
SharedPointer<T>::SharedPointer(T *ptr) : m_Control(0)
{
    reset(ptr);
}

template <class T>
SharedPointer<T>::SharedPointer(SharedPointer<T> &&other)
{
    m_Control = pedigree_std::move(other.m_Control);

    other.m_Control = nullptr;
}

template <class T>
SharedPointer<T>::~SharedPointer()
{
    release();
}

template <class T>
SharedPointer<T>::SharedPointer(const SharedPointer<T> &p) : m_Control(0)
{
    if (p.m_Control)
    {
        __atomic_add_fetch(&p.m_Control->refcount, 1, __ATOMIC_SEQ_CST);
    }

    release();

    m_Control = p.m_Control;
}

template <class T>
void SharedPointer<T>::reset()
{
    release();
}

template <class T>
void SharedPointer<T>::reset(T *ptr)
{
    release();

    m_Control = new Control;
    m_Control->refcount = 1;
    m_Control->ptr = ptr;
}

template <class T>
T *SharedPointer<T>::get() const
{
    if (!m_Control)
        return 0;

    return m_Control->ptr;
}

template <class T>
T *SharedPointer<T>::operator->() const
{
    return get();
}

template <class T>
T &SharedPointer<T>::operator*() const
{
    return *(get());
}

template <class T>
SharedPointer<T> &SharedPointer<T>::operator=(const SharedPointer<T> &p)
{
    // If the other is assigned, boost its refcount before we release. If it
    // happens that the other is in fact pointing to the same place, the counts
    // will not potentially drop to zero then back to one this way (causing a
    // bad pointer).
    if (p.m_Control)
    {
        __atomic_add_fetch(&p.m_Control->refcount, 1, __ATOMIC_SEQ_CST);
    }

    release();

    m_Control = p.m_Control;

    return *this;
}

template <class T>
SharedPointer<T> &SharedPointer<T>::operator=(SharedPointer<T> &&p)
{
    release();
    m_Control = pedigree_std::move(p.m_Control);
    p.m_Control = nullptr;

    return *this;
}

template <class T>
SharedPointer<T>::operator bool() const
{
    return get() != 0;
}

template <class T>
bool SharedPointer<T>::unique() const
{
    return refcount() == 1;
}

template <class T>
size_t SharedPointer<T>::refcount() const
{
    if (!m_Control)
        return 0;

    return __atomic_load_n(&m_Control->refcount, __ATOMIC_SEQ_CST);
}

template <class T>
template <class... Args>
SharedPointer<T> SharedPointer<T>::allocate(Args... args)
{
    SharedPointer<T> result;
    result.reset(new T(args...));
    return pedigree_std::move(result);
}

template <class T>
void SharedPointer<T>::release()
{
    if (!m_Control)
        return;

    size_t rc = __atomic_sub_fetch(&m_Control->refcount, 1, __ATOMIC_SEQ_CST);
    if (!rc)
    {
        delete m_Control->ptr;
        m_Control->ptr = 0;

        delete m_Control;
    }

    // We don't care about the control structure anymore. Someone else will
    // free it if we did not.
    m_Control = 0;
}

template <class T>
bool SharedPointer<T>::operator==(const SharedPointer &p) const
{
    return get() == p.get();
}

template <class T>
bool SharedPointer<T>::operator!=(const SharedPointer &p) const
{
    return get() != p.get();
}

template <class T>
bool SharedPointer<T>::operator<(const SharedPointer &p) const
{
    return get() < p.get();
}

template <class T>
bool SharedPointer<T>::operator<=(const SharedPointer &p) const
{
    return get() <= p.get();
}

template <class T>
bool SharedPointer<T>::operator>(const SharedPointer &p) const
{
    return get() > p.get();
}

template <class T>
bool SharedPointer<T>::operator>=(const SharedPointer &p) const
{
    return get() >= p.get();
}

#endif