aos/flatbuffer_merge.h

#ifndef AOS_FLATBUFFER_MERGE_H_
#define AOS_FLATBUFFER_MERGE_H_

#include <cstddef>
#include <string>

#include "aos/flatbuffers.h"
#include "flatbuffers/flatbuffers.h"

namespace aos {

flatbuffers::DetachedBuffer MergeFlatBuffers(
    const flatbuffers::TypeTable *typetable, const uint8_t *data1,
    const uint8_t *data2);

// Merges 2 flat buffers with the provided type table into the builder.  Returns
// the offset to the flatbuffers.
// One or both of t1 and t2 must be non-null.  If one is null, this method
// coppies instead of merging.
flatbuffers::Offset<flatbuffers::Table> MergeFlatBuffers(
    const flatbuffers::TypeTable *typetable, const flatbuffers::Table *t1,
    const flatbuffers::Table *t2, flatbuffers::FlatBufferBuilder *fbb);

template <class T>
inline flatbuffers::Offset<T> MergeFlatBuffers(
    const flatbuffers::Table *t1,
    const flatbuffers::Table *t2, flatbuffers::FlatBufferBuilder *fbb) {
  return MergeFlatBuffers(T::MiniReflectTypeTable(), t1, t2, fbb).o;
}

template <class T>
inline flatbuffers::DetachedBuffer MergeFlatBuffers(const uint8_t *data1,
                                                    const uint8_t *data2) {
  return MergeFlatBuffers(T::MiniReflectTypeTable(), data1, data2);
}

template <class T>
inline flatbuffers::DetachedBuffer MergeFlatBuffers(
    const flatbuffers::DetachedBuffer &data1,
    const flatbuffers::DetachedBuffer &data2) {
  return MergeFlatBuffers(T::MiniReflectTypeTable(), data1.data(),
                          data2.data());
}

template <class T>
inline aos::FlatbufferDetachedBuffer<T> MergeFlatBuffers(
    const aos::Flatbuffer<T> &fb1, const aos::Flatbuffer<T> &fb2) {
const uint8_t *data1 = fb1.data();
const uint8_t *data2 = fb2.data();
  return aos::FlatbufferDetachedBuffer<T>(
      MergeFlatBuffers(T::MiniReflectTypeTable(), data1, data2));
}

template <class T>
inline aos::FlatbufferDetachedBuffer<T> MergeFlatBuffers(const T *fb1,
                                                         const T *fb2) {
  flatbuffers::FlatBufferBuilder fbb;
  fbb.ForceDefaults(true);
  fbb.Finish(MergeFlatBuffers<T>(
      reinterpret_cast<const flatbuffers::Table *>(fb1),
      reinterpret_cast<const flatbuffers::Table *>(fb2), &fbb));
  return aos::FlatbufferDetachedBuffer<T>(fbb.Release());
}

template <class T>
inline flatbuffers::Offset<T> MergeFlatBuffers(
    const T *fb1, const T *fb2, flatbuffers::FlatBufferBuilder *fbb) {
  return MergeFlatBuffers<T>(reinterpret_cast<const flatbuffers::Table *>(fb1),
                             reinterpret_cast<const flatbuffers::Table *>(fb2),
                             fbb);
}

// Copies a flatbuffer by walking the tree and copying all the pieces.  This
// converts DAGs to trees.
template <class T>
inline flatbuffers::Offset<T> RecursiveCopyFlatBuffer(
    const T *t1, flatbuffers::FlatBufferBuilder *fbb) {
  return MergeFlatBuffers<T>(reinterpret_cast<const flatbuffers::Table *>(t1),
                             nullptr, fbb);
}

// Copies a flatbuffer by finding the extents of the memory using the typetable
// and copying the containing memory.  This doesn't allocate memory, and
// preserves DAGs.
flatbuffers::Offset<flatbuffers::Table> CopyFlatBuffer(
    const flatbuffers::Table *t1, const flatbuffers::TypeTable *typetable,
    flatbuffers::FlatBufferBuilder *fbb);

template <class T>
inline flatbuffers::Offset<T> CopyFlatBuffer(
    const T *t1, flatbuffers::FlatBufferBuilder *fbb) {
  return flatbuffers::Offset<T>(
      CopyFlatBuffer(reinterpret_cast<const flatbuffers::Table *>(t1),
                     T::MiniReflectTypeTable(), fbb)
          .o);
}

template <class T>
inline flatbuffers::Offset<T> CopyFlatBuffer(
    const Flatbuffer<T> &t1, flatbuffers::FlatBufferBuilder *fbb) {
  return flatbuffers::Offset<T>(
      CopyFlatBuffer(
          reinterpret_cast<const flatbuffers::Table *>(&t1.message()),
          T::MiniReflectTypeTable(), fbb)
          .o);
}

// Copies a flatbuffer by copying all the data without looking inside and
// pointing inside it.
template <class T>
inline flatbuffers::Offset<T> BlindCopyFlatBuffer(
    const Flatbuffer<T> &t, flatbuffers::FlatBufferBuilder *fbb) {
  // Enforce 8 byte alignment so anything inside the flatbuffer can be read.
  fbb->Align(sizeof(flatbuffers::largest_scalar_t));

  // We don't know how much of the start of the flatbuffer is padding.  The
  // safest thing to do from an alignment point of view (without looking inside)
  // is to copy the initial offset and leave it as dead space.
  fbb->PushBytes(t.data(), t.size());
  return fbb->GetSize() -
         flatbuffers::ReadScalar<flatbuffers::uoffset_t>(t.data());
}

template <class T>
inline flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<T>>>
RecursiveCopyVectorTable(const flatbuffers::Vector<flatbuffers::Offset<T>> *t1,
                         flatbuffers::FlatBufferBuilder *fbb) {
  if (t1 == nullptr) {
    return 0;
  }
  std::vector<flatbuffers::Offset<T>> v;
  for (const T *t : *t1) {
    v.emplace_back(RecursiveCopyFlatBuffer(t, fbb));
  }
  return fbb->CreateVector(v);
}

inline flatbuffers::Offset<
    flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
CopyVectorSharedString(
    const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *t1,
    flatbuffers::FlatBufferBuilder *fbb) {
  if (t1 == nullptr) {
    return 0;
  }
  std::vector<flatbuffers::Offset<flatbuffers::String>> v;
  for (const flatbuffers::String *t : *t1) {
    v.emplace_back(fbb->CreateSharedString(t));
  }
  return fbb->CreateVector(v);
}

template <class T>
inline FlatbufferDetachedBuffer<T> CopyFlatBuffer(const T *t) {
  flatbuffers::FlatBufferBuilder fbb;
  fbb.ForceDefaults(true);
  fbb.Finish(CopyFlatBuffer<T>(t, &fbb));
  return FlatbufferDetachedBuffer<T>(fbb.Release());
}

template <class T>
inline FlatbufferDetachedBuffer<T> RecursiveCopyFlatBuffer(const T *t) {
  flatbuffers::FlatBufferBuilder fbb;
  fbb.ForceDefaults(true);
  fbb.Finish(RecursiveCopyFlatBuffer<T>(t, &fbb));
  return FlatbufferDetachedBuffer<T>(fbb.Release());
}

// Compares 2 flatbuffers.  Returns true if they match, false otherwise.
bool CompareFlatBuffer(const flatbuffers::TypeTable *typetable,
                       const flatbuffers::Table *t1,
                       const flatbuffers::Table *t2);

template <class T>
inline bool CompareFlatBuffer(const T *t1, const T *t2) {
  return CompareFlatBuffer(T::MiniReflectTypeTable(),
                           reinterpret_cast<const flatbuffers::Table *>(t1),
                           reinterpret_cast<const flatbuffers::Table *>(t2));
}

template <class T>
inline bool CompareFlatBuffer(const aos::Flatbuffer<T> &t1,
                              const aos::Flatbuffer<T> &t2) {
  return t1.span() == t2.span();
}

}  // namespace aos

#endif  // AOS_FLATBUFFER_MERGE_H_