Array.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2024 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
#ifndef AMINO_ARRAY_H
#define AMINO_ARRAY_H
 
 
//==============================================================================
// EXTERNAL DECLARATIONS
//==============================================================================
 
#include "ArrayFwd.h"
 
#include "internal/ArrayImpl.h"
#include "internal/ConfigMacros.h"
 
#include <type_traits>
 
namespace Amino {
 
//==============================================================================
// FORWARD DECLARATIONS
//==============================================================================
 
template <typename T>
class Array;
 
//==============================================================================
// ALIAS ArrayD (Array with given dimension)
//==============================================================================
 
template <unsigned Dimension, typename T>
using ArrayD_t = Internal::MultiDimensionalArray_t<Dimension, T>;
 
//==============================================================================
// FUNCTION warn_if_unsupported_element
//==============================================================================
 
template <typename T>
inline constexpr void warn_if_unsupported_element();
 
//==============================================================================
// CLASS Array
//==============================================================================
 
template <typename T>
class Array : private Internal::ArrayImpl<T> {
private:
    static_assert(
        std::is_same<std::remove_cv_t<T>, T>::value,
        "Amino::Array must have a non-const, non-volatile value_type");
 
    using BaseClass = Internal::ArrayImpl<T>;
 
public:
    /*----- types -----*/
 
    using value_type = typename BaseClass::value_type;
 
    using pointer = typename BaseClass::pointer;
 
    using const_pointer = typename BaseClass::const_pointer;
 
    using reference = typename BaseClass::reference;
 
    using const_reference = typename BaseClass::const_reference;
 
    using difference_type = typename BaseClass::difference_type;
 
    using size_type = typename BaseClass::size_type;
 
    using iterator = typename BaseClass::iterator;
 
    using const_iterator = typename BaseClass::const_iterator;
 
private:
    template <typename InputIterator>
    using enable_if_input_iterator_t = std::enable_if_t<std::is_convertible<
        typename std::iterator_traits<InputIterator>::iterator_category,
        std::input_iterator_tag>::value>;
 
    template <typename... Args>
    using enable_if_constructible_t =
        std::enable_if_t<std::is_constructible<T, Args...>::value>;
 
public:
    /*----- constructors and assignment functions -----*/
 
    explicit Array() : BaseClass() { warn_if_unsupported_element<T>(); }
 
    explicit Array(size_type n) : BaseClass(n) {
        warn_if_unsupported_element<T>();
    }
 
    Array(size_type n, const value_type& value) : BaseClass(n, value) {
        warn_if_unsupported_element<T>();
    }
 
    template <
        class InputIterator,
        typename = enable_if_input_iterator_t<InputIterator>>
    Array(InputIterator first, InputIterator last) : BaseClass(first, last) {
        warn_if_unsupported_element<T>();
    }
 
    Array(std::initializer_list<value_type> init) : BaseClass(init) {
        warn_if_unsupported_element<T>();
    }
 
    Array(const Array<T>& other) = default;
 
    Array(Array<T>&& other) noexcept = default;
 
    ~Array() = default;
 
    Array<T>& operator=(const Array<T>& other) = default;
 
    Array<T>& operator=(Array<T>&& other) noexcept = default;
 
    Array<T>& operator=(std::initializer_list<value_type> init) {
        BaseClass::assign(init.begin(), init.end());
        return *this;
    }
 
    void assign(size_type count, const value_type& value) {
        BaseClass::assign(count, value);
    }
 
    template <
        class InputIterator,
        typename = enable_if_input_iterator_t<InputIterator>>
    void assign(InputIterator first, InputIterator last) {
        BaseClass::assign(first, last);
    }
 
    void assign(std::initializer_list<T> init) {
        BaseClass::assign(init.begin(), init.end());
    }
 
    /*----- element accessor functions -----*/
 
    reference       at(size_type n) { return BaseClass::at(n); }
    const_reference at(size_type n) const { return BaseClass::at(n); }
 
    reference       operator[](size_type n) { return BaseClass::operator[](n); }
    const_reference operator[](size_type n) const {
        return BaseClass::operator[](n);
    }
 
