[Из песочницы] Валидация данных в C++ с использованием библиотеки cpp-validator27.10.2020 13:32

При расширенном использовании cpp-validator можно регистрировать новые валидируемые свойства объектов, настраивать генерацию текстовых описаний ошибок, добавлять новые операторы или создавать полностью новые адаптеры-обработчики правил валидаций, которые, вообще говоря, могут использоваться даже не для валидации как таковой, а для выполнения других специфических задач.

Текущий статус библиотеки

Библиотека cpp-validator доступна на GitHub по адресу https://github.com/evgeniums/cpp-validator и готова к использованию — на момент написания статьи номер стабильной версии 1.0.2. Библиотека распространяется под лицензией Boost 1.0.

Приветствуются замечания, пожелания и дополнения.

Примеры

Тривиальная валидация числа

// определение валидатора
auto v=validator(gt,100); // больше чем 100

// объект ошибки
error err;

// условия не выполнены
validate(90,v,err);
if (err)
{
  // валидация неуспешна
}

// условия выполнены
validate(200,v,err);
if (!err)
{
  // валидация успешна
}

Валидация с исключением

// определение валидатора
auto v=validator(gt,100); // больше чем 100

try
{
    validate(200,v); // успешно
    validate(90,v); // генерирует исключение
}
catch (const validation_error& err)
{
    std::cerr << err.what() << std::endl;
    /* напечатает:
    must be greater than 100
    */
}

Явное применение валидатора к переменной

// определение валидатора
auto v=validator(gt,100); // больше чем 100

// применить валидатор к переменным

int value1=90;
if (!v.apply(value1))
{
  // валидация неуспешна
}

int value2=200;
if (v.apply(value2))
{
  // валидация успешна
}

Составной валидатор

// валидатор: размер меньше 15 и значение бинарно больше или равно "sample string"
auto v=validator(
  length(lt,15),
  value(gte,"sample string")
);

// явное применение валидатора к переменным

std::string str1="sample";
if (!v.apply(str1))
{
  // валидация неупешна потому что sample бинарно меньше, чем sample string
}

std::string str2="sample string+";
if (v.apply(str2))
{
  // валидация успешна
}

std::string str3="too long sample string";
if (!v.apply(str3))
{
  // валидация неуспешна, потому что длина строки больше 15 символов
}

Проверить, что число входит в интервал, и напечатать описание ошибки

// валидатор: входит в интервал [95,100]
auto v=validator(in,interval(95,100));

// объект ошибки
error_report err;

// проверить значение
size_t val=90;
validate(val,v,err);
if (err)
{
    std::cerr << err.message() << std::endl; 
    /* напечатает:
    must be in interval [95,100]
    */
}

Составной валидатор для проверки элемента контейнера

// составной валидатор
auto v=validator(
                _["field1"](gte,"xxxxxx")
                 ^OR^
                _["field1"](size(gte,100) ^OR^ value(gte,"zzzzzzzzzzzz"))
            );

// валидация контейнера и печать ошибки

error_report err;
std::map test_map={{"field1","value1"}};
validate(test_map,v,err);
if (err)
{
    std::cerr << err.message() << std::endl;
    /* напечатает:
    field1 must be greater than or equal to xxxxxx OR size of field1 must be greater than or equal to 100 OR field1 must be greater than or equal to zzzzzzzzzzzz
    */
}

Проверить элементы вложенных контейнеров

// составной валидатор элементов вложенных контейнеров
auto v=validator(
                _["field1"][1](in,range({10,20,30,40,50})),
                _["field1"][2](lt,100),
                _["field2"](exists,false),
                _["field3"](empty(flag,true))
            );

// валидация вложенного контейнера и печать ошибки
error_report err;
std::map> nested_map={
            {"field1",{{1,5},{2,50}}},
            {"field3",{}}
        };
validate(nested_map,v,err);
if (err)
{
    std::cerr << err.message() << std::endl;
    /* напечатает:
    element #1 of field1 must be in range [10, 20, 30, 40, 50]
    */
}

Провести валидацию кастомного свойства объекта

// структура с getter методом
struct Foo
{
    bool red_color() const
    {
        return true;
    }
};

// зарегистрировать новое свойство red_color
DRACOSHA_VALIDATOR_PROPERTY_FLAG(red_color,"Must be red","Must be not red");

// валидатор зарегистрированного свойства red_color
auto v=validator(
    _[red_color](flag,false)
);

// провести валидацию кастомного свойства и напечатать ошибку

error_report err;
Foo foo_instance;
validate(foo_instance,v,err);
if (err)
{
    std::cerr << err.message() << std::endl;
    /* напечатает:
    "Must be not red"
    */
}

Пре-валидация данных перед записью

// структура с переменными и методом вида setter
struct Foo
{
    std::string bar_value;

