K2SmartPtr.h

//========================================================================================
// 
// $File$
// 
// Owner: Mat Marcus
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
// 
// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. Permission to copy,
// use, modify, sell and distribute this software is granted provided this
// copyright notice appears in all copies. This software is provided "as is"
// without express or implied warranty, and with no claim as to its
// suitability for any purpose.
// 
// Also based on Loki/SmartPtr.h
// 
// The Loki Library
// Copyright (c) 2001 by Andrei Alexandrescu
// This code accompanies the book:
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design 
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
// Permission to use, copy, modify, distribute and sell this software for any 
// purpose is hereby granted without fee, provided that the above copyright 
// notice appear in all copies and that both that copyright notice and this 
// permission notice appear in supporting documentation.
// The author or Addison-Welsey Longman make no representations about the 
// suitability of this software for any purpose. It is provided "as is" 
// without express or implied warranty.
// 
//========================================================================================

#ifndef __K2SmartPtr__
#define __K2SmartPtr__

#include <boost/config.hpp> // for broken compiler workarounds
#include <cstddef> // for std::size_t
#include <memory> // for std::auto_ptr
#include <algorithm> // for std::swap
#include <boost/utility.hpp> // for boost::noncopyable
#include <functional> // for std::less

namespace K2 {

// scoped_ptr --------------------------------------------------------------//

template<typename T> class scoped_ptr : boost::noncopyable {
 typedef scoped_ptr Self;
 T* ptr;

public:
 typedef T element_type; // The type of the stored pointer

 explicit scoped_ptr( T* p=0 ) : ptr(p) {}

 ~scoped_ptr() { delete ptr; }

 void reset( T* p=0 ) { if ( ptr != p ) { delete ptr; ptr = p; } }

 T* release( ) { T* ret = ptr; ptr = nil; return ret; }

 T& operator*() const { return *ptr; } 

#ifdef BOOST_MSVC
#endif

 T* operator->() const { return ptr; } 
#ifdef BOOST_MSVC
#endif 

 T* get() const { return ptr; } 


 bool operator!() const // Enables "if (!sp) ..."
 { return get() == 0; }
 
 inline friend bool operator==(const Self& lhs,
 const T* rhs)
 { return lhs.get() == rhs; }
 
 inline friend bool operator==(const T* lhs,
 const Self& rhs)
 { return rhs == lhs; }
 
 inline friend bool operator!=(const Self& lhs,
 const T* rhs)
 { return !(lhs == rhs); }
 
 inline friend bool operator!=(const T* lhs,
 const Self& rhs)
 { return rhs != lhs; }

#if 0
 private:
 // Helper for enabling 'if (sp)'
 class Tester
 {
 void operator delete(void*);
 };
 
 public:
 // enable 'if (sp)'
 operator Tester*() const
 {
 if (!*this) return 0;
 static Tester t;
 return &t;
 }
#else
 operator void*() const {
 return get();
 }
#endif

 }; // scoped_ptr


// scoped_array ------------------------------------------------------------//

template<typename T> class scoped_array : boost::noncopyable {

 T* ptr;

 public:
 typedef T element_type;

 explicit scoped_array( T* p=0 ) : ptr(p) {} 

 ~scoped_array() { delete [] ptr; }

 void reset( T* p=0 ) { if ( ptr != p ) {delete [] ptr; ptr=p;} }

 T* get() const { return ptr; } 

 T* release( ) { T* ret = ptr; ptr = nil; return ret; }

 T& operator[](std::size_t i) const { return ptr[i]; } 
 }; // scoped_array

// shared_array ------------------------------------------------------------//

template<typename T> class shared_array {
 typedef shared_array Self; 
 public:
 typedef T element_type;
 typedef object_type data_type;

 explicit shared_array(T* p =0) : px(p) {
 pn = new long(1); // fix: prevent leak if new throws
 }

 shared_array(const shared_array& r) : px(r.px) 
 { ++*(pn = r.pn); }

 ~shared_array() { dispose(); }

 shared_array& operator=(const shared_array& r) {
 if (pn != r.pn) { // Q: why not px != r.px? A: fails when both px == 0
 ++*r.pn; // done before dispose() in case r.pn transitively
 // dependent on *this (bug reported by Thomas Maeder)
 dispose();
 px = r.px;
 pn = r.pn;
 }
 return *this;
 } // operator=

 void reset(T* p=0) {
 if ( px == p ) return; // fix: self-assignment safe
 if (--*pn == 0) { delete [] px; }
 else { // allocate new reference counter
 pn = new long; // fix: prevent leak if new throws
 } // allocate new reference counter
 *pn = 1;
 px = p;
 } // reset

 T* get() const { return px; } 
 T& operator[](std::size_t i) const { return px[i]; } 
 
 long use_count() const { return *pn; } 

 bool unique() const { return *pn == 1; } 

 void swap(shared_array<T>& other) 
 { std::swap(px,other.px); std::swap(pn,other.pn); }

 bool operator!() const // Enables "if (!sp) ..."
 { return get() == 0; }
 
 inline friend bool operator==(const Self& lhs,
 const T* rhs)
 { return lhs.get() == rhs; }
 
 inline friend bool operator==(const T* lhs,
 const Self& rhs)
 { return rhs == lhs; }
 
 inline friend bool operator!=(const Self& lhs,
 const T* rhs)
 { return !(lhs == rhs); }
 
 inline friend bool operator!=(const T* lhs,
 const Self& rhs)
 { return rhs != lhs; }

#if 0
 private:
 // Helper for enabling 'if (sp)'
 class Tester
 {
 void operator delete(void*);
 };
 
 public:
 // enable 'if (sp)'
 operator Tester*() const
 {
 if (!*this) return 0;
 static Tester t;
 return &t;
 }
#else
 operator void*() const {
 return get();
 }
#endif
 private:
 T* px; // contained pointer
 long* pn; // ptr to reference counter

 void dispose() { if (--*pn == 0) { delete [] px; delete pn; } }
 
 }; // shared_array

template<typename T>
 inline bool operator==(const shared_array<T>& a, const shared_array<T>& b)
 { return a.get() == b.get(); }

template<typename T>
 inline bool operator!=(const shared_array<T>& a, const shared_array<T>& b)
 { return a.get() != b.get(); }

} // namespace K2



// specializations for things in namespace std -----------------------------//

#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

namespace std {

template<typename T>
 inline void swap(K2::shared_array<T>& a, K2::shared_array<T>& b)
 { a.swap(b); }

// Specialize std::less so we can use shared pointers and arrays as keys in
// associative collections.

// It's still a controversial question whether this is better than supplying
// a full range of comparison operators (<, >, <=, >=).

template<typename T>
 struct less< K2::shared_array<T> >
 : function<bool(K2::shared_array<T>, K2::shared_array<T>) >
 {
 bool operator()(const K2::shared_array<T>& a,
 const K2::shared_array<T>& b) const
 { return less<T*>()(a.get(),b.get()); }
 };

} // namespace std

#endif // ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

#endif // __K2SmartPtr__