Recordable.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
 
#include <functional>
#include <map>
#include <memory>
#include <mutex>
#include <utility>
 
#include "DataSource.h"
#include "ForwardDefinitions.h"
#include "RecordManager.h"
#include "StreamId.h"
 
namespace vrs {
 
using std::map;
using std::string;
using std::vector;
 
struct StreamTags {
  map<string, string> user; 
  map<string, string> vrs; 
 
  bool operator==(const StreamTags& rhs) const {
    return user == rhs.user && vrs == rhs.vrs;
  }
};
 
class Recordable {
 protected:
  explicit Recordable(RecordableTypeId typeId, const string& flavor = {});
 
 public:
  virtual ~Recordable();
 
  string getRecordableName() const {
    return getStreamId().getName();
  }
 
  RecordableTypeId getRecordableTypeId() const {
    return typeId_;
  }
 
  uint16_t getRecordableInstanceId() const {
    return instanceId_;
  }
 
  StreamId getStreamId() const {
    return StreamId{typeId_, instanceId_};
  }
 
  void setRecordableIsActive(bool isActive) {
    isActive_ = isActive;
  }
 
  bool isRecordableActive() const {
    return isActive_;
  }
 
  void setCompression(CompressionPreset preset);
 
  bool addRecordFormat(
      Record::Type recordType,
      uint32_t formatVersion,
      const RecordFormat& format,
      const vector<const DataLayout*>& layouts = {});
 
  virtual const Record* createConfigurationRecord() = 0;
 
  virtual const Record* createStateRecord() = 0;
 
  using CreateRecordDelegate = std::function<const Record*(
      StreamId streamId,
      double timestamp,
      Record::Type recordType,
      uint32_t recordFormatVersion,
      const DataSource& data)>;
 
  void setCreateRecordDelegate(CreateRecordDelegate delegate) {
    createRecordDelegate_ = std::move(delegate);
  }
 
  void setTag(const string& tagName, const string& tagValue);
  void addTags(const map<string, string>& newTags);
  void addTags(const StreamTags& tags);
  const map<string, string>& getTags() const {
    return tags_.user;
  }
  const StreamTags& getStreamTags() const {
    return tags_;
  }
 
  const string& getSerialNumber() const {
    return getTag(tags_.vrs, getSerialNumberTagName());
  }
 
  static const string& getOriginalNameTagName() {
    static const string sOriginalRecordableNameTagName("VRS_Original_Recordable_Name");
    return sOriginalRecordableNameTagName;
  }
 
  static const string& getFlavorTagName() {
    static const string sFlavorTagName("VRS_Recordable_Flavor");
    return sFlavorTagName;
  }
 
  RecordManager& getRecordManager() {
    return recordManager_;
  }
 
  static const string& getSerialNumberTagName() {
    static const string sSerialNumberTagName("VRS_Serial_Number");
    return sSerialNumberTagName;
  }
 
  static void resetNewInstanceIds();
 
 protected:
  const Record* createRecord(
      double timestampSec,
      Record::Type recordType,
      uint32_t formatVersion,
      const DataSource& data = DataSource()) {
    return createRecordDelegate_
        ? createRecordDelegate_(getStreamId(), timestampSec, recordType, formatVersion, data)
        : recordManager_.createRecord(timestampSec, recordType, formatVersion, data);
  }
  const Record* createUncompressedRecord(
      double timestampSec,
      Record::Type recordType,
      uint32_t formatVersion,
      const DataSource& data,
      std::unique_ptr<DirectWriteRecordData>&& directWriteRecordData) {
    return recordManager_.createUncompressedRecord(
        timestampSec, recordType, formatVersion, data, std::move(directWriteRecordData));
  }
 
  map<string, string>& getVRSTags() {
    return tags_.vrs;
  }
 
 private:
  const RecordableTypeId typeId_;
  const uint16_t instanceId_;
  StreamTags tags_;
  RecordManager recordManager_;
  CreateRecordDelegate createRecordDelegate_;
  bool isActive_;
 
  friend class RecordFileWriter;
 
  static uint16_t getNewInstanceId(RecordableTypeId typeId = static_cast<RecordableTypeId>(0));
 
  static const string& getTag(const map<string, string>& tags, const string& name);
};
 
class TemporaryRecordableInstanceIdsResetter {
 public:
  TemporaryRecordableInstanceIdsResetter();
  ~TemporaryRecordableInstanceIdsResetter();
 
 private:
  std::unique_lock<std::recursive_mutex> lock_;
  map<RecordableTypeId, uint16_t> preservedState_;
};
 
} // namespace vrs