• uncrustify
  
• Мы используем clang-format

Vera++ is a programmable tool for verification, analysis and transformation of C++ source code.
The main usage scenarios that are foreseen for Vera++ are:
Ensure that the source code complies with the given coding standards and conventions.
Provide source code metrics and statistics.
Perform automated transformations of the source code, which can range from pretty-printing to diagnostics to fault injection and advanced testing.

if(s.length = A && strcmp(...) == 0) t = 1;
else if(s.length = B && strcmp(...) == 0) t = 2;
...

fmt   =       type == WCHARS("")            ? simple_formatter 
            : type == WCHARS("text")        ? simple_formatter 
            : type == WCHARS("integer")     ? integer_formatter 
            : type == WCHARS("decimal")     ? decimal_formatter 
            : type == WCHARS("currency")    ? currency_formatter 
            : type == WCHARS("date")        ? date_formatter 
            : type == WCHARS("date-local")  ? date_local_formatter 
            : type == WCHARS("time")        ? time_formatter 
            : type == WCHARS("time-local")  ? time_local_formatter 
            : type == WCHARS("enum")        ? enum_formatter 
            : fmt = simple_formatter;

fmt =
            type == WCHARS("")
                ? simple_formatter
                : type == WCHARS("text")
                      ? simple_formatter
                      : type == WCHARS("integer")
                            ? integer_formatter
                            : type == WCHARS("decimal")
                                  ? decimal_formatter
                                  : type == WCHARS("currency")
                                        ? currency_formatter
                                        : type == WCHARS("date")
                                              ? date_formatter
                                              : type == WCHARS("date-local")
                                                    ? date_local_formatter
                                                    : type == WCHARS("time")
                                                          ? time_formatter
                                                          : type == WCHARS(
                                                                        "time-"
                                                                        "local")
                                                                ? time_local_formatter
                                                                : type == WCHARS(
                                                                              "enum")
                                                                      ? enum_formatter
                                                                      : fmt =
                                                                            simple_formatter;

map_resolveFormatter 0.039
if_resolveFormatter 0.025

// std::map approach +++

// build formatter index
std::map<std::string, FormatterType> index = {
  { "text", simple_formatter },
  { "integer", integer_formatter },
  { "decimal", decimal_formatter },
  { "currency", currency_formatter },
  { "date", date_formatter },
  { "date-local", date_local_formatter },
  { "time", time_formatter },
  { "time-local", time_local_formatter },
  { "enum", enum_formatter }
};


FormatterType map_resolveFormatter(std::string name)
{
  auto it = index.find(name);
  return (it != index.end()) ? it->second : simple_formatter;
}
// std::map approach ---

// if approach +++
FormatterType if_resolveFormatter(std::string name)
{
  tool::chars name_chars = tool::chars(name.c_str(), name.size());
  return 
      name_chars == CHARS("text") ? simple_formatter
    : name_chars == CHARS("integer") ? integer_formatter
    : name_chars == CHARS("decimal") ? decimal_formatter
    : name_chars == CHARS("currency") ? currency_formatter
    : name_chars == CHARS("date") ? date_formatter
    : name_chars == CHARS("date-local") ? date_local_formatter
    : name_chars == CHARS("time") ? time_formatter
    : name_chars == CHARS("time-local") ? time_local_formatter
    : name_chars == CHARS("enum") ? enum_formatter 
    : simple_formatter;
}

// if approach ---

enum { TOTAL_RUNS = 1000 };

std::string input_tokens[] = { "", "text", "integer", "decimal", "currency", "date", "date-local", "time", "time-local", "enum"  };

std::vector<std::string> input;

void generate_input() {
  for (int n = 0; n < TOTAL_RUNS; ++n)
    input.push_back(std::string(input_tokens[std::rand() % items_in(input_tokens)]));
}

void run_test(FormatterType(*test)(std::string name), const char* name)
{
  auto start = std::chrono::steady_clock::now();
  unsigned tn = 0;
  for(int n = 0; n < TOTAL_RUNS; ++n)
    for (int i = 0; i < TOTAL_RUNS; ++i)
      tn += (unsigned)test(input[i]);
  auto finish = std::chrono::steady_clock::now();
  double elapsed_seconds = std::chrono::duration_cast<std::chrono::duration<double> >(finish - start).count();
  std::cout << name << " " << elapsed_seconds << " " << tn << std::endl;
}

int main() {
  generate_input();
  run_test(map_resolveFormatter, "map_resolveFormatter");
  run_test(if_resolveFormatter, "if_resolveFormatter");
  return 0;
}

CS>>// std::map approach +++

CS>>// build formatter index
CS>>std::map<std::string, FormatterType> index = {
CS>>  { "text", simple_formatter },
CS>>  { "integer", integer_formatter },
CS>>  { "decimal", decimal_formatter },
CS>>  { "currency", currency_formatter },
CS>>  { "date", date_formatter },
CS>>  { "date-local", date_local_formatter },
CS>>  { "time", time_formatter },
CS>>  { "time-local", time_local_formatter },
CS>>  { "enum", enum_formatter }
CS>>};
CS>>

{ foo: 1,
  bar: 2,
  zed: 3 }

CS>>map_resolveFormatter 0.039
CS>>if_resolveFormatter 0.025
CS>>

struct chars { 
  const char* start; 
  size_t length; 
}

CS>struct chars { 
CS>  const char* start; 
CS>  size_t length; 
CS>}

bool operator == ( const slice& r ) const
      {
        if( length != r.length )
          return false;
>>>        if( start == r.start )
>>>          return true;
        for( unsigned int i = 0; i < length; ++i )
          if( start[i] != r.start[i] )
            return false;
        return true;
      }

void generate_input() {
  for (int n = 0; n < TOTAL_RUNS; ++n)
    input.push_back(std::string(input_tokens[std::rand() % items_in(input_tokens)]));
}

CS>struct chars { 
CS>  const char* start; 
CS>  size_t length; 
CS>}
CS>

struct my_less{bool operator()(string_view x, string_view y) const {return x.size()==y.size()?x<y:x.size()<y.size();}};
const map<string_view, FormatterType, my_less> index = {...};