Record.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 <memory>
#include <vector>
 
#include <vrs/ForwardDefinitions.h>
#include <vrs/StreamId.h>
#include <vrs/VrsExport.h>
#include <vrs/helpers/EnumTemplates.hpp>
#include <vrs/helpers/IOVector.h>
 
namespace vrs {
 
using std::unique_ptr;
using std::vector;
 
class DataSource;
struct DataSlice;
class DirectWriteRecordData;
class BorrowedData;
class Compressor;
class RecordManager;
 
enum class CompressionType : uint8_t {
  None = 0, 
  Lz4, 
  Zstd, 
 
  COUNT
};
 
class VRS_API Record final {
 public:
  static const double kMaxTimestamp;
 
  enum class Type : uint8_t {
    UNDEFINED = 0, 
    STATE = 1, 
    CONFIGURATION = 2, 
    DATA = 3, 
    TAGS = 4, 
    COUNT 
  };
 
  void recycle();
 
  void set(
      double timestamp,
      Type type,
      uint32_t formatVersion,
      const DataSource& data,
      uint64_t creationOrder);
 
  void addDirectWriteRecordData(unique_ptr<DirectWriteRecordData>&& directWriteRecordData);
 
  void addBorrowedData(unique_ptr<BorrowedData>&& borrowedData);
 
  bool shouldTryToCompress() const;
 
  int compressRecord(Compressor& compressor, uint32_t& outCompressedSize);
 
  int writeRecord(
      WriteFileHandler& file,
      StreamId streamId,
      uint32_t& inOutRecordSize,
      Compressor& compressor,
      uint32_t compressedSize);
 
  double getTimestamp() const {
    return timestamp_;
  }
 
  uint64_t getCreationOrder() const {
    return creationOrder_;
  }
 
  size_t getSize() const {
    return usedBufferSize_;
  }
 
  Type getRecordType() const {
    return recordType_;
  }
 
  static const char* typeName(Type type);
 
 private:
  friend class RecordManager;
 
  explicit Record(RecordManager& recordManager);
  ~Record();
 
  double timestamp_{};
  Type recordType_{};
  uint32_t formatVersion_{};
  helpers::IOVector<uint8_t> buffer_;
  std::vector<DataSlice> compressorDataSlices_;
  size_t usedBufferSize_{}; // total uncompressed payload: owned + borrowed + direct-write
  size_t ownedSize_{}; // DataSource payload copied into buffer_, excluding borrowed/direct-write
  uint64_t creationOrder_{};
  unique_ptr<DirectWriteRecordData> directWriteRecordData_;
  unique_ptr<BorrowedData> borrowedData_;
 
  RecordManager& recordManager_;
};
 
VRS_API string toString(Record::Type recordType);
 
template <>
VRS_API Record::Type toEnum(const string& name);
 
} // namespace vrs