functions.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_functions_hpp
#define anna_core_functions_hpp

#include <stdlib.h>

#include <anna/core/util/ComponentManager.hpp>
#include <anna/core/util/defines.hpp>
#include <anna/core/RuntimeException.hpp>

#include <anna/core/util/ExclusiveHash.hpp>
#include <anna/core/util/Second.hpp>
#include <anna/core/util/Millisecond.hpp>
#include <anna/core/util/Microsecond.hpp>

#include <anna/core/DataBlock.hpp>


#include <time.h>
#include <sys/time.h>
#include <string>
#include <vector>


//------------------------------------------------------------------------------
//---------------------------------------------------------------------- #define
//------------------------------------------------------------------------------
#define s_REGEXP_IPv4_ADDRESSES "\\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\b"
//#define s_REGEXP_IPv6_ADDRESSES "s*((([0-9A-Fa-f]{1,4}:){7}(([0-9A-Fa-f]{1,4})|:))|(([0-9A-Fa-f]{1,4}:){6}(:|((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})|(:[0-9A-Fa-f]{1,4})))|(([0-9A-Fa-f]{1,4}:){5}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){4}(:[0-9A-Fa-f]{1,4}){0,1}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){3}(:[0-9A-Fa-f]{1,4}){0,2}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){2}(:[0-9A-Fa-f]{1,4}){0,3}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)(:[0-9A-Fa-f]{1,4}){0,4}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(:(:[0-9A-Fa-f]{1,4}){0,5}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})))(%.+)?\\s*"
#define s_REGEXP_IPv6_ADDRESSES "s*((([0-9A-Fa-f]{1,4}:){7}(([0-9A-Fa-f]{1,4})|:))|(([0-9A-Fa-f]{1,4}:){6}(:|((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\
(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})|(:[0-9A-Fa-f]{1,4})))|(([0-9A-Fa-f]{1,4}:){5}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\
\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){4}(:[0-9A-Fa-f]{1,4}){0,1}((:((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(\
25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){3}(:[0-9A-Fa-f]{1,4}){0,2}((:((25[0-5]|2[0-4]\\d|[01]?\
\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:){2}(:[0-9A-Fa-f]{1,4}){0,3}((:((25[0-5]|2\
[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(([0-9A-Fa-f]{1,4}:)(:[0-9A-Fa-f]{1,4}){0,4}((:\
((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(:(:[0-9A-Fa-f]{1,4}){0,5}((:((25[0-\
5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})?)|((:[0-9A-Fa-f]{1,4}){1,2})))|(((25[0-5]|2[0-4]\\d|[01]?\\d{1,2})(\\.(25[\
0-5]|2[0-4]\\d|[01]?\\d{1,2})){3})))(%.+)?\\s*"

// Helpers for alarm parsing parameters:
#define STRING_WITH_QUOTATION_MARKS__C_STR(x)   ((anna::functions::addQuotationMarks(x)).c_str())
#define ANNA_AS_STRING__C_STR(x)             ((anna::functions::asString(x)).c_str())



namespace anna {

class DataBlock;

#ifdef __CYGWIN__
#define CLOCK_PROCESS_CPUTIME_ID CLOCK_PROCESS_CPUTIME
#endif


struct functions {
  static const int DateTimeSizeString = 21;

  static std::string getVersion() ;

  static std::string getArchitecture() ;

  static const int intBitSize = sizeof(int) * 8;

  /*
   * Indica el número de bits de un entero largo.
   */
  static const int int64BitSize = sizeof(S64) * 8;

  static std::string asString(const int number) ;

  static std::string asString(const unsigned int number) ;

  static std::string asString(const S64 number) ;

  static std::string asString(const U64 number) ;

  static const char* asString(const bool _bool) { return (_bool == true) ? "true" : "false"; }

  static std::string asString(const DataBlock& dataBlock, const int characterByLine = 16) ;

  static std::string asString(const double v, const char* format = "%e") ;

  static std::string asString(const float v, const char* format = "%f") ;

  static std::string asText(const char* comment, const int number)
  {
    std::string result(comment);
    return result += asString(number);
  }

  static std::string asText(const char* comment, const S64 number)
  {
    std::string result(comment);
    return result += asString(number);
  }

  static std::string asText(const char* comment, const bool _bool)
  {
    std::string result(comment);
    return result += asString(_bool);
  }

  static std::string asText(const char* comment, const DataBlock& dataBlock, const int characterByLine = 16)
  {
    std::string result(comment);
    return result += asString(dataBlock, characterByLine);
  }

  static std::string asText(const char* comment, const float value, const char* format = "%f")
  {
    std::string result(comment);
    return result += asString(value, format);
  }

  static std::string asText(const char* comment, const double value, const char* format = "%e")
  {
    std::string result(comment);
    return result += asString(value, format);
  }

  static std::string asHexString(const int number) ;

  static std::string asHexString(const S64 number) ;

  static std::string asHexString(const U64 number) { return asHexString((S64) number); }

  static std::string asHexText(const char* comment, const int number)
  {
    std::string result(comment);
    return result += asHexString(number);
  }

  static std::string asHexText(const char* comment, const S64 number)
  {
    std::string result(comment);
    return result += asHexString(number);
  }

  static std::string asHexString(const DataBlock& dataBlock) ;

  static DataBlock& fromHexString(const std::string& hexString, DataBlock& target) noexcept(false);

  static std::string asDateTime(const Second &second) ;

  static const char* asDateTime(const Second &second, char* result) ;

  static S64 hash(const char* str) ;

  static S64 hash(const std::string& str) { return hash(str.c_str()); }

  static std::string asString(const char* format, ...) ;

  template <typename T> static std::string asString(const T* t)
  {
    if(t == NULL) {
      std::string result(T::className());
      result += " { <null> }";
      return result;
    }

    return t->asString();
  }

  static const std::string& asString(const std::string& str) { return str; }

  static void sleep(const Millisecond &millisecond) ;

  static Second second() {
    Second result(::time(NULL));
    return result;
  }

  static Microsecond microsecond() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    Microsecond result((Microsecond::type_t)1000000 * tv.tv_sec + tv.tv_usec);
    return result;
  }

  static Millisecond millisecond() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    Millisecond result((Millisecond::type_t)1000 * tv.tv_sec + tv.tv_usec / 1000);
    return result;
  }

  static Microsecond hardwareClock() {
    timespec ts;
    //clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts); // DONT works (original)
    //clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts); // DONT works
    //clock_gettime(CLOCK_MONOTONIC, &ts); // works
      // Note that CLOCK_MONOTONIC is subject to discontinuities from system time
      //  adjustment in Linux. CLOCK_MONOTONIC_RAW was defined to get around this
      //  (gets hardware time not adjusted by NTP).
    clock_gettime(CLOCK_MONOTONIC, &ts); // works

    Microsecond result((Microsecond::type_t)1000000 * ts.tv_sec + ts.tv_nsec / 1000);
    return result;
  }

  static bool asBool(const char* str) noexcept(false);

  static int asInteger(const char* str) { return atoi(str); }

  static S64 asInteger64(const char* str) ;

  static pthread_t getCurrentThread() ;

  static bool supportMultithread() {
    WHEN_SINGLETHREAD(return false);
    WHEN_MULTITHREAD(return true);
  }

  static bool isLike(const char* pattern, const std::string& value) noexcept(false);

  static int bitsize(const int n) {  return (n == 0) ? 1 : functions::log2(n) + 1; }

  static int bitsize(const S64 n) {
    int aux = n >> intBitSize;
    return (aux != 0) ? (bitsize(aux) + intBitSize) : bitsize((int) n);
  }

  static S64 merge(const char* whatis, const int n1, const int n2, const int bitShift) noexcept(false);

  static int log2(const unsigned int v) ;




  // Text format resources /////////////////////////////////////////////////////////////////////////
  struct TextHighlightMode {
    enum _v {
      None = -1, // Initialized
      Overline,
      Underline,
      OverAndUnderline,
      Leftline,
      Rightline,
      LeftAndRightline
    };
  };

  struct TextJustifyMode {
    enum _v {
      None = -1, // Initialized
      Left,
      Center,
      Right
    };
  };

  static std::string entriesAsString(int number, const char * wordForSingular = NULL, const char * wordForPlural = NULL) ;

  static std::string justify(const std::string & title, TextJustifyMode::_v mode = TextJustifyMode::Left, char filler = ' ') ;

  static std::string highlight(const std::string & title, TextHighlightMode::_v mode = TextHighlightMode::Underline, char filler = '-', bool appendCR = true) ;

  static std::string highlightJustify(const std::string & title, TextHighlightMode::_v hMode = TextHighlightMode::OverAndUnderline, TextJustifyMode::_v jMode = TextJustifyMode::Center, char highlightFiller = '=', char justifyFiller = ' ', bool appendCR = true) {
    return(highlight(justify(title, jMode, justifyFiller), hMode, highlightFiller, appendCR));
  }

  static std::string tab(const std::string & text, int tabSpaces = 3) ;


  // Conversions and helpers ///////////////////////////////////////////////////////////////////////

  template <typename T> static T* componentByName(const char *className, const char* fromFile, const int fromLine)
  noexcept(false) {
    ComponentManager &cm = ComponentManager::instantiate();
    T* result = static_cast <T*>(cm.find(className));

    if(result == NULL) {
      std::string msg(className);
      msg += " | Unregistered component";
      throw RuntimeException(msg, fromFile, fromLine);
    }

    return result;
  }

  template <typename T> static T* component(const char* fromFile, const int fromLine)
  noexcept(false) {
    return functions::componentByName<T> (T::getClassName(), fromFile, fromLine);
  }

  static bool endsWith(const std::string & pattern, const std::string & suffix) {
    std::string dummy;
    return endsWith(pattern, suffix, dummy);
  }

  static bool endsWith(const std::string & pattern, const std::string & suffix, std::string & preffix) ;

  static bool startsWith(const std::string & pattern, const std::string & preffix) {
    std::string dummy;
    return startsWith(pattern, preffix, dummy);
  }

  static bool startsWith(const std::string & pattern, const std::string & preffix, std::string & suffix) ;

  static std::string replace(const std::string & text, const char *item, const char *target, bool all = true) ;

  static std::string addQuotationMarks(const std::string & str) ;
  static std::string addQuotationMarks(const char * str) ;
  static std::string addQuotationMarks(const int & integer) ;

  static std::string vectorToStringRepresentation(const std::vector<int> & v, const char separator = ' ') ;

  static std::string vectorToStringRepresentation(const std::vector<std::string> & v, const char separator = ' ') ;

  static std::string socketLiteralAsString(const std::string & address, int port) ;

  static std::string asAsciiString(const char * buffer, int size, bool & isFullyPrintable) ;

  static std::string asAsciiString(const char * buffer, int size) {
    bool isFullyPrintable;
    return asAsciiString(buffer, size, isFullyPrintable);
  }

  static std::string asAsciiString(const DataBlock & db, bool & isFullyPrintable) {
    return asAsciiString(db.getData(), db.getSize(), isFullyPrintable);
  }

  static std::string asAsciiString(const DataBlock & db) {
    bool isFullyPrintable;
    return asAsciiString(db.getData(), db.getSize(), isFullyPrintable);
  }


  static DataBlock rawIpPresentationAsRaw(const std::string & rawPresentation) noexcept(false);


  static std::string rawIpPresentationToIpAsString(const std::string & rawPresentation, bool normalize = false) noexcept(false) {
    return rawIpAsString(rawIpPresentationAsRaw(rawPresentation), normalize);
  }


  static std::string rawIpAsRawIpPresentation(const DataBlock & db) noexcept(false);


  static std::string getHostname() ;

  static std::string getDomainname() ;

  static std::string getFQDN(const char *hostname = NULL, const char  *domainname = NULL) ;

  static std::string getHostnameIP() ;



  // IP Address resources //////////////////////////////////////////////////////////////////////////

  struct IPv4Type {
    enum _v {
      Estrict = -1, // Initialized,
      Compatible,
      Mapped
    };
  };

  static bool isIPv4(const std::string & ip, IPv4Type::_v ipv4Type = IPv4Type::Estrict) ;

  static bool isIPv6(const std::string & ip) ;

  static std::string IPv4To6(const std::string & ipv4) noexcept(false);

  static std::string normalizeIP(const std::string & ip) noexcept(false);

  static bool sameIP(const std::string & ip1, const std::string & ip2) noexcept(false);

  static bool matchIPv6(const std::string & ipv6, const std::string & preffixedIpv6) noexcept(false);

  static DataBlock ipAsRaw(const std::string & ip) noexcept(false);

  static std::string rawIpAsString(const DataBlock & db, bool normalize = false) noexcept(false) {
    return (rawIpAsString(db.getData(), db.getSize(), normalize));
  }

  static std::string rawIpAsString(const char *buffer, int bufferLength, bool normalize = false) noexcept(false);

  static std::string abbreviateIP(const std::string & ip) noexcept(false) {
    return (rawIpAsString(ipAsRaw(ip)));
  }




  // socket literal description typedef, vectors and conversion tools

  static void getAddressAndPortFromSocketLiteral(const std::string &literal, std::string &address, int &port) ;

  static socket_v getSocketVectorFromString(const std::string & list) ;

  static std::string socketVectorAsString(const socket_v & socketVector) ;


  static bool littleEndian() ;

  static const char* codeInteger(char* result, const int n) ;

  static const char* codeShort(char* result, const short int n) ;

  static const char* codeInteger64(char* result, const S64 n) ;

  static const char* codeFloat(char* result, const float n) ;

  static const char* codeDouble(char* result, const double n) ;

  static int decodeInteger(const char* data)  ;

  static short int decodeShort(const char* data)  ;

  static S64 decodeInteger64(const char* data)  ;

  static float decodeFloat(const char* data)  ;

  static double decodeDouble(const char* data)  ;


  static void decodeIsupNumber(const char *buffer, int length, isup_number_t & isupNumber, bool calledOrCalling) noexcept(false);

  static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, char * buffer, int & length) noexcept(false);

  static void codeIsupNumber(const isup_number_t & isupNumber, bool calledOrCalling, std::string & target) noexcept(false);

  static std::string encodeBase64(const U8* buf, unsigned int bufLen);
  static std::string encodeBase64(const std::string & str)
  {
    return encodeBase64((const U8 *)str.c_str(), str.size());
  }

  static std::string decodeBase64(const std::string & encodedString);


  /*
  * Reads a file into passed string
  *
  * @param pathfile Path file to read
  * @param content String where file content is dump
  *
  * @return success for read operation
  */
  static bool getContentFromFile(const std::string &pathfile, std::string &content) noexcept(false);
};

}

#endif