static absl::Status Deserialize()

in tfx_bsl/cc/sketches/quantiles_sketch.cc [195:256]
55 lines of code
7 McCabe index (conditional complexity)

  static absl::Status Deserialize(
      absl::string_view serialized,
      std::unique_ptr<QuantilesSketchImpl>* result) {
    Quantiles sketch_proto;
    if (!sketch_proto.ParseFromArray(serialized.data(), serialized.size())) {
      return absl::InvalidArgumentError(
          "Failed to parse serialized Quantiles sketch.");
    }
    std::vector<std::vector<Summary>> summaries;
    std::vector<std::vector<BufferEntry>> buffer_entries;
    const size_t num_streams = sketch_proto.streams_size();
    if (num_streams < 1) {
      return absl::InvalidArgumentError("Serialized sketch has no streams.");
    }

    summaries.reserve(num_streams);
    buffer_entries.reserve(num_streams);
    const double eps = sketch_proto.streams(0).eps();
    const int64_t max_num_elements = sketch_proto.streams(0).max_num_elements();
    const bool compacted = sketch_proto.streams(0).compacted();

    for (int stream_idx = 0; stream_idx < num_streams; ++stream_idx) {
      const Quantiles::Stream& stream_proto = sketch_proto.streams(stream_idx);

      // Recover summaries.
      std::vector<Summary> stream_summaries;
      const size_t num_summaries = stream_proto.summaries_size();
      stream_summaries.reserve(num_summaries);
      for (int i = 0; i < num_summaries; ++i) {
        const Quantiles::Stream::Summary& summary_proto =
            stream_proto.summaries(i);
        std::vector<SummaryEntry> summary_entries;
        const size_t num_summary_entries = summary_proto.value_size();
        summary_entries.reserve(num_summary_entries);
        for (int j = 0; j < num_summary_entries; ++j) {
          summary_entries.push_back(SummaryEntry(
              summary_proto.value(j), summary_proto.weight(j),
              summary_proto.min_rank(j), summary_proto.max_rank(j)));
        }
        Summary summary;
        summary.BuildFromSummaryEntries(summary_entries);
        stream_summaries.push_back(summary);
      }
      summaries.push_back(std::move(stream_summaries));

      // Recover buffer.
      const Quantiles::Stream::Buffer& buffer_proto = stream_proto.buffer();
      std::vector<BufferEntry> stream_buffer_entries;
      const size_t num_buffer_entries = buffer_proto.value_size();
      stream_buffer_entries.reserve(num_buffer_entries);
      for (int i = 0; i < num_buffer_entries; ++i) {
        stream_buffer_entries.push_back(
            BufferEntry(buffer_proto.value(i), buffer_proto.weight(i)));
      }
      buffer_entries.push_back(std::move(stream_buffer_entries));
    }

    *result = absl::make_unique<QuantilesSketchImpl>(
        eps, max_num_elements, num_streams, compacted, std::move(summaries),
        std::move(buffer_entries));
    return absl::OkStatus();
  }