vrpn_OwningPtr.h

浏览该文件的文档.

 
//                  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