//

// SPDX-License-Identifier: BSD-3-Clause

// Copyright (c) Contributors to the OpenEXR Project.

//

#ifndef INCLUDED_IMF_ARRAY_H

#define INCLUDED_IMF_ARRAY_H

#include "ImfForward.h"

#include "IexBaseExc.h"

#include "IexMathExc.h"

#include <cstddef>

#include <cstdint>

#include <limits>

//-------------------------------------------------------------------------

//

// 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 <C> a(3);

//

//      C &b = a[1];

//      const C &c = a[1];

//      C *d = a + 2;

//      const C *e = a;

//

//      return 0;

//  }

//

//-------------------------------------------------------------------------

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_ENTER

template <class T> class IMF_EXPORT_TEMPLATE_TYPE Array

{

public:

    //-----------------------------

    // Constructors and destructors

    //-----------------------------

    Array ()

    {

        _data = 0;

        _size = 0;

    }

    Array (long size) : _size (0), _data (0)

    {

        if (size < 0)

            throw IEX_NAMESPACE::ArgExc ("Array size must be non-negative");

        _data = new T[size];

        _size = 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);

    //-------------------------------

    // Return the size of this array.

    //-------------------------------

    long size () const { return _size; }

private:

    Array (const Array&)            = delete;

    Array& operator= (const Array&) = delete;

    Array (Array&&)                 = delete;

    Array& operator= (Array&&)      = delete;

    long _size;

    T*   _data;

};

template <class T> class IMF_EXPORT_TEMPLATE_TYPE 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);

    //-------------------------------

    // Return the size of this array.

    //-------------------------------

    long height () const { return _sizeX; }

    long width () const { return _sizeY; }

private:

    Array2D (const Array2D&)            = delete;

    Array2D& operator= (const Array2D&) = delete;

    Array2D (Array2D&&)                 = delete;

    Array2D& operator= (Array2D&&)      = delete;

    long _sizeX;

    long _sizeY;

    T*   _data;

};

//---------------

// Implementation

//---------------

namespace {

inline size_t

array2DElementCount (long sizeX, long sizeY)

{

    const uint64_t x       = static_cast<uint64_t> (sizeX);

    const uint64_t y       = static_cast<uint64_t> (sizeY);

    const uint64_t maxSize = std::numeric_limits<size_t>::max ();

    if (y > 0 && x > maxSize / y)

        throw IEX_NAMESPACE::OverflowExc ("Array2D dimensions too large");

    return static_cast<size_t> (x * y);

}

} // namespace

template <class T>

inline void

Array<T>::resizeErase (long size)

{

    if (size < 0)

        throw IEX_NAMESPACE::ArgExc ("Array size must be non-negative");

    T* tmp = new T[size];

    delete[] _data;

    _size = size;

    _data = tmp;

}

template <class T>

inline void

Array<T>::resizeEraseUnsafe (long size)

{

    if (size < 0)

        throw IEX_NAMESPACE::ArgExc ("Array size must be non-negative");

    delete[] _data;

    _data = 0;

    _size = 0;

    _data = new T[size];

    _size = size;

}

template <class T>

inline Array2D<T>::Array2D () : _sizeX (0), _sizeY (0), _data (0)

{

    // empty

}

Imf_3_4::Array2D<Imf_3_4::Rgba>::Array2D()

Line

Count

Source

209

2.28k

inline Array2D<T>::Array2D () : _sizeX (0), _sizeY (0), _data (0)

210

2.28k

{

211

    // empty

212

2.28k

}

Unexecuted instantiation: Imf_3_4::Array2D<Imf_3_4::PreviewRgba>::Array2D()

template <class T>

inline Array2D<T>::Array2D (long sizeX, long sizeY)

    : _sizeX (0), _sizeY (0), _data (0)

{

    if (sizeX < 0 || sizeY < 0)

        throw IEX_NAMESPACE::ArgExc ("Array2D dimensions must be non-negative");

    _sizeX = sizeX;

    _sizeY = sizeY;

    _data  = new T[array2DElementCount (sizeX, sizeY)];

}

template <class T> inline Array2D<T>::~Array2D ()

{

    delete[] _data;

}

Imf_3_4::Array2D<Imf_3_4::Rgba>::~Array2D()

Line

Count

Source

227

2.28k

{

228

2.28k

    delete[] _data;

229

2.28k

}

Unexecuted instantiation: Imf_3_4::Array2D<Imf_3_4::PreviewRgba>::~Array2D()

template <class T>

inline T*

Array2D<T>::operator[] (long x)

{

    return _data + x * _sizeY;

}

Imf_3_4::Array2D<Imf_3_4::Rgba>::operator[](long)

Line

Count

Source

234

486M

{

235

486M

    return _data + x * _sizeY;

236

486M

}

Unexecuted instantiation: Imf_3_4::Array2D<Imf_3_4::PreviewRgba>::operator[](long)

template <class T>

inline const T*

Array2D<T>::operator[] (long x) const

{

    return _data + x * _sizeY;

}

template <class T>

inline void

Array2D<T>::resizeErase (long sizeX, long sizeY)

{

    if (sizeX < 0 || sizeY < 0)

        throw IEX_NAMESPACE::ArgExc ("Array2D dimensions must be non-negative");

    T* tmp = new T[array2DElementCount (sizeX, sizeY)];

    delete[] _data;

    _sizeX = sizeX;

    _sizeY = sizeY;

    _data  = tmp;

}

Imf_3_4::Array2D<Imf_3_4::Rgba>::resizeErase(long, long)

Line

Count

Source

248

2.28k

{

249

2.28k

    if (sizeX < 0 || sizeY < 0)

250

0

        throw IEX_NAMESPACE::ArgExc ("Array2D dimensions must be non-negative");

251

252

2.28k

    T* tmp = new T[array2DElementCount (sizeX, sizeY)];

253

2.28k

    delete[] _data;

254

2.28k

    _sizeX = sizeX;

255

2.28k

    _sizeY = sizeY;

256

2.28k

    _data  = tmp;

257

2.28k

}

Unexecuted instantiation: Imf_3_4::Array2D<Imf_3_4::PreviewRgba>::resizeErase(long, long)

template <class T>

inline void

Array2D<T>::resizeEraseUnsafe (long sizeX, long sizeY)

{

    if (sizeX < 0 || sizeY < 0)

        throw IEX_NAMESPACE::ArgExc ("Array2D dimensions must be non-negative");

    delete[] _data;

    _data  = 0;

    _sizeX = 0;

    _sizeY = 0;

    _data  = new T[array2DElementCount (sizeX, sizeY)];

    _sizeX = sizeX;

    _sizeY = sizeY;

}

OPENEXR_IMF_INTERNAL_NAMESPACE_HEADER_EXIT

#endif