X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=otherlibs%2F_graphics%2Finclude%2FOpenEXR%2FImfArray.h;fp=otherlibs%2F_graphics%2Finclude%2FOpenEXR%2FImfArray.h;h=0000000000000000000000000000000000000000;hb=e4c14cdbdf2fe805e79cd96ded236f57e7b89060;hp=18eb66f39054707c0caf23315618c3ee7135bc31;hpb=454138ff8a20f6edb9b65a910101403d8b520643;p=opencv diff --git a/otherlibs/_graphics/include/OpenEXR/ImfArray.h b/otherlibs/_graphics/include/OpenEXR/ImfArray.h deleted file mode 100644 index 18eb66f..0000000 --- a/otherlibs/_graphics/include/OpenEXR/ImfArray.h +++ /dev/null @@ -1,261 +0,0 @@ -/////////////////////////////////////////////////////////////////////////// -// -// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas -// Digital Ltd. LLC -// -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Industrial Light & Magic nor the names of -// its contributors may be used to endorse or promote products derived -// from this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -/////////////////////////////////////////////////////////////////////////// - - - -#ifndef INCLUDED_IMF_ARRAY_H -#define INCLUDED_IMF_ARRAY_H - -//------------------------------------------------------------------------- -// -// class Array -// class Array2D -// -// "Arrays of T" whose sizes are not known at compile time. -// When an array goes out of scope, its elements are automatically -// deleted. -// -// Usage example: -// -// struct C -// { -// C () {std::cout << "C::C (" << this << ")\n";}; -// virtual ~C () {std::cout << "C::~C (" << this << ")\n";}; -// }; -// -// int -// main () -// { -// Array a(3); -// -// C &b = a[1]; -// const C &c = a[1]; -// C *d = a + 2; -// const C *e = a; -// -// return 0; -// } -// -//------------------------------------------------------------------------- - -namespace Imf { - - -template -class Array -{ - public: - - //----------------------------- - // Constructors and destructors - //----------------------------- - - Array () {_data = 0;} - Array (long size) {_data = new T[size];} - ~Array () {delete [] _data;} - - - //----------------------------- - // Access to the array elements - //----------------------------- - - operator T * () {return _data;} - operator const T * () const {return _data;} - - - //------------------------------------------------------ - // Resize and clear the array (the contents of the array - // are not preserved across the resize operation). - // - // resizeEraseUnsafe() is more memory efficient than - // resizeErase() because it deletes the old memory block - // before allocating a new one, but if allocating the - // new block throws an exception, resizeEraseUnsafe() - // leaves the array in an unusable state. - // - //------------------------------------------------------ - - void resizeErase (long size); - void resizeEraseUnsafe (long size); - - - private: - - Array (const Array &); // Copying and assignment - Array & operator = (const Array &); // are not implemented - - T * _data; -}; - - -template -class Array2D -{ - public: - - //----------------------------- - // Constructors and destructors - //----------------------------- - - Array2D (); // empty array, 0 by 0 elements - Array2D (long sizeX, long sizeY); // sizeX by sizeY elements - ~Array2D (); - - - //----------------------------- - // Access to the array elements - //----------------------------- - - T * operator [] (long x); - const T * operator [] (long x) const; - - - //------------------------------------------------------ - // Resize and clear the array (the contents of the array - // are not preserved across the resize operation). - // - // resizeEraseUnsafe() is more memory efficient than - // resizeErase() because it deletes the old memory block - // before allocating a new one, but if allocating the - // new block throws an exception, resizeEraseUnsafe() - // leaves the array in an unusable state. - // - //------------------------------------------------------ - - void resizeErase (long sizeX, long sizeY); - void resizeEraseUnsafe (long sizeX, long sizeY); - - - private: - - Array2D (const Array2D &); // Copying and assignment - Array2D & operator = (const Array2D &); // are not implemented - - long _sizeY; - T * _data; -}; - - -//--------------- -// Implementation -//--------------- - -template -inline void -Array::resizeErase (long size) -{ - T *tmp = new T[size]; - delete [] _data; - _data = tmp; -} - - -template -inline void -Array::resizeEraseUnsafe (long size) -{ - delete [] _data; - _data = 0; - _data = new T[size]; -} - - -template -inline -Array2D::Array2D (): - _sizeY (0), _data (0) -{ - // emtpy -} - - -template -inline -Array2D::Array2D (long sizeX, long sizeY): - _sizeY (sizeY), _data (new T[sizeX * sizeY]) -{ - // emtpy -} - - -template -inline -Array2D::~Array2D () -{ - delete [] _data; -} - - -template -inline T * -Array2D::operator [] (long x) -{ - return _data + x * _sizeY; -} - - -template -inline const T * -Array2D::operator [] (long x) const -{ - return _data + x * _sizeY; -} - - -template -inline void -Array2D::resizeErase (long sizeX, long sizeY) -{ - T *tmp = new T[sizeX * sizeY]; - delete [] _data; - _sizeY = sizeY; - _data = tmp; -} - - -template -inline void -Array2D::resizeEraseUnsafe (long sizeX, long sizeY) -{ - delete [] _data; - _data = 0; - _sizeY = 0; - _data = new T[sizeX * sizeY]; - _sizeY = sizeY; -} - - -} // namespace Imf - -#endif