    uint32_t other_value;
    size_t some_size;

    void set_bar_value(std::string val)
    {
        bar_value=std::move(val);
    }
};

using namespace DRACOSHA_VALIDATOR_NAMESPACE;

// зарегистрировать кастомные свойства
DRACOSHA_VALIDATOR_PROPERTY(bar_value);
DRACOSHA_VALIDATOR_PROPERTY(other_value);

// специализация шаблона класса set_member_t для записи свойства bar_value структуры Foo
DRACOSHA_VALIDATOR_NAMESPACE_BEGIN

template <>
struct set_member_t
{
    template 
    void operator() (
            ObjectT& obj,
            MemberT&&,
            ValueT&& val
        ) const
    {
        obj.set_bar_value(std::forward(val));
    }
};

DRACOSHA_VALIDATOR_NAMESPACE_END

// валидатор с кастомными свойствами
auto v=validator(
    _[bar_value](ilex_ne,"UNKNOWN"), // лексикографическое "не равно" без учета регистра
    _[other_value](gte,1000) // больше или равно 1000
);

Foo foo_instance;
error_report err;

// запись валидного значение в свойство bar_value объекта foo_instance
set_validated(foo_instance,bar_value,"Hello world",v,err);
if (!err)
{
    // свойство bar_value объекта foo_instance успешно записано
}

// попытка записи невалидного значение в свойство bar_value объекта foo_instance
set_validated(foo_instance,bar_value,"unknown",v,err);
if (err)
{
    // запись не удалась
    std::cerr << err.message() << std::endl;
    /* напечатает:
     bar_value must be not equal to UNKNOWN
     */
}

Один и тот же валидатор для пост-валидации и пре-валидации

#include 
#include 
#include 
using namespace DRACOSHA_VALIDATOR_NAMESPACE;

namespace validator_ns {

// зарегистрировать getter свойства "x"
DRACOSHA_VALIDATOR_PROPERTY(GetX);

// валидатор GetX
auto MyClassValidator=validator(
   /* 
   "x" в кавычках - это имя поля, которое писать в отчете вместо GetX;
   interval.open() - модификатор открытого интервала без учета граничных точек
   */
   _[GetX]("x")(in,interval(0,500,interval.open())) 
);

}
using namespace validator_ns;

// определение тестового класса  
class MyClass {
  double x;

public:

  // Конструктор с пост-валидацией
  MyClass(double _x) : x(_x) {
      validate(*this,MyClassValidator);
  }

  // Getter
  double GetX() const noexcept
  {
     return _x;
  }

  // Setter с пре-валидацией
  void SetX(double _x) {
    validate(_[validator_ns::GetX],_x,MyClassValidator);
    x = _x;
  }
};

int main()
{

// конструктор с валидным аргументом
try {
    MyClass obj1{100.0}; // ok
}
catch (const validation_error& err)
{
}

// конструктор с невалидным аргументом
try {
    MyClass obj2{1000.0}; // значение вне интервала
}
catch (const validation_error& err)
{
    std::cerr << err.what() << std::endl;
    /*
     напечатает:
     x must be in interval(0,500)
    */
}

MyClass obj3{100.0};

// запись с валидным аргументом
try {
    obj3.SetX(200.0); // ok
}
catch (const validation_error& err)
{
}

// попытка записи с невалидным аргументом
try {
    obj3.SetX(1000.0); // значение вне интервала
}
catch (const validation_error& err)
{
    std::cerr << err.what() << std::endl;
    /*
     напечатает:
     x must be in interval (0,500)
    */
}

return 0;
}

Перевод ошибок валидации на русский язык

// переводчик ключей контейнера на русский язык с учетом рода, падежа и числа
phrase_translator tr;
tr["password"]={
                    {"пароль"},
                    {"пароля",grammar_ru::roditelny_padezh}
               };
tr["hyperlink"]={
                    {{"гиперссылка",grammar_ru::zhensky_rod}},
                    {{"гиперссылки",grammar_ru::zhensky_rod},grammar_ru::roditelny_padezh}
                };
tr["words"]={
                {{"слова",grammar_ru::mn_chislo}}
            };

/* 
финальный переводчик включает в себя встроенный переводчик на русский
validator_translator_ru() и переводчик tr для имен элементов
*/
auto tr1=extend_translator(validator_translator_ru(),tr);

// контейнер для валидации
std::map m1={
    {"password","123456"},
    {"hyperlink","zzzzzzzzz"}
};

// адаптер с генерацией отчета об ошибке на русском языке
std::string rep;
auto ra1=make_reporting_adapter(m1,make_reporter(rep,make_formatter(tr1)));

// различные валидаторы и печать ошибок на русском языке

auto v1=validator(
    _["words"](exists,true)
 );
if (!v1.apply(ra1))
{
    std::cerr<