ptr.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_ptr_h
#define INCL_evo_ptr_h

#include "type.h"

namespace evo {


template<class T>
class SmartPtr : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef SmartPtr<T> This;       
    typedef T Item;                 

    SmartPtr(T* ptr=NULL) {
        ptr_ = ptr;
    }

    SmartPtr(const This& src) {
        ptr_ = new T(*src.ptr_);
    }

    ~SmartPtr() {
        free();
    }

    This& operator=(const This& src) {
        free();
        ptr_ = new T(*src.ptr_);
        return *this;
    }

    This& operator=(T* ptr) {
        free();
        ptr_ = ptr;
        return *this;
    }

#if defined(EVO_CPP11)

    SmartPtr(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
    }

    This& operator=(This&& src) {
        free();
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
        return *this;
    }
#endif

    This& clear() {
        free();
        ptr_ = NULL;
        return *this;
    }
    
    This& set() {
        free();
        ptr_ = NULL;
        return *this;
    }

    T* detach() {
        T* result = ptr_;
        ptr_ = NULL;
        return result;
    }

protected:
    void free() {
        if (ptr_ != NULL)
            delete ptr_;
    }
};

template<class T>
class SmartPtr<T[]> : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef SmartPtr<T[]> This;
    typedef T Item;

    SmartPtr(T* ptr=NULL) {
        ptr_ = ptr;
    }

    ~SmartPtr() {
        free();
    }

    This& operator=(T* ptr) {
        free();
        ptr_ = ptr;
        return *this;
    }

#if defined(EVO_CPP11)

    SmartPtr(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
    }

    This& operator=(This&& src) {
        free();
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
        return *this;
    }
#endif

    This& clear() {
        free();
        ptr_ = NULL;
        return *this;
    }

    This& set() {
        free();
        ptr_ = NULL;
        return *this;
    }

    T* detach() {
        T* result = ptr_;
        ptr_ = NULL;
        return result;
    }

protected:
    void free() {
        if (ptr_ != NULL)
            delete [] ptr_;
    }

private:
    // Disable copying
    explicit SmartPtr(const This&) EVO_ONCPP11(= delete);
    This& operator=(const This&) EVO_ONCPP11(= delete);
};


template<class T,class TSize=SizeT>
class SharedPtr : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef SharedPtr<T,TSize> This;    
    typedef T Item;                     

    SharedPtr()
        { ptr_ = NULL; refs_ = NULL; }

    SharedPtr(T* ptr) {
        if (ptr != NULL)
            { ptr_ = ptr; refs_ = new TSize; *refs_ = 1; }
        else
            { ptr_ = NULL; refs_ = NULL; }
    }

    SharedPtr(const This& src) {
        if (src.ptr_ != NULL)
            { ptr_ = src.ptr_; refs_ = src.refs_; ++(*refs_); }
        else
            { ptr_ = NULL; refs_ = NULL; }
    }

    ~SharedPtr()
        { free(); }

    This& operator=(const This& src) {
        free();
        if (src.ptr_ != NULL)
            { ptr_ = src.ptr_; refs_ = src.refs_; ++(*refs_); }
        else
            { ptr_ = NULL; refs_ = NULL; }
        return *this;
    }

    This& operator=(T* ptr) {
        clear();
        if (ptr != NULL) {
            ptr_ = ptr;
            if (refs_ == NULL)
                refs_ = new TSize;
            *refs_ = 1;
        }
        return *this;
    }

#if defined(EVO_CPP11)

    SharedPtr(This&& src) {
        ptr_ = src.ptr_;
        refs_ = src.refs_;
        src.ptr_ = NULL;
        src.refs_ = NULL;
    }

    This& operator=(This&& src) {
        free();
        ptr_ = src.ptr_;
        refs_ = src.refs_;
        src.ptr_ = NULL;
        src.refs_ = NULL;
        return *this;
    }
#endif

    This& clear() {
        if (ptr_ != NULL) {
            if (--(*refs_) == 0)
                delete ptr_; // leave refs_ allocated for later
            else
                refs_ = NULL; // detach from shared
            ptr_  = NULL;
        }
        return *this;
    }

    This& set()
        { return clear(); }

    This& unshare() {
        if (ptr_ != NULL && *refs_ > 1) {
            ptr_   = new T(*ptr_);
            --(*refs_);
            refs_  = new TSize;
            *refs_ = 1;
        }
        return *this;
    }

    bool shared() const
        { return (ptr_ != NULL && *refs_ > 1); }

protected:
    TSize* refs_;

    void free() {
        if (ptr_ != NULL) {
            if (--(*refs_) == 0)
                { delete ptr_; delete refs_; }
        } else if (refs_ != NULL)
            delete refs_;
    }
};

