Array.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020, NVIDIA CORPORATION.  All rights reserved.
 *
 * NVIDIA CORPORATION and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA CORPORATION is strictly prohibited.
 */
 
#ifndef CVCORE_ARRAY_H
#define CVCORE_ARRAY_H
 
#include <cassert>
#include <new>
#include <utility>
 
namespace cvcore {
 
class ArrayBase
{
public:
    ArrayBase(std::size_t capacity, std::size_t elemSize, void *dataPtr, bool isCPU);
 
    ArrayBase(std::size_t capacity, std::size_t elemSize, bool isCPU);
 
    ~ArrayBase();
 
    ArrayBase(const ArrayBase &) = delete;
 
    ArrayBase &operator=(const ArrayBase &) = delete;
 
    ArrayBase(ArrayBase &&);
 
    ArrayBase &operator=(ArrayBase &&);
 
    void *getElement(int idx) const;
 
    std::size_t getSize() const;
 
    std::size_t getCapacity() const;
 
    std::size_t getElementSize() const;
 
    void setSize(std::size_t size);
 
    bool isCPU() const;
 
    bool isOwning() const;
 
    void *getData() const;
 
private:
    ArrayBase();
 
    void *m_data;
    std::size_t m_size;
    std::size_t m_capacity;
    std::size_t m_elemSize;
    bool m_isOwning;
    bool m_isCPU;
};
 
template<typename T>
class Array : public ArrayBase
{
public:
    Array()
        : ArrayBase{0, sizeof(T), nullptr, true}
    {
    }
 
    Array(std::size_t size, std::size_t capacity, void *dataPtr, bool isCPU = true)
        : ArrayBase{capacity, sizeof(T), dataPtr, isCPU}
    {
        ArrayBase::setSize(size);
    }
 
    Array(std::size_t capacity, bool isCPU = true)
        : ArrayBase{capacity, sizeof(T), isCPU}
    {
    }
 
    ~Array()
    {
        // call resize here such that CPU-based destructor
        // will call destructors of the objects stored
        // in the array before deallocating the storage
        setSize(0);
    }
 
    Array(const Array &) = delete;
 
    Array &operator=(const Array &) = delete;
 
    Array(Array &&t)
        : Array()
    {
        *this = std::move(t);
    }
 
    Array &operator=(Array &&t)
    {
        static_cast<ArrayBase &>(*this) = std::move(t);
        return *this;
    }
 
    void setSize(std::size_t size)
    {
        const std::size_t oldSize = getSize();
        ArrayBase::setSize(size);
        if (isCPU())
        {
            // shrinking case
            for (std::size_t i = size; i < oldSize; ++i)
            {
                reinterpret_cast<T *>(getElement(i))->~T();
            }
            // expanding case
            for (std::size_t i = oldSize; i < size; ++i)
            {
                new (getElement(i)) T;
            }
        }
    }
 
    const T &operator[](int idx) const
    {
        assert(idx >= 0 && idx < getSize());
        return *reinterpret_cast<T *>(getElement(idx));
    }
 
    T &operator[](int idx)
    {
        assert(idx >= 0 && idx < getSize());
        return *reinterpret_cast<T *>(getElement(idx));
    }
};
 
template<typename T, std::size_t N>
class ArrayN : public ArrayBase
{
public:
    ArrayN()
        : ArrayBase{N, sizeof(T), true}
    {
        setSize(N);
    }
 
    ArrayN(std::size_t size, void *dataPtr, bool isCPU = true)
        : ArrayBase{N, sizeof(T), dataPtr, isCPU}
    {
        ArrayBase::setSize(size);
    }
 
    ArrayN(bool isCPU)
        : ArrayBase{N, sizeof(T), isCPU}
    {
        setSize(N);
    }
 
    ~ArrayN()
    {
        // call resize here such that CPU-based destructor
        // will call destructors of the objects stored
        // in the array before deallocating the storage
        setSize(0);
    }
 
    ArrayN(const ArrayN &) = delete;
 
    ArrayN &operator=(const ArrayN &) = delete;
 
    ArrayN(ArrayN &&t)
        : ArrayN()
    {
        *this = std::move(t);
    }
 
    ArrayN &operator=(ArrayN &&t)
    {
        static_cast<ArrayBase &>(*this) = std::move(t);
        return *this;
    }
 
    void setSize(std::size_t size)
    {
        const std::size_t oldSize = getSize();
        ArrayBase::setSize(size);
        if (isCPU())
        {
            // shrinking case
            for (std::size_t i = size; i < oldSize; ++i)
            {
                reinterpret_cast<T *>(getElement(i))->~T();
            }
            // expanding case
            for (std::size_t i = oldSize; i < size; ++i)
            {
                new (getElement(i)) T;
            }
        }
    }
 
    const T &operator[](int idx) const
    {
        assert(idx >= 0 && idx < getSize());
        return *reinterpret_cast<T *>(getElement(idx));
    }
 
    T &operator[](int idx)
    {
        assert(idx >= 0 && idx < getSize());
        return *reinterpret_cast<T *>(getElement(idx));
    }
};
 
} // namespace cvcore
 
#endif // CVCORE_ARRAY_H