SharedPointer.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://github.com/matzke1/sawyer.
 
 
 
 
#ifndef Sawyer_SharedPtr_H
#define Sawyer_SharedPtr_H
 
#include <Sawyer/Assert.h>
#include <Sawyer/Optional.h>                            // FIXME[Robb Matzke 2014-08-22]: only needed for Sawyer::Nothing
#include <Sawyer/Sawyer.h>
#include <Sawyer/SharedObject.h>
#include <Sawyer/Synchronization.h>
 
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#include <cstddef>
#include <ostream>
 
namespace Sawyer {
 
template<class T>
class SharedPointer {
public:
    typedef T Pointee;
private:
    Pointee *pointee_;
 
    static void acquireOwnership(Pointee *rawPtr);
 
    // Returns number of owners remaining
    static size_t releaseOwnership(Pointee *rawPtr);
 
private:
    friend class boost::serialization::access;
 
    template<class S>
    void save(S &s, const unsigned /*version*/) const {
        s << BOOST_SERIALIZATION_NVP(pointee_);
    }
 
    template<class S>
    void load(S &s, const unsigned /*version*/) {
        if (pointee_ != nullptr && 0==releaseOwnership(pointee_))
            delete pointee_;
        pointee_ = nullptr;
        s >> BOOST_SERIALIZATION_NVP(pointee_);
        acquireOwnership(pointee_);
    }
 
    BOOST_SERIALIZATION_SPLIT_MEMBER();
    
public:
    SharedPointer(): pointee_(nullptr) {}
 
    SharedPointer(const SharedPointer &other): pointee_(other.pointee_) {
        acquireOwnership(pointee_);
    }
    template<class Y>
    SharedPointer(const SharedPointer<Y> &other): pointee_(other.getRawPointer()) {
        acquireOwnership(pointee_);
    }
    template<class Y>
    explicit SharedPointer(Y *rawPtr): pointee_(rawPtr) {
        if (pointee_ != nullptr)
            acquireOwnership(pointee_);
    }
 
    ~SharedPointer() {
        if (0==releaseOwnership(pointee_))
            delete pointee_;
    }
 
    SharedPointer& operator=(const SharedPointer &other) {
        return operator=<T>(other);
    }
    template<class Y>
    SharedPointer& operator=(const SharedPointer<Y> &other) {
        if (pointee_!=other.getRawPointer()) {
            if (pointee_ != nullptr && 0 == releaseOwnership(pointee_))
                delete pointee_;
            pointee_ = other.getRawPointer();
            acquireOwnership(pointee_);
        }
        return *this;
    }
    SharedPointer& operator=(const Sawyer::Nothing&) {
        if (pointee_ != nullptr && 0 == releaseOwnership(pointee_))
            delete pointee_;
        pointee_ = nullptr;
        return *this;
    }
 
    T& operator*() const {
        ASSERT_not_null2(pointee_, "shared pointer points to no object");
        ASSERT_require(ownershipCount(pointee_)>0);
        return *pointee_;
    }
 
    T* operator->() const {
        ASSERT_not_null2(pointee_, "shared pointer points to no object");
        ASSERT_require(ownershipCount(pointee_)>0);
        return pointee_;
    }
    template<class U>
    SharedPointer<U> dynamicCast() const {
        return SharedPointer<U>(dynamic_cast<U*>(pointee_));
    }
    
    template<class U>
    bool operator==(const SharedPointer<U> &other) const {
        return pointee_ == other.getRawPointer();
    }
    template<class U>
    bool operator!=(const SharedPointer<U> &other) const {
        return pointee_ != other.getRawPointer();
    }
    template<class U>
    bool operator<(const SharedPointer<U> &other) const {
        return pointee_ < other.getRawPointer();
    }
    template<class U>
    bool operator<=(const SharedPointer<U> &other) const {
        return pointee_ <= other.getRawPointer();
    }
    template<class U>
    bool operator>(const SharedPointer<U> &other) const {
        return pointee_ > other.getRawPointer();
    }
    template<class U>
    bool operator>=(const SharedPointer<U> &other) const {
        return pointee_ >= other.getRawPointer();
    }
 
