Thread.h

Go to the documentation of this file.

/**************************************************************************************************
 * Copyright (c) 2021 Calypso Networks Association https://calypsonet.org/                        *
 *                                                                                                *
 * See the NOTICE file(s) distributed with this work for additional information regarding         *
 * copyright ownership.                                                                           *
 *                                                                                                *
 * This program and the accompanying materials are made available under the terms of the Eclipse  *
 * Public License 2.0 which is available at http://www.eclipse.org/legal/epl-2.0                  *
 *                                                                                                *
 * SPDX-License-Identifier: EPL-2.0                                                               *
 **************************************************************************************************/
 
#pragma once
 
#include <chrono>
#include <future>
#include <thread>
 
namespace keyple {
namespace core {
namespace util {
namespace cpp {
 
class Thread {
public:
    class UncaughtExceptionHandler {};
 
    Thread(const std::string& name)
    : mDone(false), mAlive(false), mName(name), mInterrupted(false), mDedicatedThread(false) {}
 
    Thread() : Thread("Thread-x") {}
 
    virtual ~Thread() = default;
 
    void setName(const std::string& name)
    {
        mName = name;
    }
 
    void start()
    {
        mAlive = true;
        mDedicatedThread = true;
 
        mThread = std::async(std::launch::async, &runThread, this);
    }
 
    void run()
    {
        mAlive = true;
 
        this->execute();
 
        mAlive = false;
        mDone = true;
    }
 
    int join()
    {
        int result = -1;
 
        if (isAlive() == true) {
            mThread.wait();
        }
 
        return result;
    }
 
    bool isAlive()
    {
        /* Perform live check if dedicated thread is in use */
        if (mDedicatedThread == true) {
            mAlive = (mThread.wait_for(std::chrono::milliseconds(0)) != std::future_status::ready);
        }
 
        return mAlive;
    }
 
    static void sleep(long millis)
    {
        std::this_thread::sleep_for(std::chrono::milliseconds(millis));
    }
 
    void interrupt()
    {
        mInterrupted = true;
    }
 
    bool isInterrupted() const
    {
        return mInterrupted;
    }
 
    std::string getName()
    {
        return mName;
    }
 
    void setUncaughtExceptionHandler(std::shared_ptr<UncaughtExceptionHandler> eh)
    {
        mUncaughtExceptionHandler = eh;
    }
 
protected:
    bool mDone;
 
private:
    bool mAlive;
 
    std::string mName;
 
    bool mInterrupted;
 
    std::future<void> mThread;
 
    std::shared_ptr<UncaughtExceptionHandler> mUncaughtExceptionHandler;
 
    bool mDedicatedThread;
 
    static void runThread(void* arg)
    {
        ((Thread*)arg)->execute();
    }
 
    virtual void execute() = 0;
};
 
}
}
}
}