AggregationOutputMetrics computeAggregations()

in fbpcs/emp_games/attribution/decoupled_aggregation/Aggregation.hpp [226:310]
72 lines of code
10 McCabe index (conditional complexity)

AggregationOutputMetrics computeAggregations(
    const AggregationInputMetrics& inputData,
    fbpcf::Visibility outputVisibility) {
  auto ids = inputData.getIds();
  uint32_t numIds = ids.size();
  XLOGF(INFO, "Have {} ids", numIds);

  // Send over all of the data needed for this computation
  XLOG(INFO, "Sharing aggregation formats...");
  const auto aggregationFormats =
      shareAggregationFormats<MY_ROLE>(inputData.getAggregationFormats());

  const auto& adIds = shareValidAdIds<MY_ROLE>(inputData.getOriginalAdIds());

  MeasurementTpmArrays privateTpmArrays;
  MeasurementCvmArrays privateCvmArrays;
  std::vector<std::vector<PrivateAttributionResult>>
      privateTpmSecretSharePerRule;
  std::vector<std::vector<PrivateAttributionResult>>
      privateCvmSecretSharePerRule;
  for (const auto& aggregationFormat : aggregationFormats) {
    switch (aggregationFormat.id) {
      case AGGREGATION_FORMAT::AD_OBJECT_FORMAT:
        const auto& measurmentArrays =
            populateMetricsForAdObjectFormat<MY_ROLE>(inputData, numIds);
        privateTpmArrays = measurmentArrays.first;
        privateCvmArrays = measurmentArrays.second;
        break;
    }
  }

  PrivateAggregationMetrics aggregationMetrics{
      aggregationFormats, AggregationContext{adIds}, outputVisibility};

  AggregationOutputMetrics out;
  const auto& attributionRules = inputData.getAttributionRules();
  const auto& touchpointSecretShares = inputData.getTouchpointSecretShares();
  const auto& conversionSecretShares = inputData.getConversionSecretShares();

  for (std::vector<std::string>::size_type i = 0; i < attributionRules.size();
       i++) {
    // share secret shares computed for each attribution Rule
    XLOG(INFO, "Sharing touchpoint attribution results...");
    std::vector<std::vector<AttributionResult>> tpAttributionResultsPerRule;
    std::vector<std::vector<AttributionResult>> cvmAttributionResultsPerRule;
    // We will share attribution results per attribution rule.
    if (MY_ROLE == PUBLISHER) {
      for (const auto& entries : touchpointSecretShares.at(i)) {
        std::vector<AttributionResult> results;
        for (const auto& entry : entries) {
          results.push_back(AttributionResult{entry.isAttributed});
        }
        tpAttributionResultsPerRule.push_back(results);
      }
    }

    privateTpmSecretSharePerRule =
        privatelyShareAttributionResultsTouchpoints<MY_ROLE>(
            tpAttributionResultsPerRule, numIds);

    XLOG(INFO, "Sharing conversion attribution results...");
    if (MY_ROLE == PARTNER) {
      for (const auto& entries : conversionSecretShares.at(i)) {
        std::vector<AttributionResult> results;
        for (const auto& entry : entries) {
          results.push_back(AttributionResult{entry.isAttributed});
        }
        cvmAttributionResultsPerRule.push_back(results);
      }
    }
    privateCvmSecretSharePerRule =
        privatelyShareAttributionResultsConversions<MY_ROLE>(
            cvmAttributionResultsPerRule, numIds);

    PrivateAggregation privateAggregation;
    privateAggregation.privateTpm = privateTpmArrays;
    privateAggregation.privateCvm = privateCvmArrays;
    privateAggregation.tpAttributionResults = privateTpmSecretSharePerRule;
    privateAggregation.convAttributionResults = privateCvmSecretSharePerRule;
    aggregationMetrics.computeAggregationsPerFormat(privateAggregation);
    out.ruleToMetrics[attributionRules.at(i)] = aggregationMetrics.reveal();
  }

  return out;
}