Add more examples

Author: evgeniums

docs/index.md

@@ -651,16 +651,17 @@ See examples below.
 ```cpp
 #include <dracosha/validator/validator.hpp>
 #include <dracosha/validator/validate.hpp>
+#include <dracosha/validator/operators/lexicographical.hpp>
 #include <dracosha/validator/prevalidation/set_validated.hpp>
 
 // define structure with member variables and member setter method
 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);
@@ -694,39 +695,34 @@ using namespace DRACOSHA_VALIDATOR_NAMESPACE;
 
 int main()
 {
+    // define validator of custom properties
+    auto v=validator(
+        _[bar_value](ilex_ne,"UNKNOWN"), // case insensitive lexicographical not equal
+        _[other_value](gte,1000)
+    );
 
-// define validator of custom properties
-auto v=validator(
-    _[bar_value](ilex_ne,"UNKNOWN"), // case insensitive lexicographical not equal
-    _[other_value](gte,1000)
-);
+    Foo foo_instance;
 
-Foo foo_instance;
+    error_report err;
 
-error_report err;
+    // call setter with valid data
+    set_validated(foo_instance,_[bar_value],"Hello world",v,err);
+    assert(!err);
 
-// call setter with valid data
-set_validated(foo_instance,bar_value,"Hello world",v,err);
-if (!err)
-{
-    // object's member is set
-}
+    // call setter with invalid data
+    set_validated(foo_instance,_[bar_value],"unknown",v,err);
+    assert(err);
+    if (err)
+    {
+        // object's member is not set
+        std::cerr << err.message() << std::endl;
+        assert(err.message()==std::string("bar_value must be not equal to UNKNOWN"));
+    }
 
-// call setter with invalid data
-set_validated(foo_instance,bar_value,"unknown",v,err);
-if (err)
-{
-    // object's member is not set
-    std::cerr << err.message() << std::endl;
-    /* prints:
-     
-     "bar_value must be not equal to UNKNOWN"
-     
-     */
+    std::cout << "Example 26 done" << std::endl;
+    return 0;
 }
 
-return 0;
-} 
 ```
 
 #### unset_validated
