/usr/include/ace/Value_Ptr.h is in libace-dev 6.0.3+dfsg-0.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | // -*- C++ -*-
//==========================================================================
/**
* @file Value_Ptr.h
*
* $Id: Value_Ptr.h 92386 2010-10-28 07:44:37Z johnnyw $
*
* Value_Ptr implementation based on code in Herb Sutter's book "More
* Exceptional C++".
*
* @author Ossama Othman <ossama@dre.vanderbilt.edu>
*/
//==========================================================================
#ifndef ACE_VALUE_PTR_H
#define ACE_VALUE_PTR_H
#include "ace/config-lite.h"
#include <algorithm>
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
namespace ACE
{
/**
* @struct VP_traits
*
* @brief @c Value_Ptr traits template structure.
*
* The @c Value_Ptr template class delegates some operations to this
* template traits structure.
*
* Specialize this trait template if cloning through copy
* construction is not sufficient. For example, to avoid slicing
* when copying an object through a base class pointer, one can
* implement a virtual "clone" method that can be used to
* polymorphically invoke the appropriate cloning operation(s).
* That virtual method would then be invoked by the @c VP_traits\<\>
* specialization.
*/
template <typename T>
struct VP_traits
{
/// Copy the given object.
static T * clone (T const * p) { return new T (*p); }
};
/**
* @class Value_Ptr
*
* @brief Smart pointer implementation designed for use as a class
* member.
*
* Using a @c std::auto_ptr\<\> as a class member is sometimes
* problematic since ownership of memory is transferred when copying
* such members. This @c Value_Ptr class is explicitly designed to
* avoid such problems by performing copies of the underlying object
* rather than transfer ownership. This, for example, allows it to
* be readily used as a member in classes placed inside STL
* containers.
*
* @see Item 31 in "More Exceptional C++" by Herb Sutter.
*/
template <typename T>
class Value_Ptr
{
public:
/// Constructor.
explicit Value_Ptr (T * p = 0) : p_ (p) { }
/// Destructor.
~Value_Ptr (void) { delete this->p_; }
/// Deference operator.
T & operator* (void) const { return *this->p_; }
/// Pointer operator.
T * operator-> (void) const { return this->p_; }
/// Non-throwing swap operation used to make assignment strongly
/// exception-safe.
/**
* @note As implemented, the swap operation may not work correctly
* for @c auto_ptr\<\>s, but why would one use an @c
* auto_ptr\<\> as the template argument for this particular
* template class!?
*/
void swap (Value_Ptr & other) { std::swap (this->p_, other.p_); }
/// Copy constructor.
Value_Ptr (Value_Ptr const & other)
: p_ (create_from (other.p_)) { }
/// Assignment operator.
Value_Ptr & operator= (Value_Ptr const & other)
{
// Strongly exception-safe.
Value_Ptr temp (other);
this->swap (temp);
return *this;
}
/// Converting copy constructor.
template <typename U>
Value_Ptr (Value_Ptr<U> const & other)
: p_ (create_from (other.p_)) { }
/// Converting assignment operator.
template <typename U>
Value_Ptr & operator= (Value_Ptr<U> const & other)
{
// Strongly exception-safe.
Value_Ptr temp (other);
this->swap (temp);
return *this;
}
private:
/// Copying method invoked when copy constructing.
template <typename U>
T * create_from (U const * p) const
{
return p ? VP_traits<U>::clone (p) : 0;
}
private:
template <typename U> friend class Value_Ptr;
/// Object owned by this @c Value_Ptr.
T * p_;
};
}
ACE_END_VERSIONED_NAMESPACE_DECL
#endif /* ACE_VALUE_PTR_H */
|