template<class T,class TSize>
class SharedPtr<T[],TSize> : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef SharedPtr<T[],TSize> This;
    typedef T Item;

    SharedPtr()
        { ptr_ = NULL; refs_ = NULL; }

    SharedPtr(T* ptr) {
        if (ptr != NULL)
            { ptr_ = ptr; refs_ = new TSize; *refs_ = 1; }
        else
            { ptr_ = NULL; refs_ = NULL; }
    }

    SharedPtr(const This& src) {
        if (src.ptr_ != NULL)
            { ptr_ = src.ptr_; refs_ = src.refs_; ++(*refs_); }
        else
            { ptr_ = NULL; refs_ = NULL; }
    }

    ~SharedPtr()
        { free(); }

    This& operator=(const This& src) {
        free();
        if (src.ptr_ != NULL)
            { ptr_ = src.ptr_; refs_ = src.refs_; ++(*refs_); }
        else
            { ptr_ = NULL; refs_ = NULL; }
        return *this;
    }

    This& operator=(T* ptr) {
        clear();
        if (ptr != NULL) {
            ptr_ = ptr;
            if (refs_ == NULL)
                refs_ = new TSize;
            *refs_ = 1;
        }
        return *this;
    }

#if defined(EVO_CPP11)

    SharedPtr(This&& src) {
        ptr_ = src.ptr_;
        refs_ = src.refs_;
        src.ptr_ = NULL;
        src.refs_ = NULL;
    }

    This& operator=(This&& src) {
        free();
        ptr_ = src.ptr_;
        refs_ = src.refs_;
        src.ptr_ = NULL;
        src.refs_ = NULL;
        return *this;
    }
#endif

    This& clear() {
        if (ptr_ != NULL) {
            if (--(*refs_) == 0) {
                delete [] ptr_; // leave refs_ allocated for later
                ptr_ = NULL;
            } else
                refs_ = NULL; // detach from shared
        }
        return *this;
    }

    This& set()
        { return clear(); }

    bool shared() const
        { return (ptr_ != NULL && *refs_ > 1); }

protected:
    TSize* refs_;

    void free() {
        if (ptr_ != NULL) {
            if (--(*refs_) == 0)
                { delete [] ptr_; delete refs_; }
        } else if (refs_ != NULL)
            delete refs_;
    }

private:
    // Disabled if array
    This& unshare();
};


template<class T>
class Ptr : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef Ptr<T>     This;        
    typedef PtrBase<T> Base;        
    typedef T          Item;        

    Ptr()
        { ptr_ = NULL; }

    Ptr(T* ptr)
        { ptr_ = ptr; }

    Ptr(const T* ptr)
        { ptr_ = (T*)ptr; }

    Ptr(const This& src)
        { ptr_ = src.ptr_; }

    Ptr(const Base& src)
        { ptr_ = src.ptr_; }

    This& operator=(const This& src) {
        ptr_ = src.ptr_;
        return *this;
    }

    This& operator=(const Base& src) {
        ptr_ = src.ptr_;
        return *this;
    }

    This& operator=(T* ptr) {
        ptr_ = ptr;
        return *this;
    }

    This& operator=(const T* ptr) {
        ptr_ = (T*)ptr;
        return *this;
    }

#if defined(EVO_CPP11)

    Ptr(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
    }

    This& operator=(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
        return *this;
    }
#endif

    This& clear() {
        ptr_ = NULL;
        return *this;
    }

    This& set() {
        ptr_ = NULL;
        return *this;
    }

    T* detach() {
        T* result = ptr_;
        ptr_ = NULL;
        return result;
    }
};

template<class T>
class Ptr<T[]> : public PtrBase<T> {
protected:
    using PtrBase<T>::ptr_;

public:
    typedef Ptr<T[]>   This;        
    typedef PtrBase<T> Base;        
    typedef T          Item;        


    Ptr()
        { ptr_ = NULL; }

    Ptr(T* ptr)
        { ptr_ = ptr; }

    Ptr(const T* ptr)
        { ptr_ = (T*)ptr; }

    Ptr(const This& src)
        { ptr_ = src.ptr_; }

    Ptr(const Base& src)
        { ptr_ = src.ptr_; }

    This& operator=(const This& src)
        { ptr_ = src.ptr_; return *this; }

    This& operator=(const Base& src)
        { ptr_ = src.ptr_; return *this; }

    This& operator=(T* ptr)
        { ptr_ = ptr; return *this; }

    This& operator=(const T* ptr)
        { ptr_ = (T*)ptr; return *this; }

#if defined(EVO_CPP11)

    Ptr(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
    }

    This& operator=(This&& src) {
        ptr_ = src.ptr_;
        src.ptr_ = NULL;
        return *this;
    }
#endif

    This& clear()
        { ptr_ = NULL; return *this; }

    This& set()
        { ptr_ = NULL; return *this; }

    T* detach() {
        T* result = ptr_;
        ptr_ = NULL;
        return result;
    }
};


template<class T> struct IsSmartPtr : public StaticBoolF { };
template<class T> struct IsSmartPtr<SmartPtr<T> >    : public StaticBoolT { };
template<class T> struct IsSmartPtr<SmartPtr<T[]> >  : public StaticBoolT { };
template<class T> struct IsSmartPtr<SharedPtr<T> >   : public StaticBoolT { };
template<class T> struct IsSmartPtr<SharedPtr<T[]> > : public StaticBoolT { };

}
#endif