Method serialize

bolt/exec/ContainerRow2RowSerde.cpp:20–71

static

namespace bytedance::bolt::exec {
// static
void ContainerRow2RowSerde::serialize(
    char* row,
    char*& current,
    const char* bufferEnd,
    const RowFormatInfo& info) {
  simd::memcpy(current, row, info.fixRowSize);
  char* currentHead = current;
  current += info.fixRowSize;

  for (const auto& [isStr, rowColumn] : info.variableColumns) {
    if (RowContainer::isNullAt(row, rowColumn)) {
      continue;
    }
    if (isStr) {
      const StringView& sv =
          *reinterpret_cast<StringView*>(row + rowColumn.offset());
      if (!sv.isInline()) {
        if (reinterpret_cast<const HashStringAllocator::Header*>(sv.data())[-1]
                .size() >= sv.size()) {
          simd::memcpy(current, sv.data(), sv.size());
        } else {
          auto stream = HashStringAllocator::prepareRead(
              HashStringAllocator::headerOf(sv.data()));
          stream->readBytes(current, sv.size());
        }
        // clear data ptr of StringView to increase compress ratio
        *(char**)(currentHead + rowColumn.offset() + sizeof(uint64_t)) =
            nullptr;
        current += sv.size();
        BOLT_CHECK(current <= bufferEnd);
      }
    } else {
      const auto value =
          *reinterpret_cast<std::string_view*>(row + rowColumn.offset());

      auto stream = HashStringAllocator::prepareRead(
          HashStringAllocator::headerOf(value.data()));
      stream->readBytes(current, value.size());
      current += value.size();
      BOLT_CHECK(current <= bufferEnd);
    }
  }
  for (auto& accumulator : info.serializableAccumulators) {
    current = accumulator.serializeAccumulator(currentHead, current);
    BOLT_CHECK(current <= bufferEnd);
  }

  // make row size aligned with alignment
  auto actualSize = current - currentHead;
  auto rowSize = bits::roundUp(actualSize, info.alignment);
  current += rowSize - actualSize;
}

// static
int32_t ContainerRow2RowSerde::deserialize(