gelib.h

Go to the documentation of this file.

#ifndef MIDAS_GENERAL_H
#define MIDAS_GENERAL_H

#include <stdio.h>
#include <stdarg.h>

#ifdef _WINDOWS
#include  <windows.h>
#endif


namespace midaspace {

#define MAX_MSG_LENGTH 2047

#ifdef _WINDOWS
#define DIRSEPARATOR '\\'
#else
#define DIRSEPARATOR '/'
#endif

#ifdef _WINDOWS
#define NUM_DIGITS_IN_PRINTED_EXPONENT 3
#else
#define NUM_DIGITS_IN_PRINTED_EXPONENT 2
#endif

//#ifdef _MSVS(WIN32) || defined(WIN64)
#ifdef _MSVS
#define _STRCASECMP _stricmp
#else
#define _STRCASECMP strcasecmp
#endif



#ifdef _WINDOWS
#define TC_B_BLACK  FOREGROUND_GREEN
#define TC_D_BLACK  FOREGROUND_GREEN
#define TC_B_RED    FOREGROUND_RED
#define TC_D_RED    FOREGROUND_RED
#define TC_B_GREEN  FOREGROUND_GREEN
#define TC_D_GREEN  FOREGROUND_GREEN
#define TC_B_YELLOW FOREGROUND_RED | FOREGROUND_GREEN
#define TC_D_YELLOW FOREGROUND_RED | FOREGROUND_GREEN
#define TC_B_BLUE   FOREGROUND_BLUE
#define TC_D_BLUE   FOREGROUND_BLUE
#define TC_B_VIOLET FOREGROUND_BLUE | FOREGROUND_RED
#define TC_D_VIOLET FOREGROUND_BLUE | FOREGROUND_RED
#define TC_B_CYAN   FOREGROUND_GREEN | FOREGROUND_BLUE
#define TC_D_CYAN   FOREGROUND_GREEN | FOREGROUND_BLUE
#define TC_B_WHITE  FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
#define TC_D_WHITE  FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
//
#define TC_DEFAULT  TC_D_WHITE
#else
// Bright x Dark
#define TC_B_BLACK  "\033[0;30m"
#define TC_D_BLACK  "\033[1;30m"
#define TC_B_RED    "\033[0;31m"
#define TC_D_RED    "\033[1;31m"
#define TC_B_GREEN  "\033[0;32m"
#define TC_D_GREEN  "\033[1;32m"
#define TC_B_YELLOW "\033[0;33m"
#define TC_D_YELLOW "\033[1;33m"
#define TC_B_BLUE   "\033[0;34m"
#define TC_D_BLUE   "\033[1;34m"
#define TC_B_VIOLET "\033[0;35m"
#define TC_D_VIOLET "\033[1;35m"
#define TC_B_CYAN   "\033[0;36m"
#define TC_D_CYAN   "\033[1;36m"
#define TC_B_WHITE  "\033[0;37m"
#define TC_D_WHITE  "\033[1;37m"
//
#define TC_DEFAULT  "\033[0m"
#endif

enum ETCLR {
  ETC_VOID, ETC_B_BLACK, ETC_D_BLACK, ETC_B_RED, ETC_D_RED, ETC_B_GREEN, ETC_D_GREEN, ETC_B_YELLOW, ETC_D_YELLOW, ETC_B_BLUE, ETC_D_BLUE, ETC_B_VIOLET, ETC_D_VIOLET, ETC_B_CYAN, ETC_D_CYAN, ETC_B_WHITE, ETC_D_WHITE, ETC_DEFAULT
};

// conversion
#ifdef _WINDOWS
inline WORD        trmt_clr_int2clr (ETCLR clr)
#else
inline const char* trmt_clr_int2clr (ETCLR clr)
#endif
{
  switch (clr) {
  case ETC_B_BLACK:   return TC_B_BLACK;  break;
  case ETC_D_BLACK:   return TC_D_BLACK;  break;
  case ETC_B_RED:     return TC_B_RED;    break;
  case ETC_D_RED:     return TC_D_RED;    break;
  case ETC_B_GREEN:   return TC_B_GREEN;  break;
  case ETC_D_GREEN:   return TC_D_GREEN;  break;
  case ETC_B_YELLOW:  return TC_B_YELLOW; break;
  case ETC_D_YELLOW:  return TC_D_YELLOW; break;
  case ETC_B_BLUE:    return TC_B_BLUE;   break;
  case ETC_D_BLUE:    return TC_D_BLUE;   break;
  case ETC_B_VIOLET:  return TC_B_VIOLET; break;
  case ETC_D_VIOLET:  return TC_D_VIOLET; break;
  case ETC_B_CYAN:    return TC_B_CYAN;   break;
  case ETC_D_CYAN:    return TC_D_CYAN;   break;
  case ETC_B_WHITE:   return TC_B_WHITE;  break;
  case ETC_D_WHITE:   return TC_D_WHITE;  break;
  case ETC_DEFAULT:   return TC_DEFAULT;  break;
  case ETC_VOID:      return NULL;        break;
  }
  return NULL;
}

#ifdef _WINDOWS
#define CHANGE_CONSOLE_COLOUR(_1,_2)  SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), _2)
#else
#define CHANGE_CONSOLE_COLOUR(_1,_2)  fprintf (_1, "%s", _2)
#endif

inline void change_console_colour (FILE *stream, ETCLR clr)
{
  CHANGE_CONSOLE_COLOUR(stream, trmt_clr_int2clr(clr));
}


void errorr   (const char* file, int line, const char *format, ...);
void warningg (const char* file, int line, const char *format, ...);


#define  errol                      errorr (__FILE__, __LINE__, "za ktery muze autor teto sqele utility, bezte ho vytahat za usi")
#define _errorr0                    errorr (__FILE__, __LINE__, "za ktery muze autor teto sqele utility, bezte ho vytahat za usi")
#define _errorr1(_1)                errorr (__FILE__, __LINE__, _1)
#define _errorr2(_1,_2)             errorr (__FILE__, __LINE__, _1,_2)
#define _errorr3(_1,_2,_3)          errorr (__FILE__, __LINE__, _1,_2,_3)
#define _errorr4(_1,_2,_3,_4)       errorr (__FILE__, __LINE__, _1,_2,_3,_4)
#define _errorr5(_1,_2,_3,_4,_5)    errorr (__FILE__, __LINE__, _1,_2,_3,_4,_5)
#define _errorr6(_1,_2,_3,_4,_5,_6) errorr (__FILE__, __LINE__, _1,_2,_3,_4,_5,_6)

#define _errorr(_1) _errorr1(_1)


#define _warningg(_1) _warningg1(_1)

#define _warningg1(_1)             warningg (__FILE__, __LINE__, _1)
#define _warningg2(_1,_2)          warningg (__FILE__, __LINE__, _1,_2)
#define _warningg3(_1,_2,_3)       warningg (__FILE__, __LINE__, _1,_2,_3)
#define _warningg4(_1,_2,_3,_4)    warningg (__FILE__, __LINE__, _1,_2,_3,_4)
#define _warningg5(_1,_2,_3,_4,_5) warningg (__FILE__, __LINE__, _1,_2,_3,_4,_5)


void openFileTest (const FILE *stream, const char *name);

FILE* openFileN    (const char* File, int Line, const char *mode, const char *key, const char *name);
FILE* openFilePN   (const char* File, int Line, const char *mode, const char *key, const char *path, const char *name);
FILE* openFilePNS  (const char* File, int Line, const char *mode, const char *key, const char *path, const char *name, const char *suff);
FILE* openFilePNSS (const char* File, int Line, const char *mode, const char *key, const char *path, const char *name, const char *suff, const char *suff2);

#define _openFileN(_1,_2,_3)              openFileN   (__FILE__, __LINE__, _1,_2,_3)
#define _openFilePN(_1,_2,_3,_4)          openFilePN  (__FILE__, __LINE__, _1,_2,_3,_4)
#define _openFilePNS(_1,_2,_3,_4,_5)      openFilePNS (__FILE__, __LINE__, _1,_2,_3,_4,_5)
#define _openFilePNSS(_1,_2,_3,_4,_5,_6)  openFilePNSS(__FILE__, __LINE__, _1,_2,_3,_4,_5,_6)


//  misto "class" muzu asi psat "typename"
template <class ArgType> void allocate (ArgType*&   p, long a)                 { if (a)   p = new ArgType   [a];                                         else p = NULL; }
template <class ArgType> void allocate (ArgType**&  p, long a, long b)         { if (a) { p = new ArgType*  [a];  while (a--)  allocate (p[a], b);    }  else p = NULL; }
template <class ArgType> void allocate (ArgType***& p, long a, long b, long c) { if (a) { p = new ArgType** [a];  while (a--)  allocate (p[a], b, c); }  else p = NULL; }


// ***  DEALLOCATE field   *P  ***
template <class ArgType> void deallocateCheck    (ArgType*   p,                  bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else delete [] p;
}
template <class ArgType> void deallocateCheckUno (ArgType*   p,                  bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else delete p;
}

// ***  DEALLOCATE field  **P  ***
template <class ArgType> void deallocateCheck    (ArgType**  p, long a,          bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else { while (a--) deallocateCheck    (p[a],       check);  delete [] p; }
}
template <class ArgType> void deallocateCheckUno (ArgType**  p, long a,          bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else { while (a--) deallocateCheckUno (p[a],       check);  delete [] p; }
}

// ***  DEALLOCATE field ***P  ***
template <class ArgType> void deallocateCheck    (ArgType*** p, long a, long  b, bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else { while (a--) deallocateCheck    (p[a], b,    check);  delete [] p; }
}
template <class ArgType> void deallocateCheckUno  (ArgType*** p, long a, long  b, bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else { while (a--) deallocateCheckUno (p[a], b,    check);  delete [] p; }
}
template <class ArgType> void deallocateCheck    (ArgType*** p, long a, long *b, bool check=true)
{
  if (p == NULL) { if (check) _warningg ("Field for deallocation is NULL"); }
  else { while (a--) deallocateCheck    (p[a], b[a], check);  delete [] p; }
}


//memset (lid,-1,NumDomains*sizeof(long));
//
template <class ArgType> void fill_all_by (ArgType*   p, long a,                 ArgType value) {  while (a--) p[a] = value; }
template <class ArgType> void fill_all_by (ArgType**  p, long a, long b,         ArgType value) {  while (a--) fill_all_by (p[a], b, value); }
template <class ArgType> void fill_all_by (ArgType*** p, long a, long b, long c, ArgType value) {  while (a--) fill_all_by (p[a], b, c, value); }


template <class ArgType> void fill_row_by (ArgType** p, long i, long m, ArgType value) {  fill_all_by (p[i], m, value); }
template <class ArgType> void fill_col_by (ArgType** p, long n, long j, ArgType value) {  while (n--) p[n][j] = value; }


template <class ArgType> void allocate_another_val (long n, ArgType *&old_field)
{
  if (!n && old_field)  _errorr ("allocate_another_val: n == 0 and old_field != NULL  - forbidden");
  ArgType *new_field = new ArgType [n+1];
  while (n--) new_field[n] = old_field[n];
  delete [] old_field;
  old_field = new_field;
  new_field=NULL;
}

template <class ArgType> void allocate_another_uno_ptr (long n, ArgType **&old_field, long add=1)
{
  ArgType **new_field = new ArgType* [n+add];
  while (n--)  new_field[n] = old_field[n];
  delete [] old_field;
  old_field = new_field;
  new_field=NULL;
}

template <class ArgType> void setadd_another_uno_ptr (long &n, ArgType **&field, ArgType *p)
{
  allocate_another_uno_ptr (n, field);
  field[n++] = p;
}


template <class ArgType> void shake_down_ptr_array (long &n, ArgType *array)
{
  long i,j;
  
  for (j=0; j<n; j++)
    if (array[j] == NULL) break;
  
  for (i=j+1; i<n; i++)
    if (array[i]) {
      array[j++] = array[i];
      array[i] = NULL;
    }
  
  n=j;
}

template <class ArgType> long arrays_arenot_identical (long n, ArgType *a1, ArgType *a2)
{
  if (a1 && a2) {
    while (n--)  if (a1[n] != a2[n]) break;
    return n+1;
  }
  if (a1 == a2 && !n)  return 0;
  else                 return -1;
}

template <class ArgType> long is_member_of_array (ArgType val, long n, const ArgType *array)
{
  while (n--)  if (val == array[n]) break;
  return n+1;
}


template <class ArgType> bool members_are_unique (long n, const ArgType *array)
{
  long i,j;
  
  for (i=0; i<n-1; i++)
    for (j=i+1; j<n; j++)
      if (array[i] == array[j])  return false;
  
  return true;
}


template <class ArgType> bool same_array_elements_asym (long nx, const ArgType *x, long ny, const ArgType *y, bool same_dim=false)
{
  if (same_dim && nx!=ny) return false;
  
  long i,j;
  
  for (i=0; i<nx; i++) {
    for (j=0; j<ny; j++)
      if (x[i] == y[j]) break;
    
    if (j==ny) return false;
  }
  
  return true;
}

template <class ArgType> bool same_array_elements_sym (long nx, const ArgType *x, long ny, const ArgType *y, bool same_dim=false)
{
  if (! same_array_elements_asym(nx, x, ny, y, same_dim) ) return false;
  if (! same_array_elements_asym(ny, y, nx, x, same_dim) ) return false;
  return true;
}




template <class ArgType> void add_array (long &n1, ArgType *&array1, long n2, const ArgType *array2)
{
  if (n2 == 0)  return;
  
  ArgType *new_array = new ArgType [n1+n2];
  
  long i;
  for (i=0; i<n1; i++) new_array[   i] = array1[i];
  for (i=0; i<n2; i++) new_array[n1+i] = array2[i];
  
  delete [] array1;
  array1 = new_array;
  new_array = NULL;
  n1 = n1 + n2;
}
template <class ArgType> void add_array_unique (long &n1, ArgType *&array1, long n2, const ArgType *array2)
{
  long i, n3 = 0;
  for (i=0; i<n2; i++)  if (!is_member_of_array (array2[i], n1, array1))  n3++;
  
  if (n3 == 0)  return;
  
  ArgType *new_array = new ArgType [n1+n3];
  
  n3 = 0;
  for (i=0; i<n1; i++)                                                   new_array[n3++] = array1[i];
  for (i=0; i<n2; i++)  if (!is_member_of_array (array2[i], n1, array1)) new_array[n3++] = array2[i];
  
  delete [] array1;
  array1 = new_array;
  new_array = NULL;
  n1 = n3;
}

template <class ArgType> void interchange2 (ArgType &a, ArgType &b)
{
  ArgType aux;
  aux = b;
  b = a;
  a = aux;
}


} // namespace midaspace

#endif // MIDAS_GENERAL_H