1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2007 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_) 201