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 35namespace atf { 36namespace utils { 37 38// ------------------------------------------------------------------------ 39// The "auto_array" class. 40// ------------------------------------------------------------------------ 41 42template< class T > 43struct auto_array_ref { 44 T* m_ptr; 45 46 explicit auto_array_ref(T*); 47}; 48 49template< class T > 50auto_array_ref< T >::auto_array_ref(T* ptr) : 51 m_ptr(ptr) 52{ 53} 54 55template< class T > 56class auto_array { 57 T* m_ptr; 58 59public: 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 77template< class T > 78auto_array< T >::auto_array(T* ptr) 79 throw() : 80 m_ptr(ptr) 81{ 82} 83 84template< class T > 85auto_array< T >::auto_array(auto_array< T >& ptr) 86 throw() : 87 m_ptr(ptr.release()) 88{ 89} 90 91template< class T > 92auto_array< T >::auto_array(auto_array_ref< T > ref) 93 throw() : 94 m_ptr(ref.m_ptr) 95{ 96} 97 98template< class T > 99auto_array< T >::~auto_array(void) 100 throw() 101{ 102 if (m_ptr != NULL) 103 delete [] m_ptr; 104} 105 106template< class T > 107T* 108auto_array< T >::get(void) 109 throw() 110{ 111 return m_ptr; 112} 113 114template< class T > 115const T* 116auto_array< T >::get(void) 117 const throw() 118{ 119 return m_ptr; 120} 121 122template< class T > 123T* 124auto_array< T >::release(void) 125 throw() 126{ 127 T* ptr = m_ptr; 128 m_ptr = NULL; 129 return ptr; 130} 131 132template< class T > 133void 134auto_array< T >::reset(T* ptr) 135 throw() 136{ 137 if (m_ptr != NULL) 138 delete [] m_ptr; 139 m_ptr = ptr; 140} 141 142template< class T > 143auto_array< T >& 144auto_array< T >::operator=(auto_array< T >& ptr) 145 throw() 146{ 147 reset(ptr.release()); 148 return *this; 149} 150 151template< class T > 152auto_array< T >& 153auto_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 163template< class T > 164T& 165auto_array< T >::operator[](int pos) 166 throw() 167{ 168 return m_ptr[pos]; 169} 170 171template< class T > 172auto_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 182class 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 190protected: 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