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 {

namespace internal {

template <typename ValueType>
lagrange::span<const ValueType> get_all_unpoisoned(const Attribute<ValueType>& attr);
 
} // namespace internal


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;

    template <typename V>
    friend lagrange::span<const V> internal::get_all_unpoisoned(const Attribute<V>& attr);

    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