source: NonGTP/OpenEXR/include/IlmImf/ImfArray.h @ 855

Revision 855, 6.2 KB checked in by igarcia, 19 years ago (diff)
RevLine 
[855]1///////////////////////////////////////////////////////////////////////////
2//
3// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
4// Digital Ltd. LLC
5//
6// All rights reserved.
7//
8// Redistribution and use in source and binary forms, with or without
9// modification, are permitted provided that the following conditions are
10// met:
11// *       Redistributions of source code must retain the above copyright
12// notice, this list of conditions and the following disclaimer.
13// *       Redistributions in binary form must reproduce the above
14// copyright notice, this list of conditions and the following disclaimer
15// in the documentation and/or other materials provided with the
16// distribution.
17// *       Neither the name of Industrial Light & Magic nor the names of
18// its contributors may be used to endorse or promote products derived
19// from this software without specific prior written permission.
20//
21// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32//
33///////////////////////////////////////////////////////////////////////////
34
35
36
37#ifndef INCLUDED_IMF_ARRAY_H
38#define INCLUDED_IMF_ARRAY_H
39
40//-------------------------------------------------------------------------
41//
42// class Array
43// class Array2D
44//
45// "Arrays of T" whose sizes are not known at compile time.
46// When an array goes out of scope, its elements are automatically
47// deleted.
48//
49// Usage example:
50//
51//      struct C
52//      {
53//          C ()                {std::cout << "C::C  (" << this << ")\n";};
54//          virtual ~C ()       {std::cout << "C::~C (" << this << ")\n";};
55//      };
56//
57//      int
58//      main ()
59//      {
60//          Array <C> a(3);
61//
62//          C &b = a[1];
63//          const C &c = a[1];
64//          C *d = a + 2;
65//          const C *e = a;
66//
67//          return 0;
68//      }
69//
70//-------------------------------------------------------------------------
71
72namespace Imf {
73
74
75template <class T>
76class Array
77{
78  public:
79
80    //-----------------------------
81    // Constructors and destructors
82    //-----------------------------
83
84     Array ()                           {_data = 0;}
85     Array (long size)                  {_data = new T[size];}
86    ~Array ()                           {delete [] _data;}
87
88
89    //-----------------------------
90    // Access to the array elements
91    //-----------------------------
92
93    operator T * ()                     {return _data;}
94    operator const T * () const         {return _data;}
95
96
97    //------------------------------------------------------
98    // Resize and clear the array (the contents of the array
99    // are not preserved across the resize operation).
100    //
101    // resizeEraseUnsafe() is more memory efficient than
102    // resizeErase() because it deletes the old memory block
103    // before allocating a new one, but if allocating the
104    // new block throws an exception, resizeEraseUnsafe()
105    // leaves the array in an unusable state.
106    //
107    //------------------------------------------------------
108
109    void resizeErase (long size);
110    void resizeEraseUnsafe (long size);
111
112
113  private:
114
115    Array (const Array &);              // Copying and assignment
116    Array & operator = (const Array &); // are not implemented
117
118    T * _data;
119};
120
121
122template <class T>
123class Array2D
124{
125  public:
126
127    //-----------------------------
128    // Constructors and destructors
129    //-----------------------------
130
131     Array2D ();                        // empty array, 0 by 0 elements
132     Array2D (long sizeX, long sizeY);  // sizeX by sizeY elements
133    ~Array2D ();
134
135
136    //-----------------------------
137    // Access to the array elements
138    //-----------------------------
139
140    T *         operator [] (long x);
141    const T *   operator [] (long x) const;
142
143
144    //------------------------------------------------------
145    // Resize and clear the array (the contents of the array
146    // are not preserved across the resize operation).
147    //
148    // resizeEraseUnsafe() is more memory efficient than
149    // resizeErase() because it deletes the old memory block
150    // before allocating a new one, but if allocating the
151    // new block throws an exception, resizeEraseUnsafe()
152    // leaves the array in an unusable state.
153    //
154    //------------------------------------------------------
155
156    void resizeErase (long sizeX, long sizeY);
157    void resizeEraseUnsafe (long sizeX, long sizeY);
158
159
160  private:
161
162    Array2D (const Array2D &);                  // Copying and assignment
163    Array2D & operator = (const Array2D &);     // are not implemented
164
165    long        _sizeY;
166    T *         _data;
167};
168
169
170//---------------
171// Implementation
172//---------------
173
174template <class T>
175inline void
176Array<T>::resizeErase (long size)
177{
178    T *tmp = new T[size];
179    delete [] _data;
180    _data = tmp;
181}
182
183
184template <class T>
185inline void
186Array<T>::resizeEraseUnsafe (long size)
187{
188    delete [] _data;
189    _data = 0;
190    _data = new T[size];
191}
192
193
194template <class T>
195inline
196Array2D<T>::Array2D ():
197    _sizeY (0), _data (0)
198{
199    // emtpy
200}
201
202
203template <class T>
204inline
205Array2D<T>::Array2D (long sizeX, long sizeY):
206    _sizeY (sizeY), _data (new T[sizeX * sizeY])
207{
208    // emtpy
209}
210
211
212template <class T>
213inline
214Array2D<T>::~Array2D ()
215{
216    delete [] _data;
217}
218
219
220template <class T>
221inline T *     
222Array2D<T>::operator [] (long x)
223{
224    return _data + x * _sizeY;
225}
226
227
228template <class T>
229inline const T *
230Array2D<T>::operator [] (long x) const
231{
232    return _data + x * _sizeY;
233}
234
235
236template <class T>
237inline void
238Array2D<T>::resizeErase (long sizeX, long sizeY)
239{
240    T *tmp = new T[sizeX * sizeY];
241    delete [] _data;
242    _sizeY = sizeY;
243    _data = tmp;
244}
245
246
247template <class T>
248inline void
249Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY)
250{
251    delete [] _data;
252    _data = 0;
253    _sizeY = 0;
254    _data = new T[sizeX * sizeY];
255    _sizeY = sizeY;
256}
257
258
259} // namespace Imf
260
261#endif
Note: See TracBrowser for help on using the repository browser.