RecordReaders.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 <vrs/DataReference.h>
#include <vrs/Decompressor.h>
#include <vrs/ErrorCode.h>
#include <vrs/VrsExport.h>
 
namespace vrs {
 
class FileHandler;
 
class VRS_API RecordReader {
 public:
  virtual ~RecordReader();
 
  RecordReader* init(FileHandler& file, uint32_t diskSize, uint32_t expandedSize);
 
  virtual int read(DataReference& destination, uint32_t& outReadSize) = 0;
 
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int read(std::vector<T>& buffer) {
    DataReference bufferDataReference(buffer);
    uint32_t readSize = 0;
    int res = read(bufferDataReference, readSize);
    buffer.resize(readSize / sizeof(T));
    return res;
  }
 
  int read(void* destination, size_t size) {
    DataReference bufferDataReference(destination, static_cast<uint32_t>(size));
    uint32_t readSize = 0;
    const int res = read(bufferDataReference, readSize);
    if (res != 0) {
      return res;
    }
    return readSize == size ? 0 : READ_ERROR;
  }
 
  virtual void finish() {}
 
  uint32_t getUnreadDiskBytes() const {
    return remainingDiskBytes_;
  }
 
  uint32_t getUnreadBytes() const {
    return remainingUncompressedSize_;
  }
 
  int64_t getFileOffset() const;
 
  [[nodiscard]] virtual CompressionType getCompressionType() const = 0;
 
  // for warning/error throttling only
  const void* getRef() const {
    return file_;
  }
 
 protected:
  FileHandler* file_;
  uint32_t remainingDiskBytes_;
  uint32_t remainingUncompressedSize_;
};
 
class VRS_API UncompressedRecordReader : public RecordReader {
 public:
  int read(DataReference& destination, uint32_t& outReadSize) override;
  CompressionType getCompressionType() const override;
};
 
class VRS_API CompressedRecordReader : public RecordReader {
 public:
  void initCompressionType(CompressionType compressionType);
  int read(DataReference& destination, uint32_t& outReadSize) override;
  void finish() override;
  CompressionType getCompressionType() const override;
 
 private:
  int read(void* dest, uint32_t destSize, uint32_t overallSize, uint32_t& outReadSize);
 
  Decompressor decompressor_;
};
 
} // namespace vrs