external/bsd/atf/dist/atf-c++/utils.hpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2007, 2008, 2009 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 #if !defined(_ATF_CXX_UTILS_HPP_)
  31 #define _ATF_CXX_UTILS_HPP_
  32
  33 #include <cstddef>
  34
  35 namespace atf {
  36 namespace utils {
  37
  38 // ------------------------------------------------------------------------
  39 // The "auto_array" class.
  40 // ------------------------------------------------------------------------
  41
  42 template< class T >
  43 struct auto_array_ref {
  44     T* m_ptr;
  45
  46     explicit auto_array_ref(T*);
  47 };
  48
  49 template< class T >
  50 auto_array_ref< T >::auto_array_ref(T* ptr) :
  51     m_ptr(ptr)
  52 {
  53 }
  54
  55 template< class T >
  56 class auto_array {
  57     T* m_ptr;
  58
  59 public:
  60     auto_array(T* = NULL) throw();
  61     auto_array(auto_array< T >&) throw();
  62     auto_array(auto_array_ref< T >) throw();
  63     ~auto_array(void) throw();
  64
  65     T* get(void) throw();
  66     const T* get(void) const throw();
  67     T* release(void) throw();
  68     void reset(T* = NULL) throw();
  69
  70     auto_array< T >& operator=(auto_array< T >&) throw();
  71     auto_array< T >& operator=(auto_array_ref< T >) throw();
  72
  73     T& operator[](int) throw();
  74     operator auto_array_ref< T >(void) throw();
  75 };
  76
  77 template< class T >
  78 auto_array< T >::auto_array(T* ptr)
  79     throw() :
  80     m_ptr(ptr)
  81 {
  82 }
  83
  84 template< class T >
  85 auto_array< T >::auto_array(auto_array< T >& ptr)
  86     throw() :
  87     m_ptr(ptr.release())
  88 {
  89 }
  90
  91 template< class T >
  92 auto_array< T >::auto_array(auto_array_ref< T > ref)
  93     throw() :
  94     m_ptr(ref.m_ptr)
  95 {
  96 }
  97
  98 template< class T >
  99 auto_array< T >::~auto_array(void)
 100     throw()
 101 {
 102     if (m_ptr != NULL)
 103         delete [] m_ptr;
 104 }
 105
 106 template< class T >
 107 T*
 108 auto_array< T >::get(void)
 109     throw()
 110 {
 111     return m_ptr;
 112 }
 113
 114 template< class T >
 115 const T*
 116 auto_array< T >::get(void)
 117     const throw()
 118 {
 119     return m_ptr;
 120 }
 121
 122 template< class T >
 123 T*
 124 auto_array< T >::release(void)
 125     throw()
 126 {
 127     T* ptr = m_ptr;
 128     m_ptr = NULL;
 129     return ptr;
 130 }
 131
 132 template< class T >
 133 void
 134 auto_array< T >::reset(T* ptr)
 135     throw()
 136 {
 137     if (m_ptr != NULL)
 138         delete [] m_ptr;
 139     m_ptr = ptr;
 140 }
 141
 142 template< class T >
 143 auto_array< T >&
 144 auto_array< T >::operator=(auto_array< T >& ptr)
 145     throw()
 146 {
 147     reset(ptr.release());
 148     return *this;
 149 }
 150
 151 template< class T >
 152 auto_array< T >&
 153 auto_array< T >::operator=(auto_array_ref< T > ref)
 154     throw()
 155 {
 156     if (m_ptr != ref.m_ptr) {
 157         delete [] m_ptr;
 158         m_ptr = ref.m_ptr;
 159     }
 160     return *this;
 161 }
 162
 163 template< class T >
 164 T&
 165 auto_array< T >::operator[](int pos)
 166     throw()
 167 {
 168     return m_ptr[pos];
 169 }
 170
 171 template< class T >
 172 auto_array< T >::operator auto_array_ref< T >(void)
 173     throw()
 174 {
 175     return auto_array_ref< T >(release());
 176 }
 177
 178 // ------------------------------------------------------------------------
 179 // The "noncopyable" class.
 180 // ------------------------------------------------------------------------
 181
 182 class noncopyable {
 183     // The class cannot be empty; otherwise we get ABI-stability warnings
 184     // during the build, which will break it due to strict checking.
 185     int m_noncopyable_dummy;
 186
 187     noncopyable(const noncopyable& nc);
 188     noncopyable& operator=(const noncopyable& nc);
 189
 190 protected:
 191     // Explicitly needed to provide some non-private functions.  Otherwise
 192     // we also get some warnings during the build.
 193     noncopyable(void) {}
 194     ~noncopyable(void) {}
 195 };
 196
 197 } // namespace utils
 198 } // namespace atf
 199
 200 #endif // !defined(_ATF_CXX_UTILS_HPP_)