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