struct Options parseOptions()

in tensorpipe/benchmark/options.cc [66:174]
104 lines of code
21 McCabe index (conditional complexity)

struct Options parseOptions(int argc, char** argv) {
  struct Options options;
  int opt;
  int flag = -1;

  enum Flags : int {
    MODE,
    TRANSPORT,
    CHANNEL,
    ADDRESS,
    NUM_ROUND_TRIPS,
    NUM_PAYLOADS,
    PAYLOAD_SIZE,
    NUM_TENSORS,
    TENSOR_SIZE,
    TENSOR_TYPE,
    METADATA_SIZE,
    CUDA_SYNC_PERIOD,
    HELP,
  };

  static struct option longOptions[] = {
      {"mode", required_argument, &flag, MODE},
      {"transport", required_argument, &flag, TRANSPORT},
      {"channel", required_argument, &flag, CHANNEL},
      {"address", required_argument, &flag, ADDRESS},
      {"num-round-trips", required_argument, &flag, NUM_ROUND_TRIPS},
      {"num-payloads", required_argument, &flag, NUM_PAYLOADS},
      {"payload-size", required_argument, &flag, PAYLOAD_SIZE},
      {"num-tensors", required_argument, &flag, NUM_TENSORS},
      {"tensor-size", required_argument, &flag, TENSOR_SIZE},
      {"tensor-type", required_argument, &flag, TENSOR_TYPE},
      {"metadata-size", required_argument, &flag, METADATA_SIZE},
      {"cuda-sync-period", required_argument, &flag, CUDA_SYNC_PERIOD},
      {"help", no_argument, &flag, HELP},
      {nullptr, 0, nullptr, 0}};

  while (1) {
    opt = getopt_long(argc, argv, "", longOptions, nullptr);
    if (opt == -1) {
      break;
    }
    if (opt != 0) {
      usage(EXIT_FAILURE, argv[0]);
      break;
    }
    switch (flag) {
      case MODE:
        options.mode = std::string(optarg);
        if (options.mode != "listen" && options.mode != "connect") {
          fprintf(stderr, "Error:\n");
          fprintf(stderr, "  --mode must be [listen|connect]\n");
          exit(EXIT_FAILURE);
        }
        break;
      case TRANSPORT:
        options.transport = std::string(optarg);
        break;
      case CHANNEL:
        options.channel = std::string(optarg);
        break;
      case ADDRESS:
        options.address = std::string(optarg);
        break;
      case NUM_ROUND_TRIPS:
        options.numRoundTrips = std::strtol(optarg, nullptr, 10);
        break;
      case NUM_PAYLOADS:
        options.numPayloads = std::strtoull(optarg, nullptr, 10);
        break;
      case PAYLOAD_SIZE:
        options.payloadSize = std::strtoull(optarg, nullptr, 10);
        break;
      case NUM_TENSORS:
        options.numTensors = std::strtoull(optarg, nullptr, 10);
        break;
      case TENSOR_SIZE:
        options.tensorSize = std::strtoull(optarg, nullptr, 10);
        break;
      case TENSOR_TYPE:
        if (std::string(optarg) == "cpu") {
          options.tensorType = TensorType::kCpu;
        } else if (std::string(optarg) == "cuda") {
          options.tensorType = TensorType::kCuda;
        } else {
          fprintf(stderr, "Error:\n");
          fprintf(stderr, "  --tensor-type must be [cpu|cuda]\n");
          exit(EXIT_FAILURE);
        }
        break;
      case METADATA_SIZE:
        options.metadataSize = std::strtoull(optarg, nullptr, 10);
        break;
      case CUDA_SYNC_PERIOD:
        options.cudaSyncPeriod = std::strtoull(optarg, nullptr, 10);
        break;
      case HELP:
        usage(EXIT_SUCCESS, argv[0]);
        break;
      default:
        usage(EXIT_FAILURE, argv[0]);
        break;
    }
  }

  validateOptions(options, argv[0]);

  return options;
}