Finished renames

Author: sea5kg

README.md

@@ -22,9 +22,9 @@ $ wsjcpp install "https://github.com/wsjcpp/wsjcpp-validators:master"
 
 ``` cpp
 
-WsjcppValidatorUUID *pValidatorUUID = new WsjcppValidatorUUID();
+validator_uuid *pValidatorUUID = new validator_uuid();
 std::string sError = "";
-if (!pValidatorUUID->isValid("abcdef01-ABCD-EF23-1000-000000000001", sError)) {
+if (!pValidatorUUID->is_valid("abcdef01-ABCD-EF23-1000-000000000001", sError)) {
     std::cout << sError << std::endl;
 }
 ```
@@ -36,39 +36,39 @@ Classes for data validation
 - `new WsjcppValidatorStringRegexpBase("testre", "^[a-zA-Z]+$")` - validate value by regular expression
 - `new WsjcppValidatorStringListBase("lang", {"en", "de", "ru"})` - validate value from a list
 - `new WsjcppValidatorEmail()` - validate format email
-- `new WsjcppValidatorUUID()` - validate format uuid
-- `new WsjcppValidatorStringLength(1,100)` - validate min length and max length
-- `new WsjcppValidatorJWT()` - validate format of JWT
+- `new validator_uuid()` - validate format uuid
+- `new validator_strlen(1,100)` - validate min length and max length
+- `new validator_jwt()` - validate format of JWT
 - `new WsjcppValidatorDate()` - validate format date like 'YYYY-MM-DD'
-- `new WsjcppValidatorTimeH24()` - validate format date like 'HH:mm:ss' (24 hours)
+- `new validator_time24()` - validate format date like 'HH:mm:ss' (24 hours)
 - `new WsjcppValidatorDateTime()` - validate format date like 'YYYY-MM-DD\THH:mm:ss'
 - `new WsjcppValidatorURL()` - validate format of url
-- `new WsjcppValidatorBase64()` - validate format of base64
+- `new validator_base64()` - validate format of base64
 - `new WsjcppValidatorNumber()` - validate format of number
 - `new WsjcppValidatorHex()` - validate hex value
 - `new WsjcppValidatorIntegerMinValue(1)` - validate integer min value
 - `new WsjcppValidatorIntegerMaxValue(100)` - validate integer max value
 
 ## Completed static functions
 
-- `WsjcppValidators::isValidDate(const std::string &sValue, std::string &sError)`
-- `WsjcppValidators::isValidTimeH24(const std::string &sValue, std::string &sError)`
-- `WsjcppValidators::isValidDomainName(const std::string &sValue, std::string &sError)`
-- `WsjcppValidators::isValidBase64(const std::string &sValue, std::string &sError)`
-- `WsjcppValidators::isValidIPv4(const std::string &sValue, std::string &sError)`
-- `WsjcppValidators::isValidIPv6(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validDate(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validTimeH24(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validDomainName(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validBase64(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validIPv4(const std::string &sValue, std::string &sError)`
+- `WsjcppValidators::is_validIPv6(const std::string &sValue, std::string &sError)`
 
 ## Example for your implementations
 
 ``` cpp
-class WsjcppValidatorUUID : public WsjcppValidatorStringRegexpBase {
+class validator_uuid : public WsjcppValidatorStringRegexpBase {
     public:
-        WsjcppValidatorUUID() 
+        validator_uuid() 
             : WsjcppValidatorStringRegexpBase(
                 "uuid", // name
                 "^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$"
             ) {
-            TAG = "WsjcppValidatorUUID";
+            TAG = "validator_uuid";
         }
 };
 ```

src/main.cpp

@@ -49,35 +49,35 @@ int main(int argc, char *argv[]) {
   }
   std::string sArg1(argv[1]);
 
-  std::vector<wsjcpp::WsjcppValidatorStringBase *> vValidators;
-  // vValidators.push_back(new WsjcppValidatorStringLength(5, 100));
-  // vValidators.push_back(new WsjcppValidatorStringLength(1, 5));
-  vValidators.push_back(new wsjcpp::WsjcppValidatorEmail());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorUUID());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorStringListBase("lang", {"en", "de", "ru"}));
-  vValidators.push_back(new wsjcpp::WsjcppValidatorStringRegexpBase("testre", "^[a-zA-Z]+$"));
-  vValidators.push_back(new wsjcpp::WsjcppValidatorJWT());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorDate());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorTimeH24());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorDateTime());
-  // vValidators.push_back(new WsjcppValidatorURL());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorBase64());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorNumber());
-  vValidators.push_back(new wsjcpp::WsjcppValidatorHex());
+  std::vector<wsjcpp::validator<std::string> *> validators;
+  // validators.push_back(new validator_strlen(5, 100));
+  // validators.push_back(new validator_strlen(1, 5));
+  validators.push_back(new wsjcpp::validator_email());
+  validators.push_back(new wsjcpp::validator_uuid());
+  validators.push_back(new wsjcpp::validator_str_list("lang", {"en", "de", "ru"}));
+  validators.push_back(new wsjcpp::validator_regexp("testre", "^[a-zA-Z]+$"));
+  validators.push_back(new wsjcpp::validator_jwt());
+  // validators.push_back(new wsjcpp::validator_date());
+  validators.push_back(new wsjcpp::validator_time24());
+  validators.push_back(new wsjcpp::validator_datetime());
+  validators.push_back(new wsjcpp::validator_url());
+  validators.push_back(new wsjcpp::validator_base64());
+  validators.push_back(new wsjcpp::validator_int());
+  validators.push_back(new wsjcpp::validator_hex());
 
   std::string sResult = "";
