utils.hpp

Go to the documentation of this file.

#ifndef _utils4_3_5_h_
#define _utils4_3_5_h_
//---------------------------------------------
#include<iostream>
#include<sstream>
#include<thread>
#include<mutex>
#include<chrono>
#include<vector>
  
using namespace std::chrono_literals;
 
#ifdef _WIN32 // Includes both 32 bit and 64 bit
  #include <windows.h>
  #define BLACK        0
  #define BBLACK       8
  #define RED          4
  #define BRED         12
  #define GREEN        2
  #define BGREEN       10
  #define YELLOW       6
  #define BYELLOW      14
  #define BLUE         1
  #define BBLUE        9
  #define MAGENTA      5
  #define BMAGENTA     13
  #define CYAN         3
  #define BCYAN        11
  #define WHITE        7
  #define BWHITE       15
  #define DEFAULT      7
 
  inline
  void SetColor(int color) {
    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hConsole, WORD(color) );
  }
 
#elif defined(__linux__) || defined(__APPLE__)
 
  #define BLACK        "\033[0;30m"
  #define BBLACK       "\033[1;30m"
  #define RED          "\033[0;31m"
  #define BRED         "\033[1;31m"
  #define GREEN        "\033[0;32m"
  #define BGREEN       "\033[1;32m"
  #define YELLOW       "\033[0;33m"
  #define BYELLOW      "\033[1;33m"
  #define BLUE         "\033[0;34m"
  #define BBLUE        "\033[1;34m"
  #define MAGENTA      "\033[0;35m"
  #define BMAGENTA     "\033[1;35m"
  #define CYAN         "\033[0;36m"
  #define BCYAN        "\033[1;36m"
  #define WHITE        "\033[0;37m"
  #define BWHITE       "\033[1;37m"
  #define DEFAULT      "\033[0m"
  
  inline
  void SetColor(const std::string& color) { std::cout << color; }
#endif
 
#ifdef __APPLE__
  class scoped_thr{
    std::thread t;
   public:
    explicit scoped_thr(std::thread&& t_): t(std::move(t_)){
      if(!t.joinable())
        throw std::logic_error("No thread");
    }
    ~scoped_thr() {t.join(); }
    scoped_thr()=delete;
    scoped_thr(scoped_thr const&)=delete;
    scoped_thr& operator=(scoped_thr const&)=delete;
  };
  template<class T>
  void println(const T& a) { std::cout << a << std::endl; }
  template<class T>
  void print(const T& a) { std::cout << a; }
#else
  constexpr void println(auto const& a) { std::cout << a << std::endl; }
  constexpr void print(auto const& a) { std::cout << a; }
#endif  
 
inline
void time_info(const long long& time, std::ostream& out){
  out << "The time of the CMMTree calculations : " << time << " [ µs ] = " << (0.001*(double)time) << " [ ms ]\n";
}
 
inline
void time_info(const std::string& msg, const unsigned long& time, std::ostream& out){
  out << msg << time << " [ µs ] = " << (0.001*(double)time) << " [ ms ]\n";
}
class mt_out : public std::stringstream
{
  std::ostream &out;
 
public:
  static inline std::mutex out_mutex;
  mt_out(std::ostream &r = std::cout) : out(r)
  {
  }
  ~mt_out()
  {
    std::lock_guard<std::mutex> mt{out_mutex};
    out << rdbuf();
    out.flush();
  }
};
 
template<class T>
class ptr_vector_guard{
  std::vector<T> v;
public:
  ptr_vector_guard()=delete;
  ptr_vector_guard(const ptr_vector_guard&)=delete;
  ptr_vector_guard& operator=(const ptr_vector_guard&)=delete;
 
  ptr_vector_guard(std::vector<T>&& a):v{ std::move(a) }{}
  
  ptr_vector_guard(ptr_vector_guard<T>&& other):v{ std::move(other.v) }{}
  ptr_vector_guard& operator=(ptr_vector_guard<T>&& other) noexcept {
    for( auto&& r : v ) 
      delete r;
    v = std::move(other.v);
    return *this;
  }  
 
  ~ptr_vector_guard(){ for( auto&& r : v ) delete r; }
  std::vector<T> & vec() { return v;}
  std::vector<T> const& vec()const { return v;}
};
 
//---------------------------------------------
#endif