DataReference.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 <cstdint>
 
#include <vector>
 
#include <vrs/VrsExport.h>
 
namespace vrs {
 
using std::vector;
 
class FileHandler;
 
class VRS_API DataReference {
 public:
  explicit DataReference(
      void* data1 = nullptr,
      uint32_t size1 = 0,
      void* data2 = nullptr,
      uint32_t size2 = 0)
      : data1_(data1), size1_(size1), data2_(data2), size2_(size2) {}
 
  template <class T>
  explicit DataReference(vector<T>& vectorT, void* data = nullptr, uint32_t size = 0)
      : DataReference(
            vectorT.data(),
            static_cast<uint32_t>(sizeof(T) * vectorT.size()),
            data,
            size) {}
 
  template <class T, class U>
  DataReference(vector<T>& vectorT, vector<U>& vectorU)
      : DataReference(
            vectorT.data(),
            static_cast<uint32_t>(sizeof(T) * vectorT.size()),
            vectorU.data(),
            static_cast<uint32_t>(sizeof(U) * vectorU.size())) {}
 
  template <class T, class U>
  DataReference(T& object, vector<U>& vectorU)
      : DataReference(
            &object,
            sizeof(T),
            vectorU.data(),
            static_cast<uint32_t>(sizeof(U) * vectorU.size())) {}
 
  template <class T>
  explicit DataReference(T& object, void* data = nullptr, uint32_t size = 0)
      : DataReference(&object, sizeof(T), data, size) {}
 
  void useRawData(void* data1, uint32_t size1, void* data2 = nullptr, uint32_t size2 = 0);
 
  template <class T>
  void useVector(vector<T>& vectorT, void* data = nullptr, uint32_t size = 0) {
    data1_ = vectorT.data();
    size1_ = static_cast<uint32_t>(sizeof(T) * vectorT.size());
    data2_ = data;
    size2_ = size;
  }
 
  template <class T>
  void useObject(T& object, void* data = nullptr, uint32_t size = 0) {
    data1_ = &object;
    size1_ = sizeof(T);
    data2_ = data;
    size2_ = size;
  }
 
  template <class T, class U>
  void useVectors(vector<T>& vectorT, vector<U>& vectorU) {
    data1_ = vectorT.data();
    size1_ = static_cast<uint32_t>(sizeof(T) * vectorT.size());
    data2_ = vectorU.data();
    size2_ = static_cast<uint32_t>(sizeof(U) * vectorU.size());
  }
 
  template <class T, class U>
  void useObjects(T& object1, U& object2) {
    data1_ = &object1;
    size1_ = sizeof(T);
    data2_ = &object2;
    size2_ = sizeof(U);
  }
 
  uint32_t getSize() const {
    return size1_ + size2_;
  }
 
  void copyTo(void* destination) const;
 
  int readFrom(FileHandler& file, uint32_t& outReadSize);
 
  void* getDataPtr1() const {
    return data1_;
  }
  uint32_t getDataSize1() const {
    return size1_;
  }
  void* getDataPtr2() const {
    return data2_;
  }
  uint32_t getDataSize2() const {
    return size2_;
  }
 
 private:
  void* data1_{};
  uint32_t size1_{};
  void* data2_{};
  uint32_t size2_{};
};
 
} // namespace vrs