utils.hpp

Go to the documentation of this file.

//====================================================
//     File data
//====================================================
//====================================================
//     Preprocessor settings
//====================================================
#pragma once
#ifndef ARSENALGEAR_UTILS_HPP
#define ARSENALGEAR_UTILS_HPP
 
//====================================================
//     Headers
//====================================================
 
// STD headers
#include <stdexcept>
#include <type_traits>
#include <vector>
#include <string>
#include <codecvt>
#include <locale>
#include <sstream>
#include <stdlib.h>
#include <string_view>
#include <cmath>
 
namespace agr
 {
  //====================================================
  //     Enum classes
  //====================================================
  enum class ANSI { first, generic };
 
  //====================================================
  //     Functions declaration
  //====================================================
  extern std::string multi( const std::string& element, unsigned int n_times );
  extern std::vector <std::string> split_string( const std::string& input, const std::string& regex );
  
  //====================================================
  //     Functions definition
  //====================================================
 
  // except_error_func
  template <typename T_err = std::runtime_error>
  inline T_err except_error_func( const std::string& beg = "", std::string var = nullptr, const std::string& end = "" )
   {
    using namespace std::literals::string_literals;
 
    static std::ostringstream oss;
    oss.str( "" );
    oss.clear();
    oss << "\033[31m" << beg << " \""s << "\033[1m" << var << "\033[22m" << "\" "s << end << "\033[39m";
 
    return T_err( oss.str() ); 
   }
 
  // isFloatingPoint
  template <typename T>
  inline bool isFloatingPoint( const T& )
   {
    return std::is_floating_point <T>::value;
   }
 
  // one
  template <typename T>
  inline T one( const T& iterating_var )
   {
    std::vector<T> counter_;
 
    if( isFloatingPoint( iterating_var ) )
     {
      if( counter_.size() < 2 ) counter_.push_back( iterating_var );
      if( counter_.size() == 2 ) return abs( abs( counter_.front() ) - abs( counter_.back() ) );
      return static_cast <T> ( 0 );
     }
 
    counter_.clear();
    return 1;
   }
 
  // StringConverter
  template <class CharT>
  std::conditional_t<std::is_same_v<CharT, char>, const std::basic_string<CharT>&, std::basic_string<CharT>>
  StringConverter( const std::string& input_str )
   {
    if constexpr( std::is_same_v <CharT, char> ) 
     {
      return input_str;
     }
    else if constexpr( std::is_same_v <CharT, wchar_t> )
     {
      static std::wstring_convert <std::codecvt_utf8_utf16 <wchar_t>> converter_wchar_t;
      return converter_wchar_t.from_bytes( input_str );
     }
    #ifndef __APPLE__
    #if ( __cplusplus >= 202002L )
    else if constexpr( std::is_same_v <CharT, char8_t> )
     {
      return reinterpret_cast <const char8_t*>( input_str.c_str() );
     }
    #endif
    else if constexpr( std::is_same_v <CharT, char16_t> )
     {
      static std::wstring_convert <std::codecvt_utf8_utf16 <char16_t>, char16_t> converter_16_t;
      return converter_16_t.from_bytes( input_str );
     } 
    else if constexpr( std::is_same_v <CharT, char32_t> )
     {
      static std::wstring_convert <std::codecvt_utf8_utf16 <char32_t>, char32_t> converter_32_t;
      return converter_32_t.from_bytes( input_str );
     }
    #endif
    else 
     {
      return StringConverter<CharT>( "" );
     }
   }
 
  // is_escape
  template <typename T>
  bool is_escape( const T& str, const ANSI& flag )
   {
    if constexpr( std::is_convertible_v <T, std::string_view> && ! std::is_same_v<T, std::nullptr_t> )
     {
      switch( flag )
       {
        case( ANSI::first ): 
         {
          return ( std::string_view( str ).length() < 7 ) && ( str[0] == '\033' );
         }
        case( ANSI::generic ):
         {
          return ( std::string_view( str ).find( '\033' ) != std::string_view::npos );
         }
       }
     }
    return false;
   }
 }
 
#endif