DataPieceStringMap.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_STRING_MAP_H
#define DATA_PIECES_STRING_MAP_H
 
#ifndef DATA_PIECES_H
#include <vrs/DataPieces.h>
#endif
 
namespace vrs {
 
using std::ostream;
using std::string;
 
template <typename T>
class DataPieceStringMap : public DataPiece {
 public:
  explicit DataPieceStringMap(string label, map<string, T> defaultValues = {})
      : DataPiece(std::move(label), DataPieceType::StringMap, DataLayout::kVariableSize),
        defaultValues_{std::move(defaultValues)} {}
  explicit DataPieceStringMap(const MakerBundle& bundle);
 
  const string& getElementTypeName() const override {
    return vrs::getTypeName<T>();
  }
  size_t getVariableSize() const override;
  size_t collectVariableData(int8_t* data, size_t bufferSize) override;
 
  const map<string, T>& stagedValues() const {
    return stagedValues_;
  }
  map<string, T>& stagedValues() {
    return stagedValues_;
  }
  void stage(const map<string, T>& values) {
    stagedValues_ = values;
  }
  void stage(map<string, T>&& values) {
    stagedValues_ = std::move(values);
  }
 
  bool get(map<string, T>& outValues) const;
 
  void setDefault(const map<string, T>& values) {
    defaultValues_ = values;
  }
  void setDefault(map<string, T>&& values) {
    defaultValues_ = std::move(values);
  }
  const map<string, T>& getDefault() const {
    return defaultValues_;
  }
  void initToDefault() override {
    stagedValues_ = defaultValues_;
  }
 
  bool patchValue(const map<string, T>& values) const {
    auto* patchedPiece = layout_.getMappedPiece<DataPieceStringMap<T>>(pieceIndex_);
    return patchedPiece != nullptr && (patchedPiece->stage(values), true);
  }
 
  bool isAvailable() const override {
    size_t count = 0;
    return layout_.getVarData<int8_t>(offset_, count) != 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;
 
  bool stageCurrentValue() override {
    return get(stagedValues());
  }
 
  unique_ptr<DataPiece> clone() const override {
    auto other = std::make_unique<DataPieceStringMap<T>>(getLabel());
    other->tags_ = tags_;
    other->required_ = required_;
    other->defaultValues_ = defaultValues_;
    return other;
  }
 
 protected:
  bool copyFrom(const DataPiece* original) override {
    const DataPieceStringMap<T>* origMap = reinterpret_cast<const DataPieceStringMap<T>*>(original);
    return origMap->get(stagedValues_);
  }
 
 private:
  map<string, T> stagedValues_; // values to write to disk
  map<string, T> defaultValues_;
};
 
} // namespace vrs
 
#endif // DATA_PIECES_STRING_MAP_H