Attribute.h

/*
 * Copyright 2022 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/AttributeFwd.h>
#include <lagrange/utils/SharedSpan.h>
#include <lagrange/utils/span.h>
 
#include <vector>
 
namespace lagrange {
 
 
enum class AttributeValueType : uint8_t;
 
class AttributeBase
{
public:
    AttributeBase(AttributeElement element, AttributeUsage usage, size_t num_channels);
 
    virtual ~AttributeBase();
 
    AttributeBase(AttributeBase&& other) = default;
 
    AttributeBase& operator=(AttributeBase&& other) = default;
 
    AttributeBase(const AttributeBase& other) = default;
 
    AttributeBase& operator=(const AttributeBase& other) = default;
 
    [[nodiscard]] virtual AttributeValueType get_value_type() const = 0;
 
    [[nodiscard]] AttributeElement get_element_type() const { return m_element; }
 
    [[nodiscard]] AttributeUsage get_usage() const { return m_usage; }
 
    [[nodiscard]] size_t get_num_channels() const { return m_num_channels; }
 
    void unsafe_set_usage(AttributeUsage usage) { m_usage = usage; }
 
    void unsafe_set_element_type(AttributeElement element) { m_element = element; }
 
protected:
    AttributeElement m_element;
 
    AttributeUsage m_usage;
 
    size_t m_num_channels = 0;
};
 
template <typename ValueType_>
class Attribute : public AttributeBase
{
public:
    using ValueType = ValueType_;
 
    static constexpr bool IsIndexed = false;
 
    // Static assertions to prevent users from instantiating unsupported types. We do not use the
    // macros from AttributeTypes.h since we do not want to implicitly expose them in the main
    // Attribute.h header.
    static_assert(
        std::is_same_v<ValueType, int8_t> || std::is_same_v<ValueType, int16_t> ||
            std::is_same_v<ValueType, int32_t> || std::is_same_v<ValueType, int64_t> ||
            std::is_same_v<ValueType, uint8_t> || std::is_same_v<ValueType, uint16_t> ||
            std::is_same_v<ValueType, uint32_t> || std::is_same_v<ValueType, uint64_t> ||
            std::is_same_v<ValueType, float> || std::is_same_v<ValueType, double>,
        "Attribute's ValueType template parameter can only be float, double, or a fixed size "
        "integer type.");
 
public:
 
    Attribute(AttributeElement element, AttributeUsage usage, size_t num_channels);
 
    ~Attribute() override;
 
    Attribute(Attribute&& other) noexcept;
 
    Attribute& operator=(Attribute&& other) noexcept;
 
    explicit Attribute(const Attribute& other);
 
    Attribute& operator=(const Attribute& other);
 
    template <typename OtherValue>
    static Attribute cast_copy(const Attribute<OtherValue>& other);
 
    template <typename OtherValue>
    Attribute& cast_assign(const Attribute<OtherValue>& other);
 
    [[nodiscard]] AttributeValueType get_value_type() const override;
 
    void wrap(span<ValueType> buffer, size_t num_elements);
 
    void wrap(SharedSpan<ValueType> buffer_ptr, size_t num_elements);
 
    void wrap_const(span<const ValueType> buffer, size_t num_elements);
 
    void wrap_const(SharedSpan<const ValueType> shared_buffer, size_t num_elements);
 
 
    void set_default_value(ValueType value) { m_default_value = value; }
 
    ValueType get_default_value() const { return m_default_value; }
 
    void set_growth_policy(AttributeGrowthPolicy policy) { m_growth_policy = policy; }
 
    AttributeGrowthPolicy get_growth_policy() const { return m_growth_policy; }
 
    void set_shrink_policy(AttributeShrinkPolicy policy) { m_shrink_policy = policy; }
 
    AttributeShrinkPolicy get_shrink_policy() const { return m_shrink_policy; }
 
    void set_write_policy(AttributeWritePolicy policy) { m_write_policy = policy; }
 
    AttributeWritePolicy get_write_policy() const { return m_write_policy; }
 
    void set_copy_policy(AttributeCopyPolicy policy) { m_copy_policy = policy; }
 
    AttributeCopyPolicy get_copy_policy() const { return m_copy_policy; }
 
    void set_cast_policy(AttributeCastPolicy policy) { m_cast_policy = policy; }
 
    AttributeCastPolicy get_cast_policy() const { return m_cast_policy; }
 
    void create_internal_copy();
 
    void clear();
 
    void shrink_to_fit();
 
    void reserve_entries(size_t new_cap);
 
    void resize_elements(size_t num_elements);
 
    void insert_elements(span<const ValueType> values);
 
    void insert_elements(std::initializer_list<const ValueType> values);
 
    void insert_elements(size_t count);
 
 
    [[nodiscard]] bool empty() const { return m_num_elements == 0; }
 
    [[nodiscard]] size_t get_num_elements() const { return m_num_elements; }
 
    [[nodiscard]] bool is_external() const { return m_is_external; }
 
    [[nodiscard]] bool is_managed() const { return !is_external() || m_owner; }
 
    [[nodiscard]] bool is_read_only() const { return m_is_read_only; }
 
    ValueType get(size_t i, size_t c) const;
 
    ValueType& ref(size_t i, size_t c);
 
    ValueType get(size_t i) const;
 
    ValueType& ref(size_t i);
 
    lagrange::span<const ValueType> get_all() const;
 
    lagrange::span<ValueType> ref_all();
 
    lagrange::span<const ValueType> get_first(size_t num_elements) const;
 
    lagrange::span<ValueType> ref_first(size_t num_elements);
 
    lagrange::span<const ValueType> get_last(size_t num_elements) const;
 
    lagrange::span<ValueType> ref_last(size_t num_elements);
 
    lagrange::span<const ValueType> get_middle(size_t first_element, size_t num_elements) const;
 
    lagrange::span<ValueType> ref_middle(size_t first_element, size_t num_elements);
 
    lagrange::span<const ValueType> get_row(size_t element) const;
 
    lagrange::span<ValueType> ref_row(size_t element);
 
protected:
 
    template <typename>
    friend class Attribute;
 
    void growth_check(size_t new_cap);
 
    void write_check();
 
    void update_views();
 
    void clear_views();
 
 
protected:
    std::vector<ValueType> m_data;
 
    std::shared_ptr<const ValueType> m_owner;
 
    ValueType m_default_value = ValueType(0);
 
    lagrange::span<ValueType> m_view;
 
    lagrange::span<const ValueType> m_const_view;
 
    AttributeGrowthPolicy m_growth_policy = AttributeGrowthPolicy::ErrorIfExternal;
 
    AttributeShrinkPolicy m_shrink_policy = AttributeShrinkPolicy::ErrorIfExternal;
 
    AttributeWritePolicy m_write_policy = AttributeWritePolicy::ErrorIfReadOnly;
 
    AttributeCopyPolicy m_copy_policy = AttributeCopyPolicy::CopyIfExternal;
 
    AttributeCastPolicy m_cast_policy = AttributeCastPolicy::RemapInvalidIndices;
 
    bool m_is_external = false;
 
    bool m_is_read_only = false;
 
    size_t m_num_elements = 0;
};
 
 
} // namespace lagrange