PropertyTablePropertyView.h

#pragma once
 
#include <CesiumGltf/Enum.h>
#include <CesiumGltf/PropertyArrayView.h>
#include <CesiumGltf/PropertyTransformations.h>
#include <CesiumGltf/PropertyTypeTraits.h>
#include <CesiumGltf/PropertyView.h>
#include <CesiumUtility/Assert.h>
 
#include <cstddef>
#include <cstdint>
#include <span>
#include <string_view>
 
namespace CesiumGltf {
class PropertyTablePropertyViewStatus : public PropertyViewStatus {
public:
  static const PropertyViewStatusType ErrorInvalidPropertyTable = 14;
 
  static const PropertyViewStatusType ErrorInvalidValueBufferView = 15;
 
  static const PropertyViewStatusType ErrorInvalidArrayOffsetBufferView = 16;
 
  static const PropertyViewStatusType ErrorInvalidStringOffsetBufferView = 17;
 
  static const PropertyViewStatusType ErrorInvalidValueBuffer = 18;
 
  static const PropertyViewStatusType ErrorInvalidArrayOffsetBuffer = 19;
 
  static const PropertyViewStatusType ErrorInvalidStringOffsetBuffer = 20;
 
  static const PropertyViewStatusType ErrorBufferViewOutOfBounds = 21;
 
  static const PropertyViewStatusType
      ErrorBufferViewSizeNotDivisibleByTypeSize = 22;
 
  static const PropertyViewStatusType
      ErrorBufferViewSizeDoesNotMatchPropertyTableCount = 23;
 
  static const PropertyViewStatusType ErrorArrayCountAndOffsetBufferCoexist =
      24;
 
  static const PropertyViewStatusType ErrorArrayCountAndOffsetBufferDontExist =
      25;
 
  static const PropertyViewStatusType ErrorInvalidArrayOffsetType = 26;
 
  static const PropertyViewStatusType ErrorInvalidStringOffsetType = 27;
 
  static const PropertyViewStatusType ErrorArrayOffsetsNotSorted = 28;
 
  static const PropertyViewStatusType ErrorStringOffsetsNotSorted = 29;
 
  static const PropertyViewStatusType ErrorArrayOffsetOutOfBounds = 30;
 
  static const PropertyViewStatusType ErrorStringOffsetOutOfBounds = 31;
};
 
int64_t getOffsetTypeSize(PropertyComponentType offsetType) noexcept;
 
template <typename ElementType, bool Normalized = false>
class PropertyTablePropertyView;
 
template <typename ElementType>
class PropertyTablePropertyView<ElementType, false>
    : public PropertyView<ElementType, false> {
public:
  PropertyTablePropertyView()
      : PropertyView<ElementType, false>(),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0},
        _stringOffsets{},
        _stringOffsetType{PropertyComponentType::None},
        _stringOffsetTypeSize{0} {}
 
