vrpn_OwningPtr.h

Go to the documentation of this file.

 
//                  Copyright Sensics 2016.
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE_1_0.txt or copy at
//         http://www.boost.org/LICENSE_1_0.txt)
 
#ifndef INCLUDED_vrpn_OwningPtr_h_GUID_A2A96325_1863_458B_A567_6FD968CB1321
#define INCLUDED_vrpn_OwningPtr_h_GUID_A2A96325_1863_458B_A567_6FD968CB1321
 
// Internal Includes
#include "vrpn_Assert.h"
 
// Library/third-party includes
// - none
 
// Standard includes
#include <utility>
#include <iostream>
 
namespace vrpn {

    template <typename T> struct DefaultDeleter {
        void operator()(T* ptr) const { 
          try {
            delete ptr;
          } catch (...) {
            std::cerr << "DefaultDeleter: delete failed" << std::endl;;
            return;
          }
        }
    };

    template <typename T> struct DefaultDeleter<T[]> {
        void operator()(T* ptr) const {
          try {
            delete[] ptr;
          } catch (...) {
            std::cerr << "DefaultDeleter: delete failed" << std::endl;;
            return;
          }
        }
    };
    namespace traits {
        template <typename T> struct OwningPtrPointerType {
            typedef T* type;
        };

        template <typename T> struct OwningPtrPointerType<T[]> {
            typedef T* type;
        };
    } // namespace traits

    template <typename T, typename D = DefaultDeleter<T> > class OwningPtr {
    public:
        typedef T element_type;
        typedef T& reference_type;
        typedef D deleter_type;
        typedef typename traits::OwningPtrPointerType<T>::type pointer;
        typedef OwningPtr<T, D> type;

        OwningPtr()
            : p_(NULL)
        {
        }

        explicit OwningPtr(pointer p)
            : p_(p)
        {
        }

        ~OwningPtr() { reset(); }

        void reset(pointer p = pointer())
        {
            pointer oldPtr(p_);
            p_ = p;
            if (oldPtr) {
                invokeDeleter(oldPtr);
            }
        }

        pointer release()
        {
            pointer ret(p_);
            p_ = NULL;
            return ret;
        }

        void swap(type& other) { std::swap(p_, other.p_); }

        pointer get() const { return p_; }

        pointer operator->() const
        {
            VRPN_ASSERT_MSG(valid(),
                            "attempt to use operator-> on a null pointer");
            return p_;
        }

        reference_type operator*() const
        {
            VRPN_ASSERT_MSG(valid(),
                            "attempt to use operator* on a null pointer");
            return *p_;
        }

        bool valid() const { return p_ != NULL; }

        typedef pointer type::*unspecified_bool_type;
        operator unspecified_bool_type() const
        {
            return valid() ? &type::p_ : NULL;
        }


        bool operator!() const { return !valid(); }
 
    private:
        void invokeDeleter(pointer p) { deleter_type()(p); }
        // non-copyable
        OwningPtr(OwningPtr const&);
        // Non-assignable
        OwningPtr& operator=(OwningPtr const&);

        pointer p_;
    };
 
    template <typename T, typename D>
    inline void swap(OwningPtr<T, D>& lhs, OwningPtr<T, D>& rhs)
    {
        lhs.swap(rhs);
    }
 
    template <typename T, typename D>
    inline typename traits::OwningPtrPointerType<T>::type
    get_pointer(OwningPtr<T, D> const& ptr)
    {
        return ptr.get();
    }
 
    template <typename T, typename D1, typename D2>
    inline bool operator==(OwningPtr<T, D1> const& lhs,
                           OwningPtr<T, D2> const& rhs)
    {
        return lhs.get() == rhs.get();
    }
 
    template <typename T, typename D>
    inline bool operator==(OwningPtr<T, D> const& lhs,
                           typename traits::OwningPtrPointerType<T>::type rhs)
    {
        return lhs.get() == rhs;
    }
 
    template <typename T, typename D>
    inline bool operator==(typename traits::OwningPtrPointerType<T>::type lhs,
                           OwningPtr<T, D> const& rhs)
    {
        return lhs == rhs.get();
    }
 
    template <typename T, typename D1, typename D2>
    inline bool operator!=(OwningPtr<T, D1> const& lhs,
                           OwningPtr<T, D2> const& rhs)
    {
        return lhs.get() != rhs.get();
    }
    template <typename T, typename D>
    inline bool operator!=(OwningPtr<T, D> const& lhs,
                           typename traits::OwningPtrPointerType<T>::type rhs)
    {
        return lhs.get() != rhs;
    }
 
    template <typename T, typename D>
    inline bool operator!=(typename traits::OwningPtrPointerType<T>::type lhs,
                           OwningPtr<T, D> const& rhs)
    {
        return lhs != rhs.get();
    }
} // namespace vrpn
 
#endif // INCLUDED_vrpn_OwningPtr_h_GUID_A2A96325_1863_458B_A567_6FD968CB1321