libcamera/src/cam/options.cpp
Laurent Pinchart a22dcaaa78 cam: options: Don't implement move semantics for OptionsParser::Options
The compiler creates a move constructor automatically when none is
supplied, and it does the right thing by default in this case. Using
std::move() inside the function prevents the compiler from doing
return value optimization and actually hinders performances. Using
std::move() in the caller is unnecessary, the move constructor is used
automatically by the compiler.

For all these reasons remove the tentative optimization that resulted in
worse performances and worse code.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
2019-01-22 20:44:04 +02:00

181 lines
3.9 KiB
C++

/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* options.cpp - cam - Options parsing
*/
#include <getopt.h>
#include <iomanip>
#include <iostream>
#include <string.h>
#include "options.h"
void OptionsParser::addOption(int opt, const char *help, const char *name,
OptionArgument argument, const char *argumentName)
{
/*
* Options must have at least a short or long name, and a text message.
* If an argument is accepted, it must be described by argumentName.
*/
if (!isalnum(opt) && !name)
return;
if (!help || help[0] == '\0')
return;
if (argument != ArgumentNone && !argumentName)
return;
/* Reject duplicate options. */
if (optionsMap_.find(opt) != optionsMap_.end())
return;
options_.push_back(Option({ opt, name, argument, argumentName, help }));
optionsMap_[opt] = &options_.back();
}
OptionsParser::Options OptionsParser::parse(int argc, char **argv)
{
OptionsParser::Options options;
/*
* Allocate short and long options arrays large enough to contain all
* options.
*/
char shortOptions[options_.size() * 3 + 2] = {};
struct option longOptions[options_.size() + 1] = {};
unsigned int ids = 0;
unsigned int idl = 0;
shortOptions[ids++] = ':';
for (const Option &option : options_) {
if (option.hasShortOption()) {
shortOptions[ids++] = option.opt;
if (option.argument != ArgumentNone)
shortOptions[ids++] = ':';
if (option.argument == ArgumentOptional)
shortOptions[ids++] = ':';
}
if (option.hasLongOption()) {
longOptions[idl].name = option.name;
switch (option.argument) {
case ArgumentNone:
longOptions[idl].has_arg = no_argument;
break;
case ArgumentRequired:
longOptions[idl].has_arg = required_argument;
break;
case ArgumentOptional:
longOptions[idl].has_arg = optional_argument;
break;
}
longOptions[idl].flag = 0;
longOptions[idl].val = option.opt;
idl++;
}
}
opterr = 0;
while (true) {
int c = getopt_long(argc, argv, shortOptions, longOptions, nullptr);
if (c == -1)
break;
if (c == '?' || c == ':') {
if (c == '?')
std::cerr << "Invalid option ";
else
std::cerr << "Missing argument for option ";
std::cerr << argv[optind - 1] << std::endl;
usage();
options.clear();
break;
}
options.values_[c] = optarg ? optarg : "";
}
return options;
}
void OptionsParser::usage()
{
std::cerr << "Options:" << std::endl;
unsigned int indent = 0;
for (const Option &option : options_) {
unsigned int length = 14;
if (option.hasLongOption())
length += 2 + strlen(option.name);
if (option.argument != ArgumentNone)
length += 1 + strlen(option.argumentName);
if (option.argument == ArgumentOptional)
length += 2;
if (length > indent)
indent = length;
}
indent = (indent + 7) / 8 * 8;
for (const Option &option : options_) {
std::string argument;
if (option.hasShortOption())
argument = std::string(" -")
+ static_cast<char>(option.opt);
else
argument = " ";
if (option.hasLongOption()) {
if (option.hasShortOption())
argument += ", ";
else
argument += " ";
argument += std::string("--") + option.name;
};
if (option.argument != ArgumentNone) {
argument += std::string(" ");
if (option.argument == ArgumentOptional)
argument += "[";
argument += option.argumentName;
if (option.argument == ArgumentOptional)
argument += "]";
}
std::cerr << std::setw(indent) << std::left << argument;
std::cerr << option.help << std::endl;
}
}
OptionsParser::Options::Options()
{
}
bool OptionsParser::Options::valid() const
{
return !values_.empty();
}
bool OptionsParser::Options::isSet(int opt) const
{
return values_.find(opt) != values_.end();
}
const std::string &OptionsParser::Options::operator[](int opt) const
{
return values_.find(opt)->second;
}
void OptionsParser::Options::clear()
{
values_.clear();
}