array.h

Go to the documentation of this file.

#line 1 "D:/Jenkins/workspace/EMS/ECG/ufe/full/ufe-full-python3.13-windows/ufe/include/array.h"
#ifndef UFE_ARRAY_H
#define UFE_ARRAY_H
 
// ===========================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// The use of this software is subject to the Autodesk Terms of Use or other
// license agreement provided at the time of installation or download, or
// which otherwise accompanies this software.
// ===========================================================================
 
#include "common/ufeExport.h"
 
#include "types.h"
 
#include <algorithm>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <string>
#include <vector>
 
UFE_NS_DEF {
 
 
 
// Forward declaration with specialization.
template<typename T> class UFE_SDK_DECL Array;
 
template<typename T>
class UFE_SDK_DECL Array {
public:
 
    // Standard container type definitions.
    typedef T           value_type;
    typedef T&          reference;
    typedef const T&    const_reference;
    typedef T*          pointer;
    typedef const T*    const_pointer;
 
    // A pointer to an element of an array satisfies all requirements of LegacyRandomAccessIterator.
    using iterator = T*;
    using const_iterator = const T*;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
    using size_type = std::size_t;
 
 
    Array();
 
    Array(const Array&);
 
    explicit Array(size_type count);
 
    explicit Array(size_type count, const value_type& value);
 
    Array(std::initializer_list<value_type> il);
 
    template<typename InputIt>
    Array(InputIt first, InputIt last)
        : Array()
    {
        assign(first, last);
    }
 
    Array(Array&&) noexcept;
 
    ~Array();
 
 
 
    Array& operator=(const Array& other);
 
    Array& operator=(Array&& other) noexcept;
 
    Array& operator=(std::initializer_list<value_type> il);
 
 
 
    iterator begin();
 
    const_iterator begin() const;
 
    const_iterator cbegin() const { return begin(); }
 
    iterator end();
 
    const_iterator end() const;
 
    const_iterator cend() const { return end(); }
 
    reverse_iterator rbegin() { return reverse_iterator(end()); }
 
    const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
 
    const_reverse_iterator crbegin() const { return rbegin(); }
 
    reverse_iterator rend() { return reverse_iterator(begin()); }
 
    const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
 
    const_reverse_iterator crend() const { return rend(); }
 
 
 
    size_type size() const;
 
    size_type capacity() const;
 
    bool empty() const;
 
    void reserve(size_type n);
 
 
 
    reference operator[](size_type n);
 
    const_reference operator[](size_type n) const;
 
    reference at(size_type n);
 
    const_reference at(size_type n) const;
 
    reference front();
 
    const_reference front() const;
 
    reference back();
 
    const_reference back() const;
 
    value_type* data();
 
    const value_type* data() const;
 
 
 
    void assign(size_type n, const value_type& val);
 
    template<typename InputIt>
    void assign(InputIt first, InputIt last)
    {
        // Because of the hidden implementation, we cannot use the _imp directly here.
        // Use a simple implementation for now that uses existing public methods.
        clear();
        resize(static_cast<size_type>(std::distance(first, last)));
        std::copy(first, last, begin());
    }
 
    void assign(std::initializer_list<value_type> il);
 
    void push_back(const value_type& val);
 
    void push_back(value_type&& val);
 
    void pop_back();
 
    iterator insert(const_iterator position, const value_type& val);
 
    iterator insert(const_iterator position, value_type&& val);
 
    iterator insert(const_iterator position, size_type n, const value_type& val);
 
    template<class InputIt>
    std::enable_if_t<!std::is_integral_v<InputIt>, iterator>
    insert(const_iterator position, InputIt first, InputIt last)
    {
        const size_type insertCount = static_cast<size_type>(std::distance(first, last));
        if (insertCount == 0)
            return begin() + std::distance(cbegin(), position);
 
        const size_type posIndex = static_cast<size_type>(std::distance(cbegin(), position));
        const size_type oldSize = size();
 
        // Check for overlap with internal storage (inserting a range of this array into itself).
        const_pointer dataBegin = data();
        const_pointer dataEnd = data() + oldSize;
        auto is_pointer_in_range = [dataBegin, dataEnd](const_pointer p) {
            return p >= dataBegin && p < dataEnd;
        };
 
        bool overlap = false;
        if constexpr (std::is_pointer_v<InputIt>) {
            // Only check for pointer iterators
            overlap = is_pointer_in_range(first) || is_pointer_in_range(last - 1);
        }
 
        if (overlap) {
            // Copy to temp buffer to avoid overlap
            std::vector<value_type> temp(first, last);
            resize(oldSize + insertCount);
            std::move_backward(begin() + posIndex, begin() + oldSize, end());
            std::copy(temp.begin(), temp.end(), begin() + posIndex);
        } else {
            resize(oldSize + insertCount);
            std::move_backward(begin() + posIndex, begin() + oldSize, end());
            std::copy(first, last, begin() + posIndex);
        }
        return begin() + posIndex;
    }
 
    iterator insert(const_iterator position, std::initializer_list<value_type> il);
 
    iterator erase(iterator position);
 
    iterator erase(const_iterator position);
 
    iterator erase(iterator first, iterator last);
 
    iterator erase(const_iterator first, const_iterator last);
 
    void swap(Array& other);
 
    void resize(size_type count);
 
    void resize(size_type count, const value_type& value);
 
    void clear();
 
    template<typename... Args>
    iterator emplace(const_iterator position, Args&&... args);
 
    template<typename... Args>
    void emplace_back(Args&&... args);
 
 
 
    bool operator==(const Array& other) const;
    bool operator!=(const Array& other) const;
    bool operator<(const Array& other) const;
    bool operator<=(const Array& other) const;
    bool operator>(const Array& other) const;
    bool operator>=(const Array& other) const;
 
 
private:
    struct Imp;
    std::unique_ptr<Imp> _imp;
};
 
typedef Array<bool> BoolArray;
typedef Array<int> IntArray;
typedef Array<unsigned int> UIntArray;
typedef Array<float> FloatArray;
typedef Array<double> DoubleArray;
typedef Array<std::string> StringArray;
typedef Array<Vector2i> Vector2iArray;
typedef Array<Vector2f> Vector2fArray;
typedef Array<Vector2d> Vector2dArray;
typedef Array<Vector3i> Vector3iArray;
typedef Array<Vector3f> Vector3fArray;
typedef Array<Vector3d> Vector3dArray;
typedef Array<Vector4i> Vector4iArray;
typedef Array<Vector4f> Vector4fArray;
typedef Array<Vector4d> Vector4dArray;
typedef Array<Color3f> Color3fArray;
typedef Array<Color4f> Color4fArray;
typedef Array<Matrix3d> Matrix3dArray;
typedef Array<Matrix4d> Matrix4dArray;
 
} // namespace UFE_NS_DEF
 
#endif /* UFE_ARRAY_H */