File Coverage

/usr/local/lib/perl5/site_perl/5.26.1/x86_64-linux/CPP/panda/lib.x/i/panda/refcnt.h

Criterion	Covered	Total	%
statement	32	32	100.0
branch	39	58	67.2
condition			n/a
subroutine			n/a
pod			n/a
total	71	90	78.8

#pragma once
#include
#include
#include
#include

namespace panda {

static long int void_refcnt = 1;

namespace {
    template
    struct HasRetain {
        typedef char yes;
        typedef char no[2];

        struct fallback { int retain; };
        struct mixed_type: T, fallback {};
        template < typename U, U > struct type_check {};

        template < typename U > static no&  test( type_check< int (fallback::*), &U::retain >* = 0 );
        template < typename U > static yes& test( ... );

        static const bool value = sizeof( yes ) == sizeof( test< mixed_type >( NULL ) );
    };

    template
    struct HasRelease {
        typedef char yes;
        typedef char no[2];

        struct fallback { int release; };
        struct mixed_type: T, fallback {};
        template < typename U, U > struct type_check {};

        template < typename U > static no&  test( type_check< int (fallback::*), &U::release >* = 0 );
        template < typename U > static yes& test( ... );

        static const bool value = sizeof( yes ) == sizeof( test< mixed_type >( NULL ) );
    };

    template
    struct IsRefCounted {
        static const bool value = HasRelease::value && HasRetain::value;
    };
}

class Refcnt {
public:
    void    retain  () const { ++_refcnt; }
    void    release () const { if (--_refcnt <= 0) delete this; }
    int32_t refcnt  () const { return _refcnt; }
protected:
    Refcnt () : _refcnt(0) {}
    virtual ~Refcnt () {}
private:
    mutable int32_t _refcnt;
};

template
class iptr {
public:
    template  friend class iptr;
    typedef T element_type;

    iptr ()                   : ptr(NULL)    {}
    iptr (T* pointer)         : ptr(pointer) { if (ptr) ptr->retain(); }
    iptr (const iptr& oth) : ptr(oth.ptr) { if (ptr) ptr->retain(); }
    template
    iptr (const iptr& oth) : ptr(oth.ptr) { if (ptr) ptr->retain(); }

    iptr (iptr&& oth) {
        ptr = oth.ptr;
        oth.ptr = NULL;
    }

    template
    iptr (iptr&& oth) {
        ptr = oth.ptr;
        oth.ptr = NULL;
    }

    ~iptr () { if (ptr) ptr->release(); }

    iptr& operator= (T* pointer) {
        if (ptr) ptr->release();
        ptr = pointer;
        if (pointer) pointer->retain();
        return *this;
    }

    iptr& operator= (const iptr& oth) { return iptr::operator=(oth.ptr); }
    template
    iptr& operator= (const iptr& oth) { return iptr::operator=(oth.ptr); }

    iptr& operator= (iptr&& oth) {
        std::swap(ptr, oth.ptr);
        return *this;
    }

    template
    iptr& operator= (iptr&& oth) {
        if (ptr) ptr->release();
        ptr = oth.ptr;
        oth.ptr = NULL;
        return *this;
    }

    void reset () {
        if (ptr) ptr->release();
        ptr = NULL;
    }

    void reset (T* p) { operator=(p); }

    T* operator-> () const { return ptr; }
    T& operator*  () const { return *ptr; }
    operator T*   () const { return ptr; }
    explicit
    operator bool () const { return ptr; }

    T* get () const { return ptr; }

private:
    T* ptr;
};

template
inline iptr static_pointer_cast (const iptr& ptr) {
    return iptr(static_cast(ptr.get()));
}

template
inline iptr const_pointer_cast (const iptr& ptr) {
    return iptr(const_cast(ptr.get()));
}

template
inline iptr dynamic_pointer_cast (const iptr& ptr) {
    return iptr(dyn_cast(ptr.get()));
}

class RefCounted {
public:
    void    retain  () const { ++_refcnt; on_retain(); }
    void    release () const { bool delete_me = --_refcnt <= 0; on_release(); if (delete_me && _refcnt <= 0) delete this; }
    int32_t refcnt  () const { return _refcnt; }
protected:
    RefCounted () : _refcnt(0) {}
    virtual void on_retain  () const {}
    virtual void on_release () const {}
    virtual ~RefCounted () {}
private:
    mutable int32_t _refcnt;
};

template ::value>
class shared_ptr {};

template
class shared_ptr {
public:
    typedef T element_type;

    shared_ptr () : ptr(NULL) {}

    shared_ptr (T* pointer) : ptr(pointer) {
        if (ptr) ptr->retain();
    }

    shared_ptr (const shared_ptr& oth) : ptr(oth.ptr) {
        if (ptr) ptr->retain();
    }

    template
    shared_ptr (const shared_ptr& oth) : ptr(oth.get()) {
        if (ptr) ptr->retain();
    }

    ~shared_ptr () {
        if (ptr) ptr->release();
    }