    template<class U>
    bool operator==(const U *ptr) const {
        return pointee_ == ptr;
    }
    template<class U>
    bool operator!=(const U *ptr) const {
        return pointee_ != ptr;
    }
    template<class U>
    bool operator<(const U *ptr) const {
        return pointee_ < ptr;
    }
    template<class U>
    bool operator<=(const U *ptr) const {
        return pointee_ <= ptr;
    }
    template<class U>
    bool operator>(const U *ptr) const {
        return pointee_ > ptr;
    }
    template<class U>
    bool operator>=(const U *ptr) const {
        return pointee_ >= ptr;
    }
    bool operator!() const { return pointee_ == nullptr; }
 
    friend std::ostream& operator<<(std::ostream &out, const SharedPointer &ptr) {
        out <<ptr.getRawPointer();
        return out;
    }
    
    // The following trickery is to allow things like "if (x)" to work but without having an implicit
    // conversion to bool which would cause no end of other problems.
private:
    typedef void(SharedPointer::*unspecified_bool)() const;
    void this_type_does_not_support_comparisons() const {}
public:
    operator unspecified_bool() const {
        return pointee_ ? &SharedPointer::this_type_does_not_support_comparisons : nullptr;
    }
 
    //                                  Functions
    // These are functions because we don't want to add any pointer methods that could be confused with methods on the
    // pointee. For instance, if the pointee has an "ownershipCount" method then errors could be easily be introduced. For
    // instance, these two lines both compile but do entirely different things:
    //     object->ownershipCount()
    //     object.ownershipCount();
 
 
    Pointee* getRawPointer() {
        return pointee_;
    }
    Pointee* getRawPointer() const {
        return pointee_;
    }
        
    friend size_t ownershipCount(const SharedPointer &ptr) {
        return ptr.ownershipCount(ptr.pointee_);
    }
private:
    static size_t ownershipCount(Pointee *rawPtr);
};
 
template<class Pointer>
typename Pointer::Pointee*
getRawPointer(Pointer& ptr) {
    return ptr.getRawPointer();
}
 
template<class T>
void clear(SharedPointer<T> &ptr) {
    ptr = SharedPointer<T>();
}
 
template<class T>
class SharedFromThis {
public:
    virtual ~SharedFromThis() {}
 
    SharedPointer<T> sharedFromThis() {
        T *derived = dynamic_cast<T*>(this);
        ASSERT_not_null(derived);
        return SharedPointer<T>(derived);
    }
    SharedPointer<const T> sharedFromThis() const {
        const T *derived = dynamic_cast<const T*>(this);
        ASSERT_not_null(derived);
        return SharedPointer<const T>(derived);
    }
};
 
//                                      Implementations
 
template<class T>
inline size_t SharedPointer<T>::ownershipCount(T *rawPtr) {
    if (rawPtr) {
        SAWYER_THREAD_TRAITS::LockGuard lock(rawPtr->SharedObject::mutex_);
        return rawPtr->SharedObject::nrefs_;
    }
    return 0;
}
 
template<class T>
inline void SharedPointer<T>::acquireOwnership(Pointee *rawPtr) {
    if (rawPtr != nullptr) {
        SAWYER_THREAD_TRAITS::LockGuard lock(rawPtr->SharedObject::mutex_);
        ++rawPtr->SharedObject::nrefs_;
    }
}
 
template<class T>
inline size_t SharedPointer<T>::releaseOwnership(Pointee *rawPtr) {
    if (rawPtr != nullptr) {
        SAWYER_THREAD_TRAITS::LockGuard lock(rawPtr->SharedObject::mutex_);
        assert(rawPtr->SharedObject::nrefs_ > 0);
        return --rawPtr->SharedObject::nrefs_;
    } else {
        return 0;
    }
}
 
} // namespace
#endif