int main()

in fbpcs/emp_games/lift/calculator/main.cpp [83:169]
68 lines of code
8 McCabe index (conditional complexity)

int main(int argc, char** argv) {
  folly::init(&argc, &argv);
  fbpcf::AwsSdk::aquire();
  gflags::ParseCommandLineFlags(&argc, &argv, true);

  std::vector<std::string> inputFilepaths;
  std::vector<std::string> outputFilepaths;

  if (!FLAGS_input_base_path.empty()) {
    std::string input_base_path = FLAGS_input_base_path + "_";
    std::string output_base_path = FLAGS_output_base_path + "_";
    for (auto i = FLAGS_file_start_index;
         i < FLAGS_file_start_index + FLAGS_num_files;
         ++i) {
      inputFilepaths.push_back(input_base_path + std::to_string(i));
      outputFilepaths.push_back(output_base_path + std::to_string(i));
    }
  } else {
    std::filesystem::path inputDirectory{FLAGS_input_directory};
    std::filesystem::path outputDirectory{FLAGS_output_directory};

    std::vector<std::string> inputFilenames;
    folly::split(',', FLAGS_input_filenames, inputFilenames);

    std::vector<std::string> outputFilenames;
    folly::split(",", FLAGS_output_filenames, outputFilenames);

    // Make sure the number of input files equals output files
    if (inputFilenames.size() != outputFilenames.size()) {
      XLOGF(
          ERR,
          "Error: input_filenames items ({}) does not equal output_filenames items ({})",
          inputFilenames.size(),
          outputFilenames.size());
      return 1;
    }

    for (std::size_t i = 0; i < inputFilenames.size(); ++i) {
      inputFilepaths.push_back(inputDirectory / inputFilenames[i]);
      outputFilepaths.push_back(outputDirectory / outputFilenames[i]);
    }
  }

  {
    // Build a quick list of input/output files to log
    std::ostringstream inputFileLogList;
    for (auto inputFilepath : inputFilepaths) {
      inputFileLogList << "\t\t" << inputFilepath << "\n";
    }
    std::ostringstream outputFileLogList;
    for (auto outputFilepath : outputFilepaths) {
      outputFileLogList << "\t\t" << outputFilepath << "\n";
    }
    XLOG(INFO) << "Running conversion lift with settings:\n"
               << "\tparty: " << FLAGS_party << "\n"
               << "\tserver_ip_address: " << FLAGS_server_ip << "\n"
               << "\tport: " << FLAGS_port << "\n"
               << "\tconcurrency: " << FLAGS_concurrency << "\n"
               << "\tinput: " << inputFileLogList.str() << "\n"
               << "\toutput: " << outputFileLogList.str();
  }

  auto party = static_cast<fbpcf::Party>(FLAGS_party);

  // since DEFINE_INT16 is not supported, cast int32_t FLAGS_concurrency to
  // int16_t is necessarys here
  int16_t concurrency = static_cast<int16_t>(FLAGS_concurrency);

  // construct calculatorApps according to  FLAGS_num_shards and
  // FLAGS_concurrency
  std::vector<std::unique_ptr<CalculatorApp>> calculatorApps;
  for (std::size_t i = 0; i < inputFilepaths.size(); i++) {
    calculatorApps.push_back(std::make_unique<CalculatorApp>(
        party,
        FLAGS_server_ip,
        FLAGS_port + i,
        inputFilepaths[i],
        outputFilepaths[i],
        FLAGS_use_xor_encryption));
  }

  // executor calculatorApps using fbpcf::MpcAppExecutor
  fbpcf::MpcAppExecutor<CalculatorApp> executor{concurrency};
  executor.execute(calculatorApps);

  return 0;
}