  PropertyTablePropertyView(PropertyViewStatusType status)
      : PropertyView<ElementType, false>(status),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0},
        _stringOffsets{},
        _stringOffsetType{PropertyComponentType::None},
        _stringOffsetTypeSize{0} {
    CESIUM_ASSERT(
        this->_status != PropertyTablePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid status");
  }
 
  PropertyTablePropertyView(const ClassProperty& classProperty, int64_t size)
      : PropertyView<ElementType, false>(classProperty),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0},
        _stringOffsets{},
        _stringOffsetType{PropertyComponentType::None},
        _stringOffsetTypeSize{0} {
    if (this->_status != PropertyTablePropertyViewStatus::Valid) {
      // Don't override the status / size if something is wrong with the class
      // property's definition.
      return;
    }
 
    if (!classProperty.defaultProperty) {
      // This constructor should only be called if the class property *has* a
      // default value. But in the case that it does not, this property view
      // becomes invalid.
      this->_status = PropertyTablePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status = PropertyTablePropertyViewStatus::EmptyPropertyWithDefault;
    this->_size = size;
  }
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      int64_t size,
      std::span<const std::byte> values) noexcept
      : PropertyTablePropertyView(
            property,
            classProperty,
            nullptr,
            size,
            values) {}
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      const CesiumGltf::Enum* pEnumDefinition,
      int64_t size,
      std::span<const std::byte> values) noexcept
      : PropertyView<ElementType>(classProperty, property, pEnumDefinition),
        _values{values},
        _size{
            this->_status == PropertyTablePropertyViewStatus::Valid ? size : 0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0},
        _stringOffsets{},
        _stringOffsetType{PropertyComponentType::None},
        _stringOffsetTypeSize{0} {}
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      int64_t size,
      std::span<const std::byte> values,
      std::span<const std::byte> arrayOffsets,
      std::span<const std::byte> stringOffsets,
      PropertyComponentType arrayOffsetType,
      PropertyComponentType stringOffsetType) noexcept
      : PropertyTablePropertyView(
            property,
            classProperty,
            nullptr,
            size,
            values,
            arrayOffsets,
            stringOffsets,
            arrayOffsetType,
            stringOffsetType) {}
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      const CesiumGltf::Enum* pEnumDefinition,
      int64_t size,
      std::span<const std::byte> values,
      std::span<const std::byte> arrayOffsets,
      std::span<const std::byte> stringOffsets,
      PropertyComponentType arrayOffsetType,
      PropertyComponentType stringOffsetType) noexcept
      : PropertyView<ElementType>(classProperty, property, pEnumDefinition),
        _values{values},
        _size{
            this->_status == PropertyTablePropertyViewStatus::Valid ? size : 0},
        _arrayOffsets{arrayOffsets},
        _arrayOffsetType{arrayOffsetType},
        _arrayOffsetTypeSize{getOffsetTypeSize(arrayOffsetType)},
        _stringOffsets{stringOffsets},
        _stringOffsetType{stringOffsetType},
        _stringOffsetTypeSize{getOffsetTypeSize(stringOffsetType)} {}
 
  std::optional<PropertyValueViewToCopy<ElementType>>
  get(int64_t index) const noexcept {
    if (this->_status ==
        PropertyTablePropertyViewStatus::EmptyPropertyWithDefault) {
      CESIUM_ASSERT(index >= 0 && "index must be non-negative");
      CESIUM_ASSERT(index < size() && "index must be less than size");
 
      return propertyValueViewToCopy(this->defaultValue());
    }
 
    ElementType value = getRaw(index);
 
    if (value == this->noData()) {
      return propertyValueViewToCopy(this->defaultValue());
    } else if constexpr (IsMetadataNumeric<ElementType>::value) {
      return transformValue(value, this->offset(), this->scale());
    } else if constexpr (IsMetadataNumericArray<ElementType>::value) {
      return transformArray(value, this->offset(), this->scale());
    } else {
      return value;
    }
  }
 
  ElementType getRaw(int64_t index) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyTablePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
    CESIUM_ASSERT(
        size() > 0 &&
        "Check the size() of the view to make sure it's not empty");
    CESIUM_ASSERT(index >= 0 && "index must be non-negative");
    CESIUM_ASSERT(index < size() && "index must be less than size");
 
    if constexpr (IsMetadataNumeric<ElementType>::value) {
      return getNumericValue(index);
    }
 
    if constexpr (IsMetadataBoolean<ElementType>::value) {
      return getBooleanValue(index);
    }
 
    if constexpr (IsMetadataString<ElementType>::value) {
      return getStringValue(index);
    }
 
    if constexpr (IsMetadataNumericArray<ElementType>::value) {
      return getNumericArrayValues<
          typename MetadataArrayType<ElementType>::type>(index);
    }
 
    if constexpr (IsMetadataBooleanArray<ElementType>::value) {
      return getBooleanArrayValues(index);
    }
 
    if constexpr (IsMetadataStringArray<ElementType>::value) {
      return getStringArrayValues(index);
    }
  }
 
  int64_t size() const noexcept { return _size; }
 
