ResourceGuard.h

Go to the documentation of this file.

#ifndef UTILS_RESOURCEGUARD_H
#define UTILS_RESOURCEGUARD_H
 
#include "tdb.h"
 
namespace taco {
 
template<class T,
         class Relinquish,
         class FlagType = bool,
         FlagType InvalidVal = std::is_lvalue_reference<T>::value,
         class = typename std::enable_if<
             // T may not be bool
             !std::is_same<FlagType, bool>::value &&
             // FlagType must be bool, same as T
             (std::is_same<FlagType, bool>::value ||
              std::is_same<FlagType, T>::value) &&
             // Relinquish must be trivially default constructible
             std::is_trivially_default_constructible<Relinquish>::value
         >::type>
class ResourceGuard {
public:
    ResourceGuard(): m_val(InvalidVal) {}
 
    ResourceGuard(T val): m_val(val) {}
 
    ~ResourceGuard() {
        if (m_val != InvalidVal)
            Relinquish()(m_val);
    }
 
    // no copy
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;
 
    // move ctor and assignment
    ResourceGuard(ResourceGuard&& other):
        m_val(other.m_val) {
        other.m_val = InvalidVal;
    }
 
    ResourceGuard& operator=(ResourceGuard&& other) {
        if (m_val != InvalidVal) {
            Relinquish()(m_val);
        }
        m_val = other.m_val;
        other.m_val = InvalidVal;
        return *this;
    }
 
    operator T() const {
        return m_val;
    }
 
    T
    Get() const {
        return m_val;
    }
 
    operator bool() const {
        return m_val != InvalidVal;
    }
 
    bool
    IsValid() const {
        return m_val != InvalidVal;
    }
 
    void
    Reset() {
        if (m_val != InvalidVal) {
            Relinquish()(m_val);
            m_val = InvalidVal;
        }
    }
 
    T
    Release() {
        T ret = m_val;
        m_val = InvalidVal;
        return ret;
    }
 
    constexpr bool
    operator==(T rhs) const {
        return m_val == rhs;
    }
 
    constexpr bool
    operator!=(T rhs) const {
        return m_val != rhs;
    }
 
private:
    T   m_val;
};
 
template<class T, class Relinquish>
class ResourceGuard<T, Relinquish, bool, false, void> {
public:
    ResourceGuard(): m_isvalid(false) {}
 
    ResourceGuard(T val):
        m_val(val), m_isvalid(true) {}
 
    ~ResourceGuard() {
        if (m_isvalid)
            Relinquish()(m_val);
    }
 
    // no copy
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;
 
    // move ctor and assignment
    ResourceGuard(ResourceGuard&& other):
        m_val(other.m_val),
        m_isvalid(other.m_isvalid) {
        other.m_val = T();
        other.m_isvalid = false;
    }
 
    ResourceGuard& operator=(ResourceGuard&& other) {
        if (m_isvalid) {
            Relinquish()(m_val);
        }
        m_val = other.m_val;
        m_isvalid = other.m_isvalid;
        other.m_val = T();
        other.m_isvalid = false;
        return *this;
    }
 
    operator T() const {
        return m_val;
    }
 
    T
    Get() const {
        return m_val;
    }
 
    operator bool() const {
        return m_isvalid;
    }
 
    bool
    IsValid() const {
        return m_isvalid;
    }
 
    void
    Reset() {
        if (m_isvalid) {
            Relinquish()(m_val);
            m_val = T();
            m_isvalid = false;
        }
    }
 
    T
    Release() {
        T ret = m_val;
        m_val = T();
        m_isvalid = false;
        return ret;
    }
 
    constexpr bool
    operator==(T rhs) const {
        return m_val == rhs;
    }
 
    constexpr bool
    operator!=(T rhs) const {
        return m_val != rhs;
    }
 
 
private:
    T       m_val;
    bool    m_isvalid;
};
 
template<class T, class Relinquish>
class ResourceGuard<T, Relinquish, bool, true, void> {
public:
    // no default-ctor
 
    ResourceGuard(T val):
        m_val(val) {}
 
    ~ResourceGuard() {
        Relinquish()(m_val);
    }
 
    // no copy
    ResourceGuard(const ResourceGuard&) = delete;
    ResourceGuard& operator=(const ResourceGuard&) = delete;
 
    // no move
    ResourceGuard(ResourceGuard&& other) = delete;
    ResourceGuard& operator=(ResourceGuard&& other) = delete;
 
    operator T() const {
        return m_val;
    }
 
    T
    Get() const {
        return m_val;
    }
 
    operator bool() const {
        return true;
    }
 
    bool
    IsValid() const {
        return true;
    }
 
    constexpr bool
    operator==(T rhs) const {
        return m_val == rhs;
    }
 
    constexpr bool
    operator!=(T rhs) const {
        return m_val != rhs;
    }
 
private:
    T       m_val;
};
 
}   // namespace stdb
 
#endif      // UTILS_RESOURCEGUARD_H