HelperFunctions.h

Go to the documentation of this file.

/* Copyright 2013-2019 Homegear GmbH
 *
 * libhomegear-base is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * libhomegear-base is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with libhomegear-base.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of portions of this program with the
 * OpenSSL library under certain conditions as described in each
 * individual source file, and distribute linked combinations
 * including the two.
 * You must obey the GNU Lesser General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * file(s) with this exception, you may extend this exception to your
 * version of the file(s), but you are not obligated to do so.  If you
 * do not wish to do so, delete this exception statement from your
 * version.  If you delete this exception statement from all source
 * files in the program, then also delete it here.
*/

#ifndef HELPERFUNCTIONS_H_
#define HELPERFUNCTIONS_H_

#include "../Variable.h"

#include <algorithm>
#include <ctime>
#include <map>
#include <fstream>
#include <sstream>
#include <mutex>
#include <random>
#include <vector>
#include <regex>
#include <unordered_set>

#include <gcrypt.h>

namespace BaseLib {
class SharedObjects;

class HelperFunctions {
 public:
  HelperFunctions();

  static int32_t compareConstant(const std::string &s1, const std::string &s2);

  static int64_t getTimezoneOffset();

  static int64_t getLocalTime();

  static int64_t getTime();

  static int64_t getTimeMicroseconds();

  static int64_t getTimeNanoseconds();

  static int64_t getTimeSeconds();

  static int32_t getFileLastModifiedTime(const std::string &filename);

  static std::string getTimeString(int64_t time = 0);

  static std::string getTimeString(std::string format, int64_t time = 0);

  static std::string getTimeUuid();

  static std::string getUuid1(bool useRandomNodeId = false);

  static std::string getUuid4();

  static inline std::string &ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), std::not1(std::ptr_fun<int, int>(std::isspace))));
    return s;
  }

  static inline std::string &rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), std::not1(std::ptr_fun<int, int>(std::isspace))).base(), s.end());
    return s;
  }

  static inline std::string &trim(std::string &s) {
    return ltrim(rtrim(s));
  }

  static inline std::string &toLower(std::string &s) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    return s;
  }

  static inline std::string &toUpper(std::string &s) {
    std::transform(s.begin(), s.end(), s.begin(), ::toupper);
    return s;
  }

  static inline size_t utf8StringSize(const std::string &s) {
    if (s.empty()) return 0;
    const unsigned char *pS = (const unsigned char *)s.c_str();
    size_t len = 0;
    while (*pS) len += (*pS++ & 0xc0) != 0x80;
    return len;
  }

  static std::string utf8Substring(const std::string &s, uint32_t start, uint32_t length) {
    //From http://www.zedwood.com/article/cpp-utf-8-mb_substr-function
    if (length == 0) return "";
    uint32_t c, i, ix, q, min = (unsigned)std::string::npos, max = (unsigned)std::string::npos;
    for (q = 0, i = 0, ix = s.length(); i < ix; i++, q++) {
      if (q == start) min = i;
      if (q <= start + length || length == std::string::npos) max = i;

      c = (unsigned char)s[i];
      if (c >= 0 && c <= 127) i += 0;
      else if ((c & 0xE0) == 0xC0) i += 1;
      else if ((c & 0xF0) == 0xE0) i += 2;
      else if ((c & 0xF8) == 0xF0) i += 3;
      else return ""; //invalid utf8
    }
    if (q <= start + length || length == (unsigned)std::string::npos) max = i;
    if (min == (unsigned)std::string::npos || max == (unsigned)std::string::npos) return "";
    return s.substr(min, max);
  }

  static std::string &stringReplace(std::string &haystack, const std::string &search, const std::string &replace);

  static std::string &regexReplace(std::string &haystack, const std::string &search, const std::string &replace, bool ignoreCase);

  static std::pair<std::string, std::string> splitFirst(std::string string, char delimiter);

  static std::pair<std::string, std::string> splitLast(std::string string, char delimiter);

  static std::vector<std::string> splitAll(std::string string, char delimiter);

  static inline bool isNotAlphaNumeric(char c) {
    return !(isalpha(c) || isdigit(c) || (c == '_') || (c == '-'));
  }

  static bool isAlphaNumeric(std::string &s, std::unordered_set<char> additionalCharacters = std::unordered_set<char>()) {
    return find_if
        (
            s.begin(),
            s.end(),
            [&](const char c) { return !(isalpha(c) || isdigit(c) || additionalCharacters.find(c) != additionalCharacters.end()); }
        ) == s.end();
  }

  static std::string stripNonAlphaNumeric(const std::string &s, const std::unordered_set<char> &whitelist = std::unordered_set<char>());

  static std::string stripNonPrintable(const std::string &s);

  static PVariable xml2variable(const xml_node *node, bool &isDataNode);

  static void variable2xml(xml_document *doc, xml_node *parentNode, const PVariable &variable);

  static bool getBigEndian();

  static int32_t getRandomNumber(int32_t min, int32_t max);

  static std::vector<uint8_t> getRandomBytes(uint32_t size);

  static void memcpyBigEndian(char *to, const char *from, const uint32_t &length);

  static void memcpyBigEndian(uint8_t *to, const uint8_t *from, const uint32_t &length);

  static void memcpyBigEndian(int32_t &to, const std::vector<uint8_t> &from);

  static void memcpyBigEndian(std::vector<uint8_t> &to, const int32_t &from);

  static void memcpyBigEndian(int64_t &to, const std::vector<uint8_t> &from);

  static void memcpyBigEndian(std::vector<uint8_t> &to, const int64_t &from);

  static std::vector<uint8_t> hexToBin(const std::string &data);

  static std::string getHexString(const uint8_t *buffer, uint32_t size);

  static std::string getHexString(const char *buffer, uint32_t size);

  static std::string getHexString(const std::vector<char> &data);

  static std::string getHexString(const std::string &data);

  static std::string getHexString(const std::vector<uint8_t> &data);

  static std::string getHexString(const std::vector<uint16_t> &data);

  static std::string getHexString(int32_t number, int32_t width = -1);

  static std::string getHexString(uint32_t number, int32_t width = -1);

  static std::string getHexString(int64_t number, int32_t width = -1);

  static std::string getHexString(uint64_t number, int32_t width = -1);

  static char getHexChar(int32_t nibble);

  static std::vector<char> getBinary(const std::string &hexString);

  static std::vector<uint8_t> getUBinary(const std::string &hexString);

  static std::vector<uint8_t> &getUBinary(const std::string &hexString, uint32_t size, std::vector<uint8_t> &binary);

  static std::vector<uint8_t> getUBinary(const std::vector<uint8_t> &hexData);

  static std::string getBinaryString(const std::string &hexString);

  static uid_t userId(const std::string &username);

  static gid_t groupId(const std::string &groupname);

  static std::string getGNUTLSCertVerificationError(uint32_t errorCode);

  static bool isShortCliCommand(const std::string &command);

  static bool checkCliCommand(const std::string &command, const std::string &longCommand, const std::string &shortCommand1, const std::string &shortCommand2, uint32_t minArgumentCount, std::vector<std::string> &arguments, bool &showHelp);

  static void *memrchr(const void *s, int c, size_t n);
 private:
  static const std::array<int32_t, 23> _asciiToBinaryTable;

  static const std::array<int32_t, 16> _binaryToASCIITable;

  static bool isBigEndian();
};
}
#endif