-  for (int i = 0; i < vValidators.size(); i++) {
-    wsjcpp::WsjcppValidatorStringBase *pValidator = vValidators[i];
+  for (int i = 0; i < validators.size(); i++) {
+    wsjcpp::validator<std::string> *pValidator = validators[i];
     std::string sError;
     if (sResult.size() > 0) {
       sResult += ",";
     }
-    if (pValidator->isValid(sArg1, sError)) {
-      sResult += " +" + pValidator->getTypeName();
-      // WsjcppLog::ok(TAG, "ok -> [" + pValidator->getTypeName() + "]: '" + sArg1 + "'");
+    if (pValidator->is_valid(sArg1, sError)) {
+      sResult += " +" + pValidator->name();
+      // WsjcppLog::ok(TAG, "ok -> [" + pValidator->name() + "]: '" + sArg1 + "'");
     } else {
-      sResult += " -" + pValidator->getTypeName();
-      // WsjcppLog::err(TAG, "fail -> [" + pValidator->getTypeName() + "]: '" + sArg1 + "' - " + sError);
+      sResult += " -" + pValidator->name();
+      // WsjcppLog::err(TAG, "fail -> [" + pValidator->name() + "]: '" + sArg1 + "' - " + sError);
     }
   }
   std::cout << sResult << std::endl;

src/tests/test_is_validator_base64.cpp

@@ -24,12 +24,12 @@ int main() {
   tests.push_back(local("+/11", true));
   tests.push_back(local("%$", false));
 
-  wsjcpp::WsjcppValidatorBase64 *pValidator = new wsjcpp::WsjcppValidatorBase64();
+  wsjcpp::validator_base64 *pValidator = new wsjcpp::validator_base64();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

src/tests/test_is_validator_date.cpp

@@ -29,12 +29,12 @@ int main() {
   tests.push_back(local("1898-15-01", false));
   tests.push_back(local("1898-01-32", false));
 
-  wsjcpp::WsjcppValidatorDate *pValidator = new wsjcpp::WsjcppValidatorDate();
+  wsjcpp::validator_date *pValidator = new wsjcpp::validator_date();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

src/tests/test_is_validator_datetime.cpp

@@ -27,12 +27,12 @@ int main() {
   tests.push_back(local("18a8-01-01T00:00:00", false));
   tests.push_back(local("1838-01-01T25:00:00", false));
 
-  wsjcpp::WsjcppValidatorDateTime *pValidator = new wsjcpp::WsjcppValidatorDateTime();
+  wsjcpp::validator_datetime *pValidator = new wsjcpp::validator_datetime();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

src/tests/test_is_validator_email.cpp

@@ -24,12 +24,12 @@ int main() {
   tests.push_back(local("s_s-some@test.com", true));
   tests.push_back(local("s_s-some@test.c", false));
 
-  wsjcpp::WsjcppValidatorEmail *pValidator = new wsjcpp::WsjcppValidatorEmail();
+  wsjcpp::validator_email *pValidator = new wsjcpp::validator_email();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

src/tests/test_is_validator_hex.cpp

@@ -22,12 +22,12 @@ int main() {
   tests.push_back(local("abcdef0123456789ABCDEF", true));
   tests.push_back(local("0123J", false));
 
-  wsjcpp::WsjcppValidatorHex *pValidator = new wsjcpp::WsjcppValidatorHex();
+  wsjcpp::validator_hex *pValidator = new wsjcpp::validator_hex();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

src/tests/test_is_validator_number.cpp src/tests/test_is_validator_int.cppsrc/tests/test_is_validator_number.cpp renamed to src/tests/test_is_validator_int.cpp

@@ -25,12 +25,12 @@ int main() {
   tests.push_back(local("", false));
   tests.push_back(local("+2020", false));
 
-  wsjcpp::WsjcppValidatorNumber *pValidator = new wsjcpp::WsjcppValidatorNumber();
+  wsjcpp::validator_int *pValidator = new wsjcpp::validator_int();
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

…/test_is_validator_integer_max_value.cpp src/tests/test_is_validator_int_max.cppsrc/tests/test_is_validator_integer_max_value.cpp renamed to src/tests/test_is_validator_int_max.cpp src/tests/test_is_validator_integer_max_value.cpp renamed to src/tests/test_is_validator_int_max.cpp

@@ -23,12 +23,12 @@ int main() {
   tests.push_back(local(1001, false));
   tests.push_back(local(100100000, false));
 
-  wsjcpp::WsjcppValidatorIntegerMaxValue *pValidator = new wsjcpp::WsjcppValidatorIntegerMaxValue(1000);
+  wsjcpp::validator_int_max *pValidator = new wsjcpp::validator_int_max(1000);
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "

…/test_is_validator_integer_min_value.cpp src/tests/test_is_validator_int_min.cppsrc/tests/test_is_validator_integer_min_value.cpp renamed to src/tests/test_is_validator_int_min.cpp src/tests/test_is_validator_integer_min_value.cpp renamed to src/tests/test_is_validator_int_min.cpp

@@ -24,12 +24,12 @@ int main() {
   tests.push_back(local(1001, true));
   tests.push_back(local(100100000, true));
 
-  wsjcpp::WsjcppValidatorIntegerMinValue *pValidator = new wsjcpp::WsjcppValidatorIntegerMinValue(1);
+  wsjcpp::validator_int_min *pValidator = new wsjcpp::validator_int_min(1);
 
   for (int i = 0; i < tests.size(); i++) {
     local t = tests[i];
     std::string error;
-    bool got = pValidator->isValid(t.value, error);
+    bool got = pValidator->is_valid(t.value, error);
     if (got != t.expected) {
       found_errors++;
       std::cerr << "Expected " << (t.expected ? "true" : "false") << ", but got " << (got ? "true" : "false") << " for "