static inline std::map<FormattingFlags, std::string> = {
   {FormattingFlags::unknow,  "unknown"},
// ...
};

base_error(const base_error &e) = default;
base_error& operator=(const base_error& e) = default;

if ((formattingFlags&FormattingFlags::ignoreFillIndirectErrors)==0)

    if (n>str.size())
        return "";

year = 2016
event = 'Referendum'
f'Results of the {year} {event}' # Results of the 2016 Referendum'

I>static inline std::map<FormattingFlags, std::string> = {
I>   {FormattingFlags::unknow,  "unknown"},
I>// ...
I>};
I>

#define MARTY_CPP_ENUM_DESERIALIZE_ITEM( val, valStr )                       \
        _m[lowerCaseConvert ? marty_cpp::toLower(std::string(valStr)) : std::string(valStr)] = val

I>base_error(const base_error &e) = default;
I>base_error& operator=(const base_error& e) = default;
I>

I>if ((formattingFlags&FormattingFlags::ignoreFillIndirectErrors)==0)
I>

I> не читается без пробелов вокруг &

I>    if (n>str.size())
I>        return "";
I>

int main(int argc, char* argv[])
{
    (void)(argc);
    (void)(argv);

I>>static inline std::map<FormattingFlags, std::string> = {
I>>   {FormattingFlags::unknow,  "unknown"},
I>>// ...
I>>};
I>>

M>#define MARTY_CPP_ENUM_DESERIALIZE_ITEM( val, valStr )                       \
M>        _m[lowerCaseConvert ? marty_cpp::toLower(std::string(valStr)) : std::string(valStr)] = val
M>

auto optionalError = [&](const std::string &msg)
{
    if (ignoreErrors)  // Тут по названия !ignoreErrors
        throw std::runtime_error(msg);
};

if ((formattingFlags&FormattingFlags::ignoreFormattingErrors)==0)
    throw; // Прокидываем исключение выше

inline constexpr bool isFormatSignMarker(utf32_char_t ch)
{
    return ch==utf32_char_t('-') || ch==utf32_char_t('+') /*  || ch==utf32_char_t(' ') */ ;
}

inline constexpr bool isFormatSignMarker(utf32_char_t ch)
{
   swith(ch) {
      case '-':
      case '+':
      //case ' ':
         return true;
      default:
         return false;
   }
}

static inline std::set<utf32_char_t> formatSignMarker = {
    {'-'},
    {'+'},
//    {' '},
}

inline bool isFormatSignMarker(utf32_char_t ch) {
    return formatSignMarker.contains(ch);
}

I>>inline constexpr bool isFormatSignMarker(utf32_char_t ch)
I>>{
I>>    return ch==utf32_char_t('-') || ch==utf32_char_t('+') /*  || ch==utf32_char_t(' ') */ ;
I>>}
I>>

I>>inline constexpr bool isFormatSignMarker(utf32_char_t ch)
I>>{
I>>   swith(ch) {
I>>      case '-':
I>>      case '+':
I>>      //case ' ':
I>>         return true;
I>>      default:
I>>         return false;
I>>   }
I>>}
I>>

inline
constexpr
bool isFormatTypeChar(utf32_char_t ch)
{
    return ch==utf32_char_t('?') || ch==utf32_char_t('s') || ch==utf32_char_t('b') || ch==utf32_char_t('B') || ch==utf32_char_t('c')
        || ch==utf32_char_t('d') || ch==utf32_char_t('o') || ch==utf32_char_t('x') || ch==utf32_char_t('X') || ch==utf32_char_t('a')
        || ch==utf32_char_t('A') || ch==utf32_char_t('e') || ch==utf32_char_t('E') || ch==utf32_char_t('f') || ch==utf32_char_t('F')
        || ch==utf32_char_t('g') || ch==utf32_char_t('G') || ch==utf32_char_t('n') || ch==utf32_char_t('%');
}

    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "html-attr" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "html_attr" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlAttr   , "htmlattr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::none       , "none"      );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xml        , "xml"       );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xml-attr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xml_attr"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlAttr    , "xmlattr"   );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xml-text"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xml_text"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::xmlText    , "xmltext"   );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::html       , "html"      );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "html-text" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "html_text" );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::htmlText   , "htmltext"  );
    MARTY_CPP_ENUM_CLASS_DESERIALIZE_ITEM( StdFilterType::sql        , "sql"       );

    //! Подавление варнинга о неиспользованном аргументе
    #define MARTY_ARG_USED(x)                   (void)(x)

