retainer.h

Go to the documentation of this file.

 
#pragma once
 
template <typename ptr_type>
class Retainer {
    static_assert (std::is_pointer <ptr_type>::value, "Retained type must be a pointer.");
    using value_type = typename std::remove_pointer <ptr_type>::type;
    static_assert (std::is_base_of <MusicThingie, value_type>::value, "Retained value type must derive from MusicThingie");
    using this_type = Retainer <ptr_type>;
private:
    value_type *value {nullptr};
public:
    inline Retainer () {};
    
    inline Retainer (value_type *item) : value (item) {
        if (value) {
            value->retain();
        }
    }
    
    inline Retainer (const this_type &item) : value (item.value) {
        if (value) {
            value->retain();
        }
    }
    
    template <typename OtherType>
    inline Retainer (const Retainer<OtherType> &item) : value (item.get()) {
        if (value) {
            value->retain();
        }
    }
 
    inline Retainer (this_type &&item) : value (item.value) {
        item.value = nullptr;
    }
        
    template <typename OtherType>
    inline Retainer (Retainer <OtherType> &&item) : value (item.value) {
        item.value = nullptr;
    }
    
    inline this_type &operator= (value_type *item) {
        if (value != item) {
            if (value) {
                value->release();
            }
            value = item;
            if (value) {
                value->retain();
            }
        }
        return *this;
    }
    
    inline value_type &operator= (const this_type &item) {
        *this = item.value;
        return *this;
    }
 
    template <typename OtherType>
    inline this_type &operator= (const Retainer <OtherType> &item) {
        *this = item.value;
        return *this;
    }
 
    inline this_type &operator= (this_type &&item) {
        if (value != item.value) {
            if (value) {
                value->release();
            }
            value = item.value;
            item.value = nullptr;
        }
        return *this;
    }
 
    template <typename OtherType>
    inline this_type &operator= (Retainer <OtherType> &&item) {
        if (value != item.value) {
            if (value) {
                value->release();
            }
            value = item.value;
            item.value = nullptr;
        }
        return *this;
    }
 
    inline ~Retainer () {
        if (value) {
            value->release();
        }
    }
 
    inline value_type *operator->() const {
        assert (value);
        return value;
    }
 
    inline value_type &operator*() const {
        return *value;
    }
 
    inline value_type *get() const {
        return value;
    }
 
    inline operator bool() const {
        return (value != nullptr);
    }
};