myvtm/Module/include/CommEntityHelpAgge.hpp

#ifndef RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_
#define RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_

#include <string>
#include <regex.h>
#include "SimpleString.h"

namespace SP
{
namespace Module
{
namespace Ulitily
{

bool IsValidUrl(const CSimpleStringA& value)
{
    if (value.IsNullOrEmpty()) {
        return false;
    } else {
        std::string strUrl = SP::Utility::ToLower(value.GetData());
        regex_t reg;
        CSimpleStringA pattern = "^((https|http)://)";
        pattern += "(([0-9a-z_!~*\\'().&=+$%-]+: )?[0-9a-z_!~*\\'().&=+$%-]+@)?";
        pattern += "(([0-9]{1,3}\\.){3}[0-9]{1,3}";
        pattern += "|";
        pattern += "([0-9a-z_!~*\\'()-]+\\.)*";
        pattern += "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\\.";
        pattern += "[a-z]{2,6})";
        pattern += "(:[0-9]{1,4})?";
        pattern += "((/?)|";
        pattern += "(/[0-9a-z_!~*\\'().;?:@&=+$,%#-]+)+/?)$";

        int ret = regcomp(&reg, pattern, REG_EXTENDED | REG_NOSUB);
        if (ret) {
            char ebuff[256];
            regerror(ret, &reg, ebuff, 256);
            Dbg("regex failed: %s", ebuff);
            return false;
        }

        //Dbg("pattern: %s", pattern.GetData());
        ret = regexec(&reg, strUrl.c_str(), 0, NULL, 0);
        if (0 == ret) {
            Dbg("correct url format: %s", strUrl.c_str());
            return true;
        } else {
            char ebuff[256];
            regerror(ret, &reg, ebuff, 256);
            Dbg("%s not match: %s", strUrl.c_str(), ebuff);
            return false;
        }
    }
}

bool IsNum(const std::string& value)
{
    if (value.empty()) {
        return false;
    }
    regex_t reg;
    const std::string pattern = "^[0-9]+$";
    int ret = regcomp(&reg, pattern.c_str(), REG_EXTENDED | REG_NOSUB);
    if (ret) {
        char ebuff[256];
        regerror(ret, &reg, ebuff, 256);
        Dbg("regex failed: %s", ebuff);
        return false;
    }

    ret = regexec(&reg, value.c_str(), 0, NULL, 0);
    if (0 == ret) {
        return true;
    } else {
        char ebuff[256];
        regerror(ret, &reg, ebuff, 256);
        Dbg("%s not match: %s", value.c_str(), ebuff);
        return false;
    }
}

bool CheckIPv4(const std::string& value)
{
    if (value.empty()) {
        return false;
    }
    std::vector<std::string> elems = SP::Utility::Split(value, '.');
    if (elems.size() != 4) {
        return false;
    }
    for (int i = 0; i < 4; i++) {
        if (!IsNum(elems[i])) {
            return false;
        }
        if (elems[i].find(' ') != std::string::npos) {
            return false;
        }
        if ((elems[i].find('0') == 0) && (elems[i].length() != 1)) {
            return false;
        }
    }

    if ((stoi(elems[0]) < 0 || stoi(elems[0]) > 255) ||
        (stoi(elems[1]) < 0 || stoi(elems[1]) > 255) ||
        (stoi(elems[2]) < 0 || stoi(elems[2]) > 255) ||
        (stoi(elems[3]) < 0 || stoi(elems[3]) > 255)) {
        return false;
    }
    return true;
}


}
}
}

#endif //RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_