@@ -2094,6 +2090,7 @@ To use aggregation with modifier the modifier must be provided as an argument to
 See examples below.
 
 ```cpp
+#include <map>
 #include <dracosha/validator/validator.hpp>
 #include <dracosha/validator/properties/pair.hpp>
 
@@ -2512,6 +2509,8 @@ See example below.
 #include <dracosha/validator/value_transformer.hpp>
 #include <dracosha/validator/validator.hpp>
 
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
 namespace {
 // define handler that returns a size of provided string
 size_t string_size(const std::string& val) noexcept

examples/CMakeLists.txt

@@ -13,6 +13,21 @@ SET(SOURCES
     example10_custom_property_flag.cpp
     example11_heterogeneous_property_implicit.cpp
     example12_heterogeneous_property_explicit.cpp
+    example13_variadic_property.cpp
+    example14_variadic_property_aggregation.cpp
+    example15_operator_in.cpp
+    example16_operator_negation.cpp
+    example17_custom_operator.cpp
+    example18_move_copy.cpp
+    example19_lazy_operands.cpp
+    example20_operand_other_member.cpp
+    example21_operand_sample_object.cpp
+    example22_element_aggregation.cpp
+    example23_tree_validation.cpp
+    example24_partial_validation.cpp
+    example25_validate_evaluation_result.cpp
+    example26_prevalidate_set_member.cpp
+    example27_prevalidate_set_custom_property.cpp
 )
 
 ENABLE_TESTING(true)

examples/example13_variadic_property.cpp

@@ -0,0 +1,90 @@
+#undef NDEBUG
+
+#include <dracosha/validator/variadic_property.hpp>
+#include <dracosha/validator/validator.hpp>
+#include <dracosha/validator/adapters/reporting_adapter.hpp>
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
+// define a structure with variadic properties
+struct WithChild
+{
+    // method with one argument
+    int child(int val) const noexcept
+    {
+        return val+1;
+    }
+
+    // method with two arguments
+    int child_word(int val, const std::string& word) const noexcept
+    {
+        return val+static_cast<int>(word.size());
+    }
+
+    // method to check if object "has" child_world with provided arguments
+    bool has_child_word(int val, const std::string& word) const noexcept
+    {
+        return val>10 && word.size()>=5;
+    }
+};
+
+// define variadic property
+DRACOSHA_VALIDATOR_VARIADIC_PROPERTY(child)
+// define variadic property to be used as "exists" checker
+DRACOSHA_VALIDATOR_VARIADIC_PROPERTY(has_child_word)
+// define variadic property with "exists" checker
+DRACOSHA_VALIDATOR_VARIADIC_PROPERTY_HAS(child_word,has_child_word)
+
+int main()
+{
+    // define object
+    WithChild o1;
+
+    // define validation adapter with text reports
+    std::string rep;
+    auto ra1=make_reporting_adapter(o1,rep);
+
+    // variadic property with single argument and member notation
+    auto v1=validator(
+        _[child][varg(1)](eq,30)
+    );
+    assert(!v1.apply(ra1));
+    assert(rep==std::string("child(1) must be equal to 30"));
+    rep.clear();
+
+    // variadic property with single argument and property notation
+    auto v2=validator(
+        child(1)(eq,30)
+    );
+    assert(!v2.apply(ra1));
+    assert(rep==std::string("child(1) must be equal to 30"));
+    rep.clear();
+
+    // variadic property with two arguments and member notation
+    auto v3=validator(
+        _[child_word][varg(20)][varg("hello")](eq,30)
+    );
+    assert(!v3.apply(ra1));
+    assert(rep==std::string("child_word(20,hello) must be equal to 30"));
+    rep.clear();
+
+    // variadic property with two arguments and property notation
+    auto v4=validator(
+        child_word(20,"hello")(eq,30)
+    );
+    assert(!v4.apply(ra1));
+    assert(rep==std::string("child_word(20,hello) must be equal to 30"));
+    rep.clear();
+
+    // check if variadic property exists
+    auto v5=validator(
+        _[child_word][20]["hello"](exists,true)
+    );
+    assert(v5.apply(o1));
+    auto v6=validator(
+        _[child_word][5]["hello"](exists,true)
+    );
+    assert(!v6.apply(o1));
+
+    std::cout << "Example 13 done" << std::endl;
+    return 0;
+}

examples/example14_variadic_property_aggregation.cpp

@@ -0,0 +1,51 @@
+#undef NDEBUG
+
+#include <dracosha/validator/variadic_property.hpp>
+#include <dracosha/validator/validator.hpp>
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
+// sample struct
+struct Matrix
+{
+    size_t element(size_t i, size_t j) const noexcept
+    {
+        return i+j;
+    }
+
+    size_t count_i() const noexcept
+    {
+        return 1000;
+    }
+
+    size_t count_j() const noexcept
+    {
+        return 100;
+    }
+};
+
+// define variadic property
+DRACOSHA_VALIDATOR_VARIADIC_PROPERTY(element)
+
+// define "end" properties
+DRACOSHA_VALIDATOR_PROPERTY(count_i)
+DRACOSHA_VALIDATOR_PROPERTY(count_j)
+
+int main()
+{
+    Matrix m1;
+
+    // check if each element is greater than 100 - fails
+    auto v1=validator(
+        _[element][varg(ALL,count_i)][varg(ALL,count_j)](gt,100)
+    );
+    assert(!v1.apply(m1));
+
+    // check if at least one element is greater than 100 - succeeds
+    auto v2=validator(
+        _[element][varg(ANY,count_i)][varg(ANY,count_j)](gt,100)
+    );
+    assert(v2.apply(m1));
+
+    std::cout << "Example 14 done" << std::endl;
+    return 0;
+}

examples/example15_operator_in.cpp

@@ -0,0 +1,24 @@
+#undef NDEBUG
+
+#include <dracosha/validator/validator.hpp>
+#include <dracosha/validator/operators.hpp>
+#include <dracosha/validator/range.hpp>
+#include <dracosha/validator/interval.hpp>
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
+int main()
+{
+    // define value for validation
+    size_t val=90;
+
+    // check if the value is in range
+    auto v1=validator(in,range({70,80,90,100}));
+    assert(v1.apply(val));
+
+    // check if the value is in interval
+    auto v2=validator(in,interval(80,100));
+    assert(v2.apply(val));
+
+    std::cout << "Example 15 done" << std::endl;
+    return 0;
+}

examples/example16_operator_negation.cpp

@@ -0,0 +1,27 @@
+#undef NDEBUG
+
+#include <map>
+#include <dracosha/validator/validator.hpp>
+#include <dracosha/validator/operators.hpp>
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
+int main()
+{
+    // container to validate
+    std::map<std::string,uint32_t> m1={{"key1",100}};
+
+    // validator with original operator
+    auto v1=validator(
+        _["key1"](eq,100)
+    );
+    assert(v1.apply(m1));
+
+    // validator with negated operator
+    auto v2=validator(
+        _["key1"](_n(eq),100)
+    );
+    assert(!v2.apply(m1));
+
+    std::cout << "Example 16 done" << std::endl;
+    return 0;
+}

examples/example17_custom_operator.cpp

@@ -0,0 +1,45 @@
+#undef NDEBUG
+
+#include <dracosha/validator/validator.hpp>
+#include <dracosha/validator/validate.hpp>
+#include <dracosha/validator/operators/operator.hpp>
+using namespace DRACOSHA_VALIDATOR_NAMESPACE;
+
+// new operator implementation
+struct simple_eq_t : public op<simple_eq_t>
+{
+    // comparison operator with two templated arguments
+    template <typename T1, typename T2>
+    constexpr bool operator() (const T1& a, const T2& b) const
+    {
+        return a==b;
+    }
+
+    // direct error description
+    constexpr static const char* description="must be simply equal to";
+    // negated error description
+    constexpr static const char* n_description="must be not simply equal to";
+};
+// callable object to be used in validators
+constexpr simple_eq_t simple_eq{};
+
+int main()
+{
+    // define validator with custom operator
+    auto v1=validator(simple_eq,100);
+
+    error_report err;
+
+    // validate good value
+    validate(100,v1,err);
+    assert(!err);
+
+    // validate bad value
+    validate(90,v1,err);
+    assert(err);
+    std::cerr << err.message() << std::endl;
+    assert(err.message()==std::string("must be simply equal to 100"));
+
+    std::cout << "Example 17 done" << std::endl;
+    return 0;
+}