    shared_ptr& operator= (T* pointer) {
        if (ptr) ptr->release();
        ptr = pointer;
        if (ptr) ptr->retain();
        return *this;
    }

    shared_ptr& operator= (const shared_ptr& oth) {
        return shared_ptr::operator=(oth.ptr);
    }

    void reset () {
        if (ptr) ptr->release();
        ptr = NULL;
    }

    template
    void reset (U* p) {
        operator=(p);
    }

    T* operator-> () const { return ptr; }
    T& operator*  () const { return *ptr; }
    operator T*   () const { return ptr; }
    explicit operator bool () const { return ptr; }

    T*       get       () const { return ptr; }
    long int use_count () const { return ptr->refcnt(); }
    bool     unique    () const { return ptr->refcnt() == 1; }

private:
    T* ptr;
};

template
class shared_ptr {
public:
    typedef T element_type;

    shared_ptr () : ptr(NULL), refcnt(&void_refcnt) {
        refcnt_inc();
    }
    shared_ptr (std::nullptr_t) : shared_ptr() {}

    explicit shared_ptr (T* pointer) {
        ptr = pointer;
        if (ptr) {
            refcnt = new long int;
            *refcnt = 1;
        } else {
            refcnt = &void_refcnt;
            refcnt_inc();
        }
    }

    shared_ptr (const shared_ptr& oth) : ptr(oth.ptr), refcnt(oth.refcnt) {
        refcnt_inc();
    }

    template
    shared_ptr (const shared_ptr& oth) : ptr(oth.ptr), refcnt(oth.refcnt) {
        refcnt_inc();
    }

    template
    shared_ptr (const shared_ptr& oth, T* pointer) : ptr(pointer), refcnt(oth.refcnt) {
        refcnt_inc();
    }

    ~shared_ptr () {
        refcnt_dec();
    }

    shared_ptr& operator= (const shared_ptr& oth) {
        refcnt_dec();
        ptr = oth.ptr;
        refcnt = oth.refcnt;
        refcnt_inc();
        return *this;
    }

    void reset () {
        refcnt_dec();
        ptr = NULL;
        refcnt = &void_refcnt;
        refcnt_inc();
    }

    template
    void reset (U* p) {
        operator=(p);
    }

    T* operator-> () const { return ptr; }
    T& operator*  () const { return *ptr; }
    operator T*   () const { return ptr; }
    explicit operator bool () const { return ptr; }

    T*       get       () const { return ptr; }
    long int use_count () const { return *refcnt; }
    bool     unique    () const { return *refcnt == 1; }

    template friend class shared_ptr;

private:
    T*   ptr;
    long int* refcnt;

    void refcnt_inc () {
        ++*refcnt;
    }

    void refcnt_dec () {
        if (--*refcnt <= 0) {
            delete ptr;
            delete refcnt;
        }
    }
};

template
inline shared_ptr static_pointer_cast (const shared_ptr& shptr) {
    return shared_ptr(shptr, static_cast(shptr.get()));
}

template
inline shared_ptr static_pointer_cast (const shared_ptr& shptr) {
    return shared_ptr(static_cast(shptr.get()));
}

template
inline shared_ptr const_pointer_cast (const shared_ptr& shptr) {
    return shared_ptr(shptr, const_cast(shptr.get()));
}

template
inline shared_ptr const_pointer_cast (const shared_ptr& shptr) {
    return shared_ptr(const_cast(shptr.get()));
}

template
inline shared_ptr dynamic_pointer_cast (const shared_ptr& shptr) {
    if (T1* p = dyn_cast(shptr.get())) return shared_ptr(shptr, p);
    return shared_ptr();
}

template
inline shared_ptr dynamic_pointer_cast (const shared_ptr& shptr) {
    if (T1* p = dyn_cast(shptr.get())) return shared_ptr(p);
    return shared_ptr();
}

template
inline std::shared_ptr static_pointer_cast (const std::shared_ptr& shptr) {
    return std::static_pointer_cast(shptr);
}
template
inline std::shared_ptr const_pointer_cast (const std::shared_ptr& shptr) {
    return std::const_pointer_cast(shptr);
}
template
inline std::shared_ptr dynamic_pointer_cast (const std::shared_ptr& shptr) {
    return std::dynamic_pointer_cast(shptr);
}

namespace {
    template ::value>
    struct make_shared_impl;

    template
    struct make_shared_impl {
        template
        static shared_ptr make_shared(Args&&... args) {
            return new T(std::forward(args)...);
        }
    };

    template
    struct make_shared_impl {
        template
        static shared_ptr make_shared(Args&&... args) {
            struct tmp : public T, public virtual RefCounted {
                using T::T;
            };

            return new tmp(std::forward(args)...);
        }
    };
}

template
shared_ptr make_shared(Args&&... args) {
    //return make_shared_impl::make_shared(std::forward(args)...);
    return shared_ptr(new T(std::forward(args)...));
}

}