DataPieceArray.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed 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 CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#ifndef DATA_PIECES_ARRAY_H
#define DATA_PIECES_ARRAY_H
 
#ifndef DATA_PIECES_H
#include "DataPieces.h"
#endif
 
namespace vrs {
 
using std::map;
using std::min;
using std::ostream;
using std::string;
using std::vector;
 
template <typename T>
class DataPieceArray : public DataPiece {
  static_assert(std::is_trivially_copyable<T>::value, "DataPieceArray only supports POD types.");
 
 public:
  DataPieceArray(string label, size_t count)
      : DataPiece(std::move(label), DataPieceType::Array, sizeof(T) * count), count_(count) {}
  template <size_t n>
  DataPieceArray(string label, size_t count, const T (&defaultValues)[n])
      : DataPiece(std::move(label), DataPieceType::Array, sizeof(T) * count), count_(count) {
    setDefault(defaultValues, n);
  }
  explicit DataPieceArray(const MakerBundle& bundle);
 
  size_t getArraySize() const {
    return count_;
  }
 
  const string& getElementTypeName() const override {
    return vrs::getTypeName<T>();
  }
  size_t getVariableSize() const override {
    return 0;
  }
  size_t collectVariableData(int8_t*, size_t) override {
    return 0;
  }
 
  bool get(T* outValues, size_t count) const {
    const size_t bytesRequested = sizeof(T) * count;
    const T* const ptr =
        (count <= count_) ? layout_.getFixedData<T>(offset_, bytesRequested) : nullptr;
    if (ptr != nullptr && bytesRequested > 0) {
      memcpy(outValues, ptr, bytesRequested);
      return true;
    }
    const size_t defaultReadCount = min<size_t>(count, defaultValues_.size());
    if (defaultReadCount > 0) {
      memcpy(outValues, defaultValues_.data(), defaultReadCount * sizeof(T));
    }
    // blank values set set by default values
    for (size_t k = defaultValues_.size(); k < count; k++) {
      outValues[k] = T{};
    }
    return false;
  }
  bool get(T& outValue, size_t index) const {
    const size_t bytesRequested = sizeof(T) * (index + 1);
    const T* const ptr =
        (index < count_) ? layout_.getFixedData<T>(offset_, bytesRequested) : nullptr;
    if (ptr != nullptr) {
      outValue = readUnaligned<T>(ptr + index);
      return true;
    }
    if (index < defaultValues_.size()) {
      outValue = defaultValues_[index];
    } else {
      outValue = T{};
    }
    return false;
  }
  bool get(vector<T>& outValues) const {
    const T* const ptr = layout_.getFixedData<T>(offset_, getFixedSize());
    if (ptr != nullptr) {
      outValues.resize(count_);
      memcpy(outValues.data(), ptr, getFixedSize());
      return true;
    }
    outValues = defaultValues_;
    return false;
  }
  bool set(const T* values, size_t count) {
    T* const ptr = layout_.getFixedData<T>(offset_, getFixedSize());
    if (ptr != nullptr) {
      if (count > 0) {
        memcpy(ptr, values, sizeof(T) * min<size_t>(count, count_));
      }
      T v{};
      while (count < count_) {
        writeUnaligned<T>(ptr + count++, v);
      }
      return true;
    } else {
      return false;
    }
  }
  bool set(const T& value, size_t index) {
    T* const ptr = layout_.getFixedData<T>(offset_, getFixedSize());
    if (ptr != nullptr && index < count_) {
      writeUnaligned<T>(ptr + index, value);
      return true;
    }
    return false;
  }
  template <size_t n>
  bool set(const T (&arr)[n]) {
    return set(arr, n);
  }
  bool set(const vector<T>& values) {
    return values.empty() ? set(nullptr, 0) : set(values.data(), values.size());
  }
 
  void setDefault(const T* defaultValues, size_t count) {
    defaultValues_.resize(count_);
    size_t copySize = min(count, count_) * sizeof(T);
    if (copySize > 0) {
      memcpy(defaultValues_.data(), defaultValues, copySize);
    }
    for (; count < count_; count++) {
      defaultValues_[count] = T{};
    }
  }
  template <size_t n>
  void setDefault(const T (&arr)[n]) {
    setDefault(arr, n);
  }
  void setDefault(const vector<T>& values) {
    setDefault(values.data(), values.size());
  }
  const vector<T>& getDefault() const {
    return defaultValues_;
  }
  void initToDefault() override {
    set(defaultValues_);
  }
 
  void setProperty(const string& propertyName, T value) {
    properties_[propertyName] = value;
  }
  bool getProperty(const string& propertyName, T& outValue) const {
    auto iter = properties_.find(propertyName);
    if (iter != properties_.end()) {
      outValue = iter->second;
      return true;
    }
    return false;
  }
 
  void setMin(T min) {
    properties_[kMinValue] = min;
  }
  void setMax(T max) {
    properties_[kMaxValue] = max;
  }
  void setRange(T min, T max) {
    properties_[kMinValue] = min;
    properties_[kMaxValue] = max;
  }
  bool getMin(T& outMin) const {
    return getProperty(kMinValue, outMin);
  }
  bool getMax(T& outMax) const {
    return getProperty(kMinValue, outMax);
  }
 
  bool patchValue(const T* values, size_t count) const {
    auto* patchedPiece = layout_.getMappedPiece<DataPieceArray<T>>(pieceIndex_);
    return patchedPiece != nullptr && patchedPiece->set(values, count);
  }
 
  bool isAvailable() const override {
    return layout_.getFixedData<T>(offset_, getFixedSize()) != nullptr;
  }
 
  void print(ostream& out, const string& indent) const override;
  void printCompact(ostream& out, const string& indent) const override;
 
  bool isSame(const DataPiece* rhs) const override;
 
  void serialize(JsonWrapper& jsonWrapper, const JsonFormatProfileSpec& profile) override;
 
  unique_ptr<DataPiece> clone() const override {
    auto other = std::make_unique<DataPieceArray<T>>(getLabel(), getArraySize());
    other->tags_ = tags_;
    other->required_ = required_;
    other->properties_ = properties_;
    other->defaultValues_ = defaultValues_;
    return other;
  }
 
 protected:
  bool copyFrom(const DataPiece* original) override {
    const auto* source = reinterpret_cast<const DataPieceArray<T>*>(original);
    vector<T> values;
    bool retrieved = source->get(values);
    set(values);
    return retrieved;
  }
 
 private:
  const size_t count_{};
  map<string, T> properties_;
  vector<T> defaultValues_;
};
 
} // namespace vrs
 
#endif // DATA_PIECES_ARRAY_H