Simulation.h

#pragma once
 
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#define NOMINMAX
#include <windows.h>
#include "Printable.h"
#include <chrono>
#include <ctime>
#include <string>
#include <mutex>
//#include <random>
#include "date.h"
#include "TextColors.h"
#include <realtimeapiset.h>
#include <processthreadsapi.h>
 
#include <thread>
 
 
using namespace date;
 
#define OSTREAM printStream
 
#define STREAM OSTREAM
#define Print OSTREAM
 
template <typename T>
class is_streamable_cout
{
    template <typename U> // must be template to get SFINAE fall-through...
    static auto test(const U* u) -> decltype(std::cout << *u);
 
    static auto test(...)->std::false_type;
 
public:
    enum { value = !std::is_same_v<decltype(test((T*)0)), std::false_type> };
};
 
template<typename T> typename std::enable_if<std::is_floating_point<T>::value, char*>::type ftoa(T f, char * buf, int precision) {
    char * ptr = buf;
    char * p = ptr;
    char * p1;
    char c;
    long intPart;
 
#define MAX_PRECISION   (10)
    static const double rounders[MAX_PRECISION + 1] =
    {
        0.5,                // 0
        0.05,               // 1
        0.005,              // 2
        0.0005,             // 3
        0.00005,            // 4
        0.000005,           // 5
        0.0000005,          // 6
        0.00000005,         // 7
        0.000000005,        // 8
        0.0000000005,       // 9
        0.00000000005       // 10
    };
 
    // check precision bounds
    if (precision > MAX_PRECISION)
        precision = MAX_PRECISION;
 
    // sign stuff
    if (f < 0)
    {
        f = -f;
        *ptr++ = '-';
    }
 
    if (precision < 0)  // negative precision == automatic precision guess
    {
        if (f < 1.0) precision = 6;
        else if (f < 10.0) precision = 5;
        else if (f < 100.0) precision = 4;
        else if (f < 1000.0) precision = 3;
        else if (f < 10000.0) precision = 2;
        else if (f < 100000.0) precision = 1;
        else precision = 0;
    }
 
    // round value according the precision
    if (precision)
        f += rounders[precision];
 
    // integer part...
    intPart = (long)f;
    f -= intPart;
 
    if (!intPart)
        *ptr++ = '0';
    else
    {
        // save start pointer
        p = ptr;
 
        // convert (reverse order)
        while (intPart)
        {
            *p++ = '0' + intPart % 10;
            intPart /= 10;
        }
 
        // save end pos
        p1 = p;
 
        // reverse result
        while (p > ptr)
        {
            c = *--p;
            *p = *ptr;
            *ptr++ = c;
        }
 
        // restore end pos
        ptr = p1;
    }
 
    // decimal part
    if (precision)
    {
        // place decimal point
        *ptr++ = '.';
 
        // convert
        while (precision--)
        {
            f *= 10.0;
            c = (char)f;
            *ptr++ = '0' + c;
            f -= c;
        }
    }
 
    // terminating zero
    *ptr = 0;
 
    return buf;
}
 
/*template<typename Clock, typename Duration>
std::ostream& operator<<(std::ostream& stream,
    const std::chrono::time_point<Clock, Duration>& time_point) {
    const time_t time = Clock::to_time_t(time_point);
#if __GNUC__ > 4 || \
    ((__GNUC__ == 4) && __GNUC_MINOR__ > 8 && __GNUC_REVISION__ > 1)
    // Maybe the put_time will be implemented later?
    struct tm tm;
    localtime_r(&time, &tm);
    return stream << std::put_time(&tm, "%c"); // Print standard date&time
#else
#ifdef _WIN32
    char buffer[26];
    ctime_s(buffer , 26, &time);
    buffer[24] = '\0';  // Removes the newline that is added
    return stream << buffer;
#else 
    char buffer[26];
    ctime_r(&time, buffer);
    buffer[24] = '\0';  // Removes the newline that is added
    return stream << buffer;
#endif
#endif
}*/
 
#define HEX (16)
#define DEC (10)
#define OCT (8)
#define BIN (2)
 
 
class printStream{
public:
    size_t print(const Printable& x);
 
    size_t print(char data);
 
    size_t print(int32_t data, uint8_t base = DEC);
 
    size_t print(uint32_t data, uint8_t base = DEC);
 
    size_t print(double data);
 
    size_t print(std::string data);
 
    size_t print(const char* data);
 
    template <typename T> size_t println(T data) {
        size_t ret = print(data);
        ret += println();
        return ret;
    }
 
    size_t println();
 
    size_t write(char val);
 
    size_t write(uint8_t* val, size_t count);
 
    size_t write(char* val, size_t count);
 
    printStream& operator<<(const Printable& data);
 
    printStream& operator<<(std::chrono::nanoseconds data);
 
    template<typename T> std::enable_if_t<is_streamable_cout<T>::value, printStream&> operator<<(T data)
    {
        std::cout << data;
        return *this;
    }
};
 
class String : public std::string {
public:
    String();
 
    String(String& str);
 
    String(std::string str);
 
    bool startsWith(const char* txt);
 
    bool startsWith(std::string txt);
 
    int indexOf(char c) const;
 
    int indexOf(char ch, unsigned int fromIndex) const;
 
    int indexOf(const char* s2) const {
        return indexOf(String(s2));
    }
 
    int indexOf(const char* s2, unsigned int fromIndex) const {
        return indexOf(String(s2), fromIndex);
    }
 
    int indexOf(const String& s2) const;
 
    int indexOf(const String& s2, unsigned int fromIndex) const;
 
    String substring(size_t from, size_t to);
 
    String substring(size_t from);
 
    String trimStart();
 
    String trimEnd();
 
    String trim();
};
 
struct membuf : std::streambuf
{
    membuf(char* p, size_t size)
    {
        setp(p, p + size); // set start end end pointers
    }
    size_t written() { return pptr() - pbase(); } // how many bytes were really written?
};
 
int32_t random();
 
int32_t random(int32_t to);
 
int32_t random(int32_t from, int32_t to);
 
class ConsoleItem {
public:
 
};
 
#define endl "\r\n"
 
inline bool false_ret() {
    return false;
}
 
#define __get_PRIMASK false_ret
#define __disable_irq()
#define __enable_irq()
 
extern printStream pout;
 
 
template <typename T>
class is_streamable
{
    template <typename U> // must be template to get SFINAE fall-through...
    static auto test(const U* u) -> decltype(pout << *u);
 
    static auto test(...)->std::false_type;
 
public:
    enum { value = !std::is_same_v<decltype(test((T*)0)), std::false_type> };
};