: supported_buckets_(default_buckets), computed_quantiles_(supportedQuantiles().size(), 0.0) {}

    : supported_buckets_(supported_buckets),

      computed_quantiles_(HistogramStatisticsImpl::supportedQuantiles().size(), 0.0), unit_(unit) {

  refresh(histogram_ptr);

}

const std::vector<double>& HistogramStatisticsImpl::supportedQuantiles() const {

  CONSTRUCT_ON_FIRST_USE(std::vector<double>,

                         {0, 0.25, 0.5, 0.75, 0.90, 0.95, 0.99, 0.995, 0.999, 1});

}

std::vector<uint64_t> HistogramStatisticsImpl::computeDisjointBuckets() const {

  std::vector<uint64_t> buckets;

  buckets.reserve(computed_buckets_.size());

  uint64_t previous_computed_bucket = 0;

  for (uint64_t computed_bucket : computed_buckets_) {

    buckets.push_back(computed_bucket - previous_computed_bucket);

    previous_computed_bucket = computed_bucket;

  }

  return buckets;

}

std::string HistogramStatisticsImpl::quantileSummary() const {

  std::vector<std::string> summary;

  const std::vector<double>& supported_quantiles = supportedQuantiles();

  summary.reserve(supported_quantiles.size());

  for (size_t i = 0; i < supported_quantiles.size(); ++i) {

    summary.push_back(

        fmt::format("P{:g}: {:g}", 100 * supported_quantiles[i], computed_quantiles_[i]));

  }

  return absl::StrJoin(summary, ", ");

}

std::string HistogramStatisticsImpl::bucketSummary() const {

  std::vector<std::string> bucket_summary;

  ConstSupportedBuckets& supported_buckets = supportedBuckets();

  bucket_summary.reserve(supported_buckets.size());

  for (size_t i = 0; i < supported_buckets.size(); ++i) {

    bucket_summary.push_back(fmt::format("B{:g}: {}", supported_buckets[i], computed_buckets_[i]));

  }

  return absl::StrJoin(bucket_summary, ", ");

}

void HistogramStatisticsImpl::refresh(const histogram_t* new_histogram_ptr) {

  constexpr double percent_scale = Histogram::PercentScale;

  std::fill(computed_quantiles_.begin(), computed_quantiles_.end(), 0.0);

  ASSERT(supportedQuantiles().size() == computed_quantiles_.size());

  hist_approx_quantile(new_histogram_ptr, supportedQuantiles().data(), supportedQuantiles().size(),

                       computed_quantiles_.data());

  if (unit_ == Histogram::Unit::Percent) {

    for (double& val : computed_quantiles_) {

      val /= percent_scale;

    }

  }

  sample_count_ = hist_sample_count(new_histogram_ptr);

  sample_sum_ = hist_approx_sum(new_histogram_ptr);

  if (unit_ == Histogram::Unit::Percent) {

    sample_sum_ /= percent_scale;

  }

  computed_buckets_.clear();

  ConstSupportedBuckets& supported_buckets = supportedBuckets();

  computed_buckets_.reserve(supported_buckets.size());

  for (auto bucket : supported_buckets) {

    if (unit_ == Histogram::Unit::Percent) {

      bucket *= percent_scale;

    }

    computed_buckets_.emplace_back(hist_approx_count_below(new_histogram_ptr, bucket));

  }

  out_of_bound_count_ = hist_approx_count_above(new_histogram_ptr, supported_buckets.back());

}

    : configs_([&config, &context]() {

        std::vector<Config> configs;

        for (const auto& matcher : config.histogram_bucket_settings()) {

          std::vector<double> buckets{matcher.buckets().begin(), matcher.buckets().end()};

          std::sort(buckets.begin(), buckets.end());

          configs.emplace_back(Matchers::StringMatcherImpl(matcher.match(), context),

                               buckets.empty()

                                   ? absl::nullopt

                                   : absl::make_optional<ConstSupportedBuckets>(std::move(buckets)),

                               PROTOBUF_GET_OPTIONAL_WRAPPED(matcher, bins));

        }

        return configs;

      }()) {}

const ConstSupportedBuckets& HistogramSettingsImpl::buckets(absl::string_view stat_name) const {

  for (const auto& config : configs_) {

    if (config.matcher_.match(stat_name) && config.buckets_.has_value()) {

      return config.buckets_.value();

    }

  }

  return defaultBuckets();

}

absl::optional<uint32_t> HistogramSettingsImpl::bins(absl::string_view stat_name) const {

  for (const auto& config : configs_) {

    if (config.matcher_.match(stat_name) && config.bins_.has_value()) {

      return config.bins_;

    }

  }

  return {};

}

const ConstSupportedBuckets& HistogramSettingsImpl::defaultBuckets() {

  CONSTRUCT_ON_FIRST_USE(ConstSupportedBuckets,

                         {0.5, 1, 5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000,

                          60000, 300000, 600000, 1800000, 3600000});

}