    reference       front() { return BaseClass::front(); }
    const_reference front() const { return BaseClass::front(); }
 
    reference       back() { return BaseClass::back(); }
    const_reference back() const { return BaseClass::back(); }
 
    pointer       data() noexcept { return BaseClass::data(); }
    const_pointer data() const noexcept { return BaseClass::data(); }
 
    /*----- iterators functions -----*/
 
    iterator       begin() noexcept { return BaseClass::begin(); }
    const_iterator begin() const noexcept { return BaseClass::begin(); }
    const_iterator cbegin() const noexcept { return BaseClass::cbegin(); }
 
    iterator       end() noexcept { return BaseClass::end(); }
    const_iterator end() const noexcept { return BaseClass::end(); }
    const_iterator cend() const noexcept { return BaseClass::cend(); }
 
    /*----- capacity related functions -----*/
 
    bool empty() const noexcept { return BaseClass::empty(); }
 
    size_type size() const noexcept { return BaseClass::size(); }
 
    size_type max_size() const { return BaseClass::max_size(); }
 
    void reserve(size_type new_capacity) { BaseClass::reserve(new_capacity); }
 
    size_type capacity() const noexcept { return BaseClass::capacity(); }
 
    void shrink_to_fit() noexcept { BaseClass::shrink_to_fit(); }
 
    /*----- modifier functions -----*/
 
    void clear() noexcept { BaseClass::clear(); }
 
    iterator insert(const_iterator pos, const value_type& value) {
        return BaseClass::insert(pos, value);
    }
    iterator insert(const_iterator pos, value_type&& value) {
        return BaseClass::insert(pos, std::move(value));
    }
 
    iterator insert(
        const_iterator pos, size_type count, const value_type& value) {
        return BaseClass::insert(pos, count, value);
    }
 
    template <
        class InputIterator,
        typename = enable_if_input_iterator_t<InputIterator>>
    iterator insert(
        const_iterator pos, InputIterator first, InputIterator last) {
        return BaseClass::insert(pos, first, last);
    }
 
    iterator insert(
        const_iterator pos, std::initializer_list<value_type> init) {
        return BaseClass::insert(pos, init.begin(), init.end());
    }
 
    iterator erase(const_iterator pos) { return BaseClass::erase(pos); }
 
    iterator erase(const_iterator first, const_iterator last) {
        return BaseClass::erase(first, last);
    }
 
    void push_back(const value_type& value) { BaseClass::push_back(value); }
    void push_back(value_type&& value) {
        BaseClass::push_back(std::move(value));
    }
 
    template <typename... Args, typename = enable_if_constructible_t<Args...>>
    void emplace_back(Args&&... args) {
        BaseClass::emplace_back(std::forward<Args>(args)...);
    }
 
    void pop_back() { BaseClass::pop_back(); }
 
    void resize(size_type count) { BaseClass::resize(count); }
 
    void resize(size_type count, const value_type& value) {
        BaseClass::resize(count, value);
    }
 
    void swap(Array& other) noexcept { BaseClass::swap(other); }
 
private:
    // WARNING - this class MUST NOT have any data members or virtual functions
    // (It must be perfectly ABI compatible with the UntypedArray).
};
 
//------------------------------------------------------------------------------
//
template <Internal::TypeCategory>
struct MaybeWarn {
    static inline constexpr void amino_array_of_unsupported_element() {}
};
template <>
struct MaybeWarn<Internal::TypeCategory::eUninstantiable> {
    AMINO_INTERNAL_DEPRECATED(
        "The element type of this array is not supported in Amino.\n    "
        "All types must be default constructible, copy/move constructible,"
        "copy/move assignable, and destructible.\n    "
        "Class types wrapped in Amino::Ptr must provide a default getter "
        "(see Amino/Cpp/ClassDeclare.h and Amino/Cpp/ClassDefine.h).\n    "
        "It won't be type-erased, nor support virtualized operations.")
    static inline constexpr void amino_array_of_unsupported_element() {}
};
 
template <typename T>
inline constexpr void warn_if_unsupported_element() {
    MaybeWarn<Internal::GetTypeCategory<T>::value>::
        amino_array_of_unsupported_element();
}
 
} // namespace Amino
 
#endif