root/library/bdm/shared_ptr.h @ 419

/*!
  \file
  \brief BDM's own smart pointer.
  \author Vaclav Barta.

  -----------------------------------
  BDM++ - C++ library for Bayesian Decision Making under Uncertainty

  Using IT++ for numerical operations
  -----------------------------------
*/

#ifndef shared_ptr_h
#define shared_ptr_h

#include <assert.h>
#include <limits.h>
#include <algorithm>
#include <stdexcept>
#include <string>

namespace bdm {

//! A naive implementation of roughly a subset of the std::tr1:shared_ptr spec (really just roughly - it ignores memory exceptions, for example; also note I didn't read the spec).
// The standard template would naturally be preferable, _if_ it was
// included in the standard libraries of all supported compilers - but
// that's exactly what remains to be seen...
template <typename T>
class shared_ptr {
private:
    T *payload;
    unsigned *refCnt;

public:
    shared_ptr():
        payload(0),
        refCnt(0)
    {
    }

    shared_ptr(T *p):
        payload(p),
        refCnt(p ? new unsigned(1) : 0)
    {
    }

    shared_ptr(const shared_ptr &other):
        payload(other.payload),
        refCnt(other.refCnt)
    {
        add_ref();
    }

    ~shared_ptr()
    {
        del_ref();
    }

    shared_ptr &operator=(const shared_ptr &other)
    {
        other.add_ref();
        del_ref();

        payload = other.payload;
        refCnt = other.refCnt;

        return *this;
    }

    T *get() { return payload; }

    T *operator->()
    {
        assert(payload);
        return payload;
    }

    T &operator*()
    {
        assert(payload);
        return *payload;
    }

    const T* get() const { return payload; }

    const T *operator->() const
    {
        assert(payload);
        return payload;
    }

    const T &operator*() const
    {
        assert(payload);
        return *payload;
    }

    bool unique() const
    {
        return refCnt && (*refCnt == 1);
    }

    long use_count() const
    {
        return refCnt ? *refCnt : 0;
    }

    operator bool() const
    {
      return payload;
    }

    void swap(shared_ptr &other)
    {
        std::swap(payload, other.payload);
        std::swap(refCnt, other.refCnt);
    }

private:
    void add_ref() const
    {
        if (refCnt) {
            if (*refCnt == UINT_MAX) {
                throw std::overflow_error(
                    std::string("Shared pointer has too many references."));
            }

            ++*refCnt;
        }
    }

    void del_ref()
    {
        if (refCnt) {
            if (!(--*refCnt)) {
                delete payload;
                delete refCnt;
            }
        }
    }
};

template<typename T, typename U>
bool operator==(shared_ptr<T> const &a, shared_ptr<U> const &b)
{
    return a.get() == b.get();
}

template<typename T, typename U>
bool operator!=(shared_ptr<T> const &a, shared_ptr<U> const &b)
{
    return a.get() != b.get();
}

template<typename T, typename U>
bool operator<(shared_ptr<T> const &a, shared_ptr<U> const &b)
{
    return a.get() < b.get();
}

}

#endif