/src/FreeImage/Source/OpenEXR/IlmImf/ImfAttribute.h

  1///////////////////////////////////////////////////////////////////////////
  2//
  3// Copyright (c) 2004, 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_ATTRIBUTE_H
 38#define INCLUDED_IMF_ATTRIBUTE_H
 39
 40//-----------------------------------------------------------------------------
 41//
 42//	class Attribute
 43//
 44//-----------------------------------------------------------------------------
 45
 46#include "IexBaseExc.h"
 47#include <ImfIO.h>
 48#include <ImfXdr.h>
 49
 50
 51namespace Imf {
 52
 53
 54class Attribute
 55{
 56  public:
 57
 58    //---------------------------
 59    // Constructor and destructor
 60    //---------------------------
 61
 62    Attribute ();
 63    virtual ~Attribute ();
 64
 65
 66    //-------------------------------
 67    // Get this attribute's type name
 68    //-------------------------------
 69
 70    virtual const char *	typeName () const = 0;
 71
 72
 73    //------------------------------
 74    // Make a copy of this attribute
 75    //------------------------------
 76
 77    virtual Attribute *		copy () const = 0;
 78
 79
 80    //----------------------------------------
 81    // Type-specific attribute I/O and copying
 82    //----------------------------------------
 83
 84    virtual void		writeValueTo (OStream &os,
 85					      int version) const = 0;
 86
 87    virtual void		readValueFrom (IStream &is,
 88					       int size,
 89					       int version) = 0;
 90
 91    virtual void		copyValueFrom (const Attribute &other) = 0;
 92
 93
 94    //------------------
 95    // Attribute factory
 96    //------------------
 97
 98    static Attribute *		newAttribute (const char typeName[]);
 99
100
101    //-----------------------------------------------------------
102    // Test if a given attribute type has already been registered
103    //-----------------------------------------------------------
104
105    static bool			knownType (const char typeName[]);
106
107
108  protected:
109
110    //--------------------------------------------------
111    // Register an attribute type so that newAttribute()
112    // knows how to make objects of this type.
113    //--------------------------------------------------
114
115    static void		registerAttributeType (const char typeName[],
116					       Attribute *(*newAttribute)());
117
118    //------------------------------------------------------
119    // Un-register an attribute type so that newAttribute()
120    // no longer knows how to make objects of this type (for
121    // debugging only).
122    //------------------------------------------------------
123
124    static void		unRegisterAttributeType (const char typeName[]);
125};
126
127
128//-------------------------------------------------
129// Class template for attributes of a specific type
130//-------------------------------------------------
131
132template <class T>
133class TypedAttribute: public Attribute
134{
135  public:
136
137    //----------------------------
138    // Constructors and destructor
139    //------------_---------------
140
141    TypedAttribute ();
142    TypedAttribute (const T &value);
143    TypedAttribute (const TypedAttribute<T> &other);
144    virtual ~TypedAttribute ();
145
146
147    //--------------------------------
148    // Access to the attribute's value
149    //--------------------------------
150
151    T &					value ();
152    const T &				value () const;
153
154
155    //--------------------------------
156    // Get this attribute's type name.
157    //--------------------------------
158
159    virtual const char *		typeName () const;
160    
161
162    //---------------------------------------------------------
163    // Static version of typeName()
164    // This function must be specialized for each value type T.
165    //---------------------------------------------------------
166
167    static const char *			staticTypeName ();
168    
169
170    //---------------------
171    // Make a new attribute
172    //---------------------
173
174    static Attribute *			makeNewAttribute ();
175
176
177    //------------------------------
178    // Make a copy of this attribute
179    //------------------------------
180
181    virtual Attribute *			copy () const;
182
183
184    //-----------------------------------------------------------------
185    // Type-specific attribute I/O and copying.
186    // Depending on type T, these functions may have to be specialized.
187    //-----------------------------------------------------------------
188
189    virtual void		writeValueTo (OStream &os,
190					      int version) const;
191
192    virtual void		readValueFrom (IStream &is,
193					       int size,
194					       int version);
195
196    virtual void		copyValueFrom (const Attribute &other);
197
198
199    //------------------------------------------------------------
200    // Dynamic casts that throw exceptions instead of returning 0.
201    //------------------------------------------------------------
202
203    static TypedAttribute *		cast (Attribute *attribute);
204    static const TypedAttribute *	cast (const Attribute *attribute);
205    static TypedAttribute &		cast (Attribute &attribute);
206    static const TypedAttribute &	cast (const Attribute &attribute);
207
208
209    //---------------------------------------------------------------
210    // Register this attribute type so that Attribute::newAttribute()
211    // knows how to make objects of this type.
212    //
213    // Note that this function is not thread-safe because it modifies
214    // a global variable in the IlmIlm library.  A thread in a multi-
215    // threaded program may call registerAttributeType() only when no
216    // other thread is accessing any functions or classes in the
217    // IlmImf library.
218    //
219    //---------------------------------------------------------------
220
221    static void				registerAttributeType ();
222
223
224    //-----------------------------------------------------
225    // Un-register this attribute type (for debugging only)
226    //-----------------------------------------------------
227
228    static void				 unRegisterAttributeType ();
229
230
231  private:
232
233    T					_value;
234};
235
236
237//------------------------------------
238// Implementation of TypedAttribute<T>
239//------------------------------------
240
241template <class T>
242TypedAttribute<T>::TypedAttribute ():
243    Attribute (),
244    _value (T())
245{
246    // empty
247}
248
249
250template <class T>
251TypedAttribute<T>::TypedAttribute (const T &value):
252    Attribute (),
253    _value (value)
254{
255    // empty
256}
257
258
259template <class T>
260TypedAttribute<T>::TypedAttribute (const TypedAttribute<T> &other):
261    Attribute (other),
262    _value ()
263{
264    copyValueFrom (other);
265}
266
267
268template <class T>
269TypedAttribute<T>::~TypedAttribute ()
270{
271    // empty
272}
273
274
275template <class T>
276inline T &
277TypedAttribute<T>::value ()
278{
279    return _value;
280}
281
282
283template <class T>
284inline const T &
285TypedAttribute<T>::value () const
286{
287    return _value;
288}
289
290
291template <class T>
292const char *	
293TypedAttribute<T>::typeName () const
294{
295    return staticTypeName();
296}
297
298
299template <class T>
300Attribute *
301TypedAttribute<T>::makeNewAttribute ()
302{
303    return new TypedAttribute<T>();
304}
305
306
307template <class T>
308Attribute *
309TypedAttribute<T>::copy () const
310{
311    Attribute * attribute = new TypedAttribute<T>();
312    attribute->copyValueFrom (*this);
313    return attribute;
314}
315
316
317template <class T>
318void		
319TypedAttribute<T>::writeValueTo (OStream &os, int version) const
320{
321    Xdr::write <StreamIO> (os, _value);
322}
323
324
325template <class T>
326void		
327TypedAttribute<T>::readValueFrom (IStream &is, int size, int version)
328{
329    Xdr::read <StreamIO> (is, _value);
330}
331
332
333template <class T>
334void		
335TypedAttribute<T>::copyValueFrom (const Attribute &other)
336{
337    _value = cast(other)._value;
338}
339
340
341template <class T>
342TypedAttribute<T> *
343TypedAttribute<T>::cast (Attribute *attribute)
344{
345    TypedAttribute<T> *t =
346	dynamic_cast <TypedAttribute<T> *> (attribute);
347
348    if (t == 0)
349	throw Iex::TypeExc ("Unexpected attribute type.");
350
351    return t;
352}
353
354
355template <class T>
356const TypedAttribute<T> *
357TypedAttribute<T>::cast (const Attribute *attribute)
358{
359    const TypedAttribute<T> *t =
360	dynamic_cast <const TypedAttribute<T> *> (attribute);
361
362    if (t == 0)
363	throw Iex::TypeExc ("Unexpected attribute type.");
364
365    return t;
366}
367
368
369template <class T>
370inline TypedAttribute<T> &	
371TypedAttribute<T>::cast (Attribute &attribute)
372{
373    return *cast (&attribute);
374}
375
376
377template <class T>
378inline const TypedAttribute<T> &
379TypedAttribute<T>::cast (const Attribute &attribute)
380{
381    return *cast (&attribute);
382}
383
384
385template <class T>
386inline void
387TypedAttribute<T>::registerAttributeType ()
388{
389    Attribute::registerAttributeType (staticTypeName(), makeNewAttribute);
390}
391
392
393template <class T>
394inline void
395TypedAttribute<T>::unRegisterAttributeType ()
396{
397    Attribute::unRegisterAttributeType (staticTypeName());
398}
399
400
401} // namespace Imf
402
403#if defined(OPENEXR_DLL) && defined(_MSC_VER)
404    // Tell MS VC++ to disable "non dll-interface class used as base
405    // for dll-interface class" and "no suitable definition provided
406    // for explicit template"
407    #pragma warning (disable : 4275 4661)
408
409    #if defined (ILMIMF_EXPORTS)
410 	#define IMF_EXPIMP_TEMPLATE
411    #else
412 	#define IMF_EXPIMP_TEMPLATE extern
413    #endif
414
415    IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<float>;
416    IMF_EXPIMP_TEMPLATE template class Imf::TypedAttribute<double>;
417
418    #pragma warning(default : 4251)
419    #undef EXTERN_TEMPLATE
420#endif
421
422// Metrowerks compiler wants the .cpp file inlined, too
423#ifdef __MWERKS__
424#include <ImfAttribute.cpp>
425#endif
426
427#endif