DataPieceString.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_H
#define DATA_PIECES_STRING_H
 
#ifndef DATA_PIECES_H
#include <vrs/DataPieces.h>
#endif
 
#include <vrs/VrsExport.h>
 
namespace vrs {
 
using std::min;
using std::ostream;
using std::string;
 
class VRS_API DataPieceString : public DataPiece {
 public:
  explicit DataPieceString(string label, string defaultValue = {})
      : DataPiece(std::move(label), DataPieceType::String, DataLayout::kVariableSize),
        defaultString_{std::move(defaultValue)} {}
  explicit DataPieceString(const MakerBundle& bundle);
 
  const string& getElementTypeName() const override;
  size_t getVariableSize() const override {
    return stagedString_.size();
  }
  size_t collectVariableData(int8_t* data, size_t bufferSize) override;
 
  void stage(const string& string) {
    stagedString_ = string;
  }
  void stage(string&& string) {
    stagedString_ = std::move(string);
  }
  const string& stagedValue() const {
    return stagedString_;
  }
  string& stagedValue() {
    return stagedString_;
  }
 
  string get() const;
  bool get(string& outString) const;
 
  void setDefault(const string& defaultString) {
    defaultString_ = defaultString;
  }
  void setDefault(string&& defaultString) {
    defaultString_ = std::move(defaultString);
  }
  const string& getDefault() const {
    return defaultString_;
  }
 
  void initToDefault() override {
    stagedString_ = defaultString_;
  }
 
  bool patchValue(const string& str) const {
    auto* patchedPiece = layout_.getMappedPiece<DataPieceString>(pieceIndex_);
    return patchedPiece != nullptr && (patchedPiece->stage(str), true);
  }
 
  bool isAvailable() const override;
 
  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(stagedValue());
  }
 
  unique_ptr<DataPiece> clone() const override {
    auto other = std::make_unique<DataPieceString>(getLabel());
    other->tags_ = tags_;
    other->required_ = required_;
    other->defaultString_ = defaultString_;
    return other;
  }
 
 protected:
  bool copyFrom(const DataPiece* original) override {
    const DataPieceString* cloneString = reinterpret_cast<const DataPieceString*>(original);
    return cloneString->get(stagedString_);
  }
 
 private:
  string stagedString_;
  string defaultString_;
};
 
} // namespace vrs
 
#endif // DATA_PIECES_STRING_H