DataPieces.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_H
#define DATA_PIECES_H
 
#include <cstring>
 
#include <map>
#include <ostream>
 
#include <vrs/DataLayout.h>
#include <vrs/DataPieceTypes.h>
#include <vrs/VrsExport.h>
 
namespace vrs {
 
using std::map;
using std::ostream;
using std::string;
 
class VRS_API DataPiece {
 public:
  struct MakerBundle;
 
 protected:
  DataPiece(string label, DataPieceType type, size_t size);
 
  static const string kUnit;
  static const string kDescription;
 
  static const string kMinValue;
  static const string kMaxValue;
  static const string kMinIncrement;
  static const string kMaxIncrement;
 
 public:
  virtual ~DataPiece();
  const DataLayout& getDataLayout() const {
    return layout_;
  }
  const string& getLabel() const {
    return label_;
  }
  DataPieceType getPieceType() const {
    return pieceType_;
  }
 
  string getTypeName() const;
 
  size_t getPieceIndex() const {
    return pieceIndex_;
  }
 
  size_t getOffset() const {
    return offset_;
  }
  bool hasFixedSize() const {
    return fixedSize_ != DataLayout::kVariableSize;
  }
  size_t getFixedSize() const {
    return fixedSize_;
  }
  bool getTag(const string& tagName, string& outTag) const;
  void setTag(const string& tagName, const string& tag) {
    tags_[tagName] = tag;
  }
  bool getUnit(string& outUnit) const {
    return getTag(kUnit, outUnit);
  }
  void setUnit(const string& unit) {
    tags_[kUnit] = unit;
  }
 
  bool getDescription(string& outDescription) const {
    return getTag(kDescription, outDescription);
  }
  void setDescription(const string& description) {
    tags_[kDescription] = description;
  }
 
  void setRequired(bool required = true) {
    required_ = required;
  }
  bool isRequired() const {
    return required_;
  }
 
  virtual size_t getVariableSize() const = 0;
  virtual size_t collectVariableData(int8_t* data, size_t bufferSize) = 0;
  virtual const string& getElementTypeName() const = 0;
  virtual bool isAvailable() const = 0;
  bool isMapped() const {
    return layout_.isMapped() && pieceIndex_ != DataLayout::kNotFound;
  }
  virtual void print(ostream& out, const string& indent = "") const = 0;
  virtual void printCompact(ostream& out, const string& indent = "") const = 0;
  virtual void serialize(JsonWrapper& jsonWrapper, const JsonFormatProfileSpec& profile);
  virtual bool stageCurrentValue() {
    return isAvailable();
  }
 
  virtual void initToDefault() = 0;
  virtual unique_ptr<DataPiece> clone() const = 0;
 
 protected:
  bool isMatch(const DataPiece& rhs) const;
  virtual bool isSame(const DataPiece* rhs) const;
  void setIndexOffset(size_t pieceIndex, size_t offset) {
    pieceIndex_ = pieceIndex;
    offset_ = offset;
  }
  virtual bool copyFrom(const DataPiece* original) = 0;
 
  const string label_;
  const DataPieceType pieceType_;
  const size_t fixedSize_;
  size_t pieceIndex_;
  size_t offset_;
  DataLayout& layout_;
  map<string, string> tags_;
  bool required_;
 
  friend class DataLayout;
};
 
template <class T>
const string& getTypeName();
 
template <>
inline const string& getTypeName<string>() {
  static const string sName("string");
  return sName;
}
 
// The getTypeName<> POD specializations are defined out-of-line in DataLayout.cpp. Declare them
// here with VRS_API so consumers of the shared library see the import-side attribute at every call
// site (e.g. the inline DataPiece<T>::getElementTypeName()).
#define POD_MACRO(x) \
  template <>        \
  VRS_API const string& getTypeName<x>();
#include <vrs/helpers/PODMacro.inc>
 
#pragma pack(push, 1) // tells the compiler that the data might not be aligned
template <class T>
struct UnalignedValue {
  T value;
};
#pragma pack(pop)
 
template <class T>
T readUnaligned(const void* ptr) {
  return reinterpret_cast<const UnalignedValue<T>*>(ptr)->value;
}
 
template <class T>
void writeUnaligned(void* ptr, const T& value) {
  reinterpret_cast<UnalignedValue<T>*>(ptr)->value = value;
}
 
inline void unalignedCopy(void* dst, const void* src, size_t size) {
  memcpy(reinterpret_cast<char*>(dst), reinterpret_cast<const char*>(src), size);
}
 
} // namespace vrs
 
// These are required pretty much every single time we use DataLayout. Just include them all.
#ifndef DATA_PIECES_ARRAY_H
#include <vrs/DataPieceArray.h>
#endif
 
#ifndef DATA_PIECES_STRING_H
#include <vrs/DataPieceString.h>
#endif
 
#ifndef DATA_PIECES_STRING_MAP_H
#include <vrs/DataPieceStringMap.h>
#endif
 
#ifndef DATA_PIECES_VALUE_H
#include <vrs/DataPieceValue.h>
#endif
 
#ifndef DATA_PIECES_VECTOR_H
#include <vrs/DataPieceVector.h>
#endif
 
#endif // DATA_PIECES_H