#define MARTY_CPP_ENUM_SERIALIZE_BEGIN( enumTypeName, mapType, doLower )     \
inline                                                                       \
mapType< enumTypeName, std::string > enum_serialize_make_map_##enumTypeName()\
{                                                                            \
     /* static  */ mapType< enumTypeName, std::string >  _m;                 \
    if (_m.empty())                                                          \
    {

inline                                                                       \
const mapType< enumTypeName, std::string >& enum_serialize_get_map_##enumTypeName() \
{                                                                            \
    static mapType< enumTypeName, std::string > m = enum_serialize_make_map_##enumTypeName();\
    return m;                                                               \
}

inline                                                                       \
std::string enum_serialize_##enumTypeName( enumTypeName v )                  \
{                                                                            \
    const auto &m = enum_serialize_get_map_##enumTypeName();                 \
    mapType< enumTypeName, std::string >::const_iterator it = m.find(v);     \
    if (it==m.end())                                                         \
        return std::string();                                                \
                                                                             \
    return it->second;                                                       \
}

template<typename StringType> inline
std::vector<StringType> simple_string_split(const StringType &str, const typename StringType::value_type delim, typename StringType::size_type nSplits = -1)

StringType::size_type

	Скрытый текст

• '%' — форматный символ, вывод процентов, плавучку умножает на 100, целые — не трогает, выводит, как 'd', затем выводит символ процента
  
• 'n' — форматный символ — вывод как 'd', но с локалью текущего пользователя. Обрабатывается в форматной строке, но локаль юзера не использует.
  
• '=' — маркер выравнивания по ширине
  
• '~' — маркер биткаста — знаковое целое конвертируется побитно в беззнаковое соответствующего типа — не надо ручками кастить, когда хочется хекс или бин вывести. "~X" выведет "FFFFFFFF" для -1 при 32х-битном целом.
  
• '!' — маркер инверсии регистра — при выводе хексов позволяет делать префикс в другом регистре — "!#X" выведет "0xDEADBEAF"
  
• 'h'/'H' — форматный символ для вывода хексов, без префикса, но суффиксом 'h'/'H', как в асме (если не задана опция '#' — то разницы не будет)
  
• 's'/'S' — форматный символ для типа bool — выводит bool, как строки true/false (TRUE/FALSE). Маркер инверсии регистра позволяет печатать True/False (tRUE/fALSE)
  
• 'y', 'Y' — форматный символ для типа bool и целых типов — выводит bool, как строки yes/no
  
• 't', 'T' — форматный символ для целых чисел, позволяет их выводить как bool — чтобы а) не кастить инты руками в бул, б) чтобы можно было использовать в своей скриптоте, где нет типа бул.
  
• Для форматных символов 'y', 'Y' и 't', 'T' маркер/опция '#' (alternate form) выводит первый символ строкового представления типа bool (или целого) — 't'/'T'/'f'/'F'/'y'/'Y'/'n'/'N'.
  Это равносильно, как задать точность ".1" при выводе строки.
  
• вывод const void* как указателя — хекс, размер по ширине типа указателя на платформе, также выводит инты как указатели, но соответственно своему размеру.
  
• '_', ',' и ''' — маркеры разделителя групп разрядов, для хекс и бин — по 4 разряда, для дек и окт — по 3. Задаются после ширины поля и после точности поля (для плавучки, если дробную часть надо разбить на разряды тоже).