std::shared_ptr FlowFileRecord::DeSerialize()

in libminifi/src/FlowFileRecord.cpp [176:272]

• 84 lines of code
• 18 McCabe index (conditional complexity)

std::shared_ptr<FlowFileRecord> FlowFileRecord::DeSerialize(io::InputStream& inStream, const std::shared_ptr<core::ContentRepository>& content_repo, utils::Identifier& container) {
  auto file = std::make_shared<FlowFileRecord>();

  {
    uint64_t event_time_in_ms;
    const auto ret = inStream.read(event_time_in_ms);
    if (ret != 8) {
      return {};
    }
    file->event_time_ = std::chrono::system_clock::time_point() + std::chrono::milliseconds(event_time_in_ms);
  }

  {
    uint64_t entry_date_in_ms;
    const auto ret = inStream.read(entry_date_in_ms);
    if (ret != 8) {
      return {};
    }
    file->entry_date_ = std::chrono::system_clock::time_point() + std::chrono::milliseconds(entry_date_in_ms);
  }

  {
    uint64_t lineage_start_date_in_ms;
    const auto ret = inStream.read(lineage_start_date_in_ms);
    if (ret != 8) {
      return {};
    }
    file->lineage_start_date_ = std::chrono::system_clock::time_point() + std::chrono::milliseconds(lineage_start_date_in_ms);
  }

  {
    const auto ret = inStream.read(file->uuid_);
    if (ret == 0 || io::isError(ret)) {
      return {};
    }
  }

  {
    const auto ret = inStream.read(container);
    if (ret == 0 || io::isError(ret)) {
      return {};
    }
  }

  // read flow attributes
  uint32_t numAttributes = 0;
  {
    const auto ret = inStream.read(numAttributes);
    if (ret != 4) {
      return {};
    }
  }

  for (uint32_t i = 0; i < numAttributes; i++) {
    std::string key;
    {
      const auto ret = inStream.read(key, true);
      if (ret == 0 || io::isError(ret)) {
        return {};
      }
    }
    std::string value;
    {
      const auto ret = inStream.read(value, true);
      if (ret == 0 || io::isError(ret)) {
        return {};
      }
    }
    file->attributes_[key] = value;
  }

  std::string content_full_path;
  {
    const auto ret = inStream.read(content_full_path);
    if (ret == 0 || io::isError(ret)) {
      return {};
    }
  }

  {
    const auto ret = inStream.read(file->size_);
    if (ret != 8) {
      return {};
    }
  }

  {
    const auto ret = inStream.read(file->offset_);
    if (ret != 8) {
      return {};
    }
  }

  file->claim_ = std::make_shared<ResourceClaim>(content_full_path, content_repo);

  return file;
}