🧠 C++ Задача для продвинутых: безопасный счётчик с автоматическим сбросом

Условие:
Реализуйте потокобезопасный счётчик, который:
1. Увеличивается при вызове increment()
2. Возвращает текущее значение при get()
3. Автоматически сбрасывается в 0 через N миллисекунд после последнего increment()
4. Не сбрасывается, если за это время пришёл новый increment()

🔧 Условия:
- Нельзя использовать сторонние библиотеки (только стандарт C++17+)
- Нельзя вручную управлять потоками (используйте std::thread, std::mutex, `std::condition_variable`)
- Нужно обеспечить корректный RAII (автоматическое завершение потоков при разрушении объекта)

🔍 Пример:

SafeCounter counter(1000); // сброс через 1000 мс
counter.increment();       // value = 1
std::this_thread::sleep_for(500ms);
counter.increment();       // value = 2, таймер сброса перезапускается
std::this_thread::sleep_for(1500ms);
std::cout << counter.get(); // value = 0

💡 Подсказка:
Нужно реализовать "отложенный сброс", который перезапускается при каждом increment(). Используйте фоновый поток и condition_variable.

✅ Ожидаемое решение (упрощённый скелет):

#include <iostream>
#include <thread>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <chrono>

class SafeCounter {
public:
    SafeCounter(int timeout_ms) : timeout(timeout_ms), value(0), stop(false) {
        worker = std::thread([this] { this->watch(); });
    }

    ~SafeCounter() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            stop = true;
        }
        cv.notify_all();
        worker.join();
    }

    void increment() {
        {
            std::lock_guard<std::mutex> lock(mtx);
            ++value;
            last_action = std::chrono::steady_clock::now();
        }
        cv.notify_all();
    }

    int get() const {
        return value.load();
    }

private:
    void watch() {
        std::unique_lock<std::mutex> lock(mtx);
        while (!stop) {
            cv.wait_for(lock, timeout, [this] {
                return stop || std::chrono::steady_clock::now() - last_action >= timeout;
            });

            if (stop) break;

            if (std::chrono::steady_clock::now() - last_action >= timeout) {
                value = 0;
            }
        }
    }

    std::chrono::milliseconds timeout;
    std::chrono::steady_clock::time_point last_action = std::chrono::steady_clock::now();
    std::atomic<int> value;
    std::mutex mtx;
    std::condition_variable cv;
    std::thread worker;
    bool stop;
};

🎯 Отличная задача, чтобы потренировать:

понимание RAII

работу с condition_variable

атомарные переменные

и правильную остановку фоновых потоков

Можешь доработать под конкретные кейсы — например, логирование событий сброса или работу с несколькими счётчиками.

🧠 Задача: Реализация `TypeList` с поддержкой операций на этапе компиляции

📌 Описание

Реализуйте шаблонный класс TypeList, который представляет собой список типов на этапе компиляции (compile-time type list). Он должен поддерживать следующие операции:

1. Получение длины списка (`length`)
2. Получение типа по индексу (`at<N>`)
3. Добавление типа в начало списка (`push_front<T>`)
4. Удаление первого типа (`pop_front`)
5. Проверка наличия типа в списке (`contains<T>`)
6. Фильтрация по условию (например, только целочисленные типы) (`filter<Predicate>`)

Всё это должно работать на этапе компиляции, без использования std::tuple или других runtime-контейнеров.

🧩 Пример использования

#include <type_traits>
#include <iostream>

// Пример предиката
template<typename T>
struct is_integral : std::is_integral<T> {};

int main() {
    using MyList = TypeList<int, char, float, double, short>;
    
    static_assert(MyList::length == 5);
    static_assert(std::is_same_v<MyList::at<0>, int>);
    static_assert(std::is_same_v<MyList::at<2>, float>);

    using WithBool = MyList::push_front<bool>;
    static_assert(WithBool::length == 6);
    static_assert(std::is_same_v<WithBool::at<0>, bool>);

    using Popped = WithBool::pop_front;
    static_assert(std::is_same_v<Popped, MyList>);

    static_assert(MyList::contains<int>);
    static_assert(!MyList::contains<bool>);

    using OnlyIntegral = MyList::filter<is_integral>;
    static_assert(std::is_same_v<OnlyIntegral, TypeList<int, char, short>>);

    return 0;
}

🛠 Требования к реализации
Используйте только возможности шаблонов и constexpr.
Не используйте std::tuple, std::array, if constexpr (если хотите усложнить — можно).
Предпочтительно использование C++17 или выше.
Код должен компилироваться и проходить все static_assert.

🧪 Бонусное задание
Реализуйте print_types() — функцию, которая выводит все типы из списка в std::cout (можно использовать typeid, PRETTY_FUNCTION или другие хаки).

@cpluspluc