private:
  ElementType getNumericValue(int64_t index) const noexcept {
    return reinterpret_cast<const ElementType*>(_values.data())[index];
  }
 
  bool getBooleanValue(int64_t index) const noexcept {
    const int64_t byteIndex = index / 8;
    const int64_t bitIndex = index % 8;
    const int bitValue =
        static_cast<int>(_values[static_cast<size_t>(byteIndex)] >> bitIndex) &
        1;
    return bitValue == 1;
  }
 
  std::string_view getStringValue(int64_t index) const noexcept {
    const size_t currentOffset = getOffsetFromOffsetsBuffer(
        static_cast<size_t>(index),
        _stringOffsets,
        _stringOffsetType);
    const size_t nextOffset = getOffsetFromOffsetsBuffer(
        static_cast<size_t>(index + 1),
        _stringOffsets,
        _stringOffsetType);
    return std::string_view(
        reinterpret_cast<const char*>(_values.data() + currentOffset),
        nextOffset - currentOffset);
  }
 
  template <typename T>
  PropertyArrayView<T> getNumericArrayValues(int64_t index) const noexcept {
    size_t count = static_cast<size_t>(this->arrayCount());
    // Handle fixed-length arrays
    if (count > 0) {
      size_t arraySize = count * sizeof(T);
      const std::span<const std::byte> values(
          _values.data() + static_cast<size_t>(index) * arraySize,
          arraySize);
      return PropertyArrayView<T>{values};
    }
 
    // Handle variable-length arrays. The offsets are interpreted as array
    // indices, not byte offsets, so they must be multiplied by sizeof(T)
    const size_t currentOffset = getOffsetFromOffsetsBuffer(
                                     static_cast<size_t>(index),
                                     _arrayOffsets,
                                     _arrayOffsetType) *
                                 sizeof(T);
    const size_t nextOffset = getOffsetFromOffsetsBuffer(
                                  static_cast<size_t>(index + 1),
                                  _arrayOffsets,
                                  _arrayOffsetType) *
                              sizeof(T);
    const std::span<const std::byte> values(
        _values.data() + currentOffset,
        nextOffset - currentOffset);
    return PropertyArrayView<T>{values};
  }
 
  PropertyArrayView<std::string_view>
  getStringArrayValues(int64_t index) const noexcept {
    size_t count = static_cast<size_t>(this->arrayCount());
    // Handle fixed-length arrays
    if (count > 0) {
      // Copy the corresponding string offsets to pass to the PropertyArrayView.
      const size_t arraySize =
          count * static_cast<size_t>(_stringOffsetTypeSize);
      const std::span<const std::byte> stringOffsetValues(
          _stringOffsets.data() + static_cast<size_t>(index) * arraySize,
          arraySize + static_cast<size_t>(_stringOffsetTypeSize));
      return PropertyArrayView<std::string_view>(
          _values,
          stringOffsetValues,
          _stringOffsetType,
          static_cast<int64_t>(count));
    }
 
    // Handle variable-length arrays
    const size_t currentArrayOffset =
        getOffsetFromOffsetsBuffer(
            static_cast<size_t>(index),
            _arrayOffsets,
            _arrayOffsetType) *
        static_cast<size_t>(_stringOffsetTypeSize);
    const size_t nextArrayOffset = getOffsetFromOffsetsBuffer(
                                       static_cast<size_t>(index + 1),
                                       _arrayOffsets,
                                       _arrayOffsetType) *
                                   static_cast<size_t>(_stringOffsetTypeSize);
    const size_t arraySize = nextArrayOffset - currentArrayOffset;
    const std::span<const std::byte> stringOffsetValues(
        _stringOffsets.data() + currentArrayOffset,
        arraySize + static_cast<size_t>(_stringOffsetTypeSize));
    return PropertyArrayView<std::string_view>(
        _values,
        stringOffsetValues,
        _stringOffsetType,
        static_cast<int64_t>(arraySize) / _stringOffsetTypeSize);
  }
 
  PropertyArrayView<bool> getBooleanArrayValues(int64_t index) const noexcept {
    size_t count = static_cast<size_t>(this->arrayCount());
    // Handle fixed-length arrays
    if (count > 0) {
      const size_t offsetBits = count * static_cast<size_t>(index);
      const size_t nextOffsetBits = count * static_cast<size_t>(index + 1);
      const std::span<const std::byte> buffer(
          _values.data() + offsetBits / 8,
          (nextOffsetBits / 8 - offsetBits / 8 + 1));
      return PropertyArrayView<bool>(
          buffer,
          offsetBits % 8,
          static_cast<int64_t>(count));
    }
 
    // Handle variable-length arrays
    const size_t currentOffset = getOffsetFromOffsetsBuffer(
        static_cast<size_t>(index),
        _arrayOffsets,
        _arrayOffsetType);
    const size_t nextOffset = getOffsetFromOffsetsBuffer(
        static_cast<size_t>(index + 1),
        _arrayOffsets,
        _arrayOffsetType);
    const size_t totalBits = nextOffset - currentOffset;
    const std::span<const std::byte> buffer(
        _values.data() + currentOffset / 8,
        (nextOffset / 8 - currentOffset / 8 + 1));
    return PropertyArrayView<bool>(
        buffer,
        currentOffset % 8,
        static_cast<int64_t>(totalBits));
  }
 
  std::span<const std::byte> _values;
  int64_t _size;
 
  std::span<const std::byte> _arrayOffsets;
  PropertyComponentType _arrayOffsetType;
  int64_t _arrayOffsetTypeSize;
 
  std::span<const std::byte> _stringOffsets;
  PropertyComponentType _stringOffsetType;
  int64_t _stringOffsetTypeSize;
};
 
template <typename ElementType>
class PropertyTablePropertyView<ElementType, true>
    : public PropertyView<ElementType, true> {
private:
  using NormalizedType = typename TypeToNormalizedType<ElementType>::type;
 
public:
  PropertyTablePropertyView()
      : PropertyView<ElementType, true>(),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0} {}
 
  PropertyTablePropertyView(PropertyViewStatusType status)
      : PropertyView<ElementType, true>(status),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0} {
    CESIUM_ASSERT(
        this->_status != PropertyTablePropertyViewStatus::Valid &&
        "An empty property view should not be constructed with a valid status");
  }
 
  PropertyTablePropertyView(const ClassProperty& classProperty, int64_t size)
      : PropertyView<ElementType, true>(classProperty),
        _values{},
        _size{0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0} {
    if (this->_status != PropertyTablePropertyViewStatus::Valid) {
      // Don't override the status / size if something is wrong with the class
      // property's definition.
      return;
    }
 
    if (!classProperty.defaultProperty) {
      // This constructor should only be called if the class property *has* a
      // default value. But in the case that it does not, this property view
      // becomes invalid.
      this->_status = PropertyTablePropertyViewStatus::ErrorNonexistentProperty;
      return;
    }
 
    this->_status = PropertyTablePropertyViewStatus::EmptyPropertyWithDefault;
    this->_size = size;
  }
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      int64_t size,
      std::span<const std::byte> values) noexcept
      : PropertyView<ElementType, true>(classProperty, property),
        _values{values},
        _size{
            this->_status == PropertyTablePropertyViewStatus::Valid ? size : 0},
        _arrayOffsets{},
        _arrayOffsetType{PropertyComponentType::None},
        _arrayOffsetTypeSize{0} {}
 
  PropertyTablePropertyView(
      const PropertyTableProperty& property,
      const ClassProperty& classProperty,
      int64_t size,
      std::span<const std::byte> values,
      std::span<const std::byte> arrayOffsets,
      PropertyComponentType arrayOffsetType) noexcept
      : PropertyView<ElementType, true>(classProperty, property),
        _values{values},
        _size{
            this->_status == PropertyTablePropertyViewStatus::Valid ? size : 0},
        _arrayOffsets{arrayOffsets},
        _arrayOffsetType{arrayOffsetType},
        _arrayOffsetTypeSize{getOffsetTypeSize(arrayOffsetType)} {}
 
  std::optional<PropertyValueViewToCopy<NormalizedType>>
  get(int64_t index) const noexcept {
    if (this->_status ==
        PropertyTablePropertyViewStatus::EmptyPropertyWithDefault) {
      CESIUM_ASSERT(index >= 0 && "index must be non-negative");
      CESIUM_ASSERT(index < size() && "index must be less than size");
 
      return propertyValueViewToCopy(this->defaultValue());
    }
 
    ElementType value = getRaw(index);
    if (this->noData() && value == *(this->noData())) {
      return propertyValueViewToCopy(this->defaultValue());
    } else if constexpr (IsMetadataScalar<ElementType>::value) {
      return transformValue<NormalizedType>(
          normalize<ElementType>(value),
          this->offset(),
          this->scale());
    } else if constexpr (IsMetadataVecN<ElementType>::value) {
      constexpr glm::length_t N = ElementType::length();
      using T = typename ElementType::value_type;
      using NormalizedT = typename NormalizedType::value_type;
      return transformValue<glm::vec<N, NormalizedT>>(
          normalize<N, T>(value),
          this->offset(),
          this->scale());
    } else if constexpr (IsMetadataMatN<ElementType>::value) {
      constexpr glm::length_t N = ElementType::length();
      using T = typename ElementType::value_type;
      using NormalizedT = typename NormalizedType::value_type;
      return transformValue<glm::mat<N, N, NormalizedT>>(
          normalize<N, T>(value),
          this->offset(),
          this->scale());
    } else if constexpr (IsMetadataArray<ElementType>::value) {
      using ArrayElementType = typename MetadataArrayType<ElementType>::type;
      if constexpr (IsMetadataScalar<ArrayElementType>::value) {
        return transformNormalizedArray<ArrayElementType>(
            value,
            this->offset(),
            this->scale());
      } else if constexpr (IsMetadataVecN<ArrayElementType>::value) {
        constexpr glm::length_t N = ArrayElementType::length();
        using T = typename ArrayElementType::value_type;
        return transformNormalizedVecNArray<N, T>(
            value,
            this->offset(),
            this->scale());
      } else if constexpr (IsMetadataMatN<ArrayElementType>::value) {
        constexpr glm::length_t N = ArrayElementType::length();
        using T = typename ArrayElementType::value_type;
        return transformNormalizedMatNArray<N, T>(
            value,
            this->offset(),
            this->scale());
      }
    }
  }
 
  ElementType getRaw(int64_t index) const noexcept {
    CESIUM_ASSERT(
        this->_status == PropertyTablePropertyViewStatus::Valid &&
        "Check the status() first to make sure view is valid");
    CESIUM_ASSERT(
        size() > 0 &&
        "Check the size() of the view to make sure it's not empty");
    CESIUM_ASSERT(index >= 0 && "index must be non-negative");
    CESIUM_ASSERT(index < size() && "index must be less than size");
 
    if constexpr (IsMetadataNumeric<ElementType>::value) {
      return getValue(index);
    }
 
    if constexpr (IsMetadataNumericArray<ElementType>::value) {
      return getArrayValues<typename MetadataArrayType<ElementType>::type>(
          index);
    }
  }
 
  int64_t size() const noexcept {
    return this->_status == PropertyTablePropertyViewStatus::Valid ? _size : 0;
  }
 
private:
  ElementType getValue(int64_t index) const noexcept {
    return reinterpret_cast<const ElementType*>(_values.data())[index];
  }
 
  template <typename T>
  PropertyArrayView<T> getArrayValues(int64_t index) const noexcept {
    size_t count = static_cast<size_t>(this->arrayCount());
    // Handle fixed-length arrays
    if (count > 0) {
      size_t arraySize = count * sizeof(T);
      const std::span<const std::byte> values(
          _values.data() + static_cast<size_t>(index) * arraySize,
          arraySize);
      return PropertyArrayView<T>{values};
    }
 
    // Handle variable-length arrays. The offsets are interpreted as array
    // indices, not byte offsets, so they must be multiplied by sizeof(T)
    const size_t currentOffset = getOffsetFromOffsetsBuffer(
                                     static_cast<size_t>(index),
                                     _arrayOffsets,
                                     _arrayOffsetType) *
                                 sizeof(T);
    const size_t nextOffset = getOffsetFromOffsetsBuffer(
                                  static_cast<size_t>(index + 1),
                                  _arrayOffsets,
                                  _arrayOffsetType) *
                              sizeof(T);
    const std::span<const std::byte> values(
        _values.data() + currentOffset,
        nextOffset - currentOffset);
    return PropertyArrayView<T>{values};
  }
 
  std::span<const std::byte> _values;
  int64_t _size;
 
  std::span<const std::byte> _arrayOffsets;
  PropertyComponentType _arrayOffsetType;
  int64_t _arrayOffsetTypeSize;
};
 
} // namespace CesiumGltf