Obfuscated-Keylogger/Timer.h at main · NicolasMuras/Obfuscated-Keylogger · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
#ifndef TIMER_H
#define TIMER_H

#include <thread>
#include <chrono>
#include <functional>

class Timer
{
    std::thread Thread;
    bool Alive = false;
    long CallNumber = -1L;
    long repeat_count = -1L;
    std::chrono::milliseconds interval = std::chrono::milliseconds(0);
    std::function<void(void)> funct = nullptr;

    void SleepAndRun()
    {
        std::this_thread::sleep_for(interval);
        if(Alive)
            Function()();
    }

    void ThreadFunc()
    {
        if(CallNumber == Infinite)
            while(Alive)
                SleepAndRun();
        else
            while(repeat_count--)
                SleepAndRun();
    }

    public:
        static const long Infinite = -1L;

        Timer(){}

        Timer(const std::function<void(void)> &f) : funct (f) {}

        Timer(const std::function<void(void)> &f, const unsigned long &i, const long repeat = Timer::Infinite) : funct(f), interval(std::chrono::milliseconds(i)), CallNumber(repeat) {}

        void Start(bool Async = true)
        {
            if(IsAlive())
                return;
            Alive = true;
            repeat_count = CallNumber;
            if(Async)
                Thread = std::thread(ThreadFunc, this);
            else
                this->ThreadFunc();
        }

        void Stop()
        {
            Alive = false;
            Thread.join();
        }

        void SetFunction(const std::function<void(void)> &f)
        {
            funct = f;
        }

        bool IsAlive() const
        {
            return Alive;
        }

        void RepeatCount(const long r)
        {
            if(Alive)
                return;
            CallNumber = r;
        }

        long GetLeftCount() const
        {
            return repeat_count;
        }

        long RepeatCount() const
        {
            return CallNumber;
        }

        void SetInterval(const unsigned long &i)
        {
            if(Alive)
                return;
            interval = std::chrono::milliseconds(i);
        }

        // Convert from 'chrono::milliseconds' type to 'unsigned long'.
        unsigned long Interval() const
        {
            return interval.count();
        }

        const std::function<void(void)> &Function() const
        {
            return funct;
        }
};

#endif // TIMER_H