DataPieceValue.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_VALUE_H
#define DATA_PIECES_VALUE_H
 
#include <memory>
 
#ifndef DATA_PIECES_H
#include "DataPieces.h"
#endif
 
namespace vrs {
 
using std::map;
using std::ostream;
using std::string;
using std::unique_ptr;
 
template <typename T>
class DataPieceValue : public DataPiece {
  static_assert(
      !std::is_same<T, bool>::value,
      "DataPieceValue does not support bool. Use vrs::Bool instead");
  static_assert(std::is_trivially_copyable<T>::value, "DataPieceValue only supports POD types.");
 
 public:
  explicit DataPieceValue(const string& label)
      : DataPiece(label, DataPieceType::Value, sizeof(T)) {}
  DataPieceValue(const string& label, T defaultValue)
      : DataPiece(label, DataPieceType::Value, sizeof(T)) {
    defaultValue_ = std::make_unique<T>(defaultValue);
  }
  explicit DataPieceValue(const MakerBundle& bundle);
 
  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;
  }
 
  T get() const {
    const T* const ptr = layout_.getFixedData<T>(offset_, sizeof(T));
    return ptr != nullptr ? readUnaligned<T>(ptr) : getDefault();
  }
  bool get(T& outValue) const {
    const T* const ptr = layout_.getFixedData<T>(offset_, sizeof(T));
    if (ptr != nullptr) {
      outValue = readUnaligned<T>(ptr);
      return true;
    } else {
      getDefault(outValue);
      return false;
    }
  }
 
  bool set(const T& value) {
    T* const ptr = layout_.getFixedData<T>(offset_, sizeof(T));
    if (ptr != nullptr) {
      writeUnaligned<T>(ptr, value);
      return true;
    }
    return false;
  }
 
  T getDefault() const {
    return defaultValue_ ? *defaultValue_.get() : T{};
  }
  bool getDefault(T& outDefault) const {
    if (defaultValue_) {
      outDefault = *defaultValue_.get();
      return true;
    }
    outDefault = T{};
    return false;
  }
 
  void setDefault(const T& defaultValue) {
    if (defaultValue_) {
      *defaultValue_.get() = defaultValue;
    } else {
      defaultValue_ = std::make_unique<T>(defaultValue);
    }
  }
 
  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 setProperty(const string& propertyName, T value) {
    properties_[propertyName] = value;
  }
 
  bool getMin(T& outMin) const {
    return getProperty(kMinValue, outMin);
  }
  bool getMax(T& outMax) const {
    return getProperty(kMaxValue, outMax);
  }
  bool getMinIncrement(T& outMinIncrement) const {
    return getProperty(kMinIncrement, outMinIncrement);
  }
  bool getMaxIncrement(T& outMaxIncrement) const {
    return getProperty(kMaxIncrement, outMaxIncrement);
  }
  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;
  }
  void setMinIncrement(T minIncrement) {
    properties_[kMinIncrement] = minIncrement;
  }
  void setMaxIncrement(T maxIncrement) {
    properties_[kMaxIncrement] = maxIncrement;
  }
  void setIncrement(T minIncrement, T maxIncrement) {
    properties_[kMinIncrement] = minIncrement;
    properties_[kMaxIncrement] = maxIncrement;
  }
 
  bool isAvailable() const override {
    return layout_.getFixedData<T>(offset_, sizeof(T)) != 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<DataPieceValue<T>>(getLabel());
    other->tags_ = tags_;
    other->required_ = required_;
    other->properties_ = properties_;
    if (defaultValue_) {
      other->defaultValue_ = std::make_unique<T>(*defaultValue_);
    }
    return other;
  }
 
 protected:
  bool stageFrom(const DataPiece* /*original*/) override {
    return false; // not applicable
  }
 
 private:
  map<string, T> properties_;
  unique_ptr<T> defaultValue_;
};
 
template <typename EnumType, typename StorageType>
class DataPieceEnum : public DataPieceValue<StorageType> {
 public:
  explicit DataPieceEnum(const string& label) : DataPieceValue<StorageType>(label) {}
 
  DataPieceEnum(const string& label, EnumType defaultValue)
      : DataPieceValue<StorageType>(label, static_cast<StorageType>(defaultValue)) {}
 
  EnumType get() const {
    return static_cast<EnumType>(DataPieceValue<StorageType>::get());
  }
 
  bool get(EnumType& e) const {
    StorageType v{};
    bool r = DataPieceValue<StorageType>::get(v);
    e = static_cast<EnumType>(v);
    return r;
  }
 
  bool set(const EnumType e) {
    return DataPieceValue<StorageType>::set(static_cast<StorageType>(e));
  }
 
  EnumType getDefault() const {
    return static_cast<EnumType>(DataPieceValue<StorageType>::getDefault());
  }
 
  bool getDefault(EnumType& outDefault) const {
    StorageType v;
    bool r = DataPieceValue<StorageType>::getDefault(v);
    outDefault = static_cast<EnumType>(v);
    return r;
  }
 
  void setDefault(const EnumType defaultValue) {
    DataPieceValue<StorageType>::setDefault(static_cast<StorageType>(defaultValue));
  }
};
 
} // namespace vrs
 
#endif // DATA_PIECES_VALUE_H