thread.cpp

Go to the documentation of this file.

/*****************************************************************************
** Platform Check
*****************************************************************************/

#include <ecl/config.hpp>

/*****************************************************************************
** Includes
*****************************************************************************/

#include <iostream>
#include "../../include/ecl/threads/thread.hpp"
#include "../../../ecl_time/include/ecl/time/sleep.hpp"

class ThreadMemberFunctions {
public:
        void f() {
                std::cout << "A::f()" << std::endl;
        }
        void g(const int &i) {
                std::cout << "A::g(" << i << ")" << std::endl;
        }
};

class NullaryFunction {
public:
        NullaryFunction() : i(0) {};
        typedef void result_type;
        void operator()() {
                for (int j = 0; j < 3; ++j ) {
                        std::cout << "  Nullary Function Object: " << i << std::endl;
                        ecl::Sleep sleep;
                        sleep(1);
                        ++i;
                }
                std::cout << "  Nullary Function Object: finished." << std::endl;
        }
        int i;
};

void d() {
        for (int i = 0; i < 5; ++i ) {
                ecl::Sleep sleep;
                sleep(1);
                std::cout << "  d(): " << i << std::endl;
        }
        std::cout << "  d(): finished" << std::endl;
}
void d_cb() {
        std::cout << "  d(): callback function" << std::endl;
}

void f() {
        for (int i = 0; i < 3; ++i) {
                std::cout << "f(): " << i << std::endl;
        }
}

void g(const int &i) {
        for (int j = 0; j < 3; ++j) {
                std::cout << "g(" << i << ")" << std::endl;
        }
}

void deconstructThread() {
        ecl::Thread thread_deconstruct(d);
}

int main() {

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "                   Thread Function Type" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

    ThreadMemberFunctions a;
    ecl::Thread thread_f1(f);
    ecl::Thread thread_f2(&ThreadMemberFunctions::f, a);
    ecl::Thread thread_f3(ecl::generateFunctionObject(f));
    ecl::Thread thread_f4(ecl::generateFunctionObject(g,1));
    ecl::Thread thread_f5(ecl::generateFunctionObject(&ThreadMemberFunctions::f,a));
    ecl::Thread thread_f6(ecl::generateFunctionObject(&ThreadMemberFunctions::g,a,2));

    thread_f1.join();
    thread_f2.join();
    thread_f3.join();
    thread_f4.join();
    thread_f5.join();
    thread_f6.join();

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "               Cancel" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

        ecl::Thread thread(ecl::generateFunctionObject(d));
        ecl::Sleep sleep;
        sleep(3);
        if (!thread.isRunning()) {
                std::cout << "Abnormal #1" << std::endl;
        }
        thread.cancel();
        if (thread.isRunning()) {
                std::cout << "Abnormal #2" << std::endl;
        }
    thread.join();
        if (thread.isRunning()) {
                std::cout << "Abnormal #3" << std::endl;
        }

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "               Deconstruct" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

    deconstructThread();
    sleep(6);

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "               Nullary Function Objects" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

    NullaryFunction function_object_1;
    ecl::Thread thread_f8(function_object_1);
    sleep(4);
    ecl::Thread thread_f9(ecl::ref(function_object_1));
        sleep(4);
    thread_f8.join();
    thread_f9.join();

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "               Delayed Start" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

        NullaryFunction function_object_2;
        ThreadMemberFunctions b;
        ecl::Thread thread1, thread2, thread3, thread4;
        thread1.start(f);
        thread2.start(function_object_2);
        thread3.start(&ThreadMemberFunctions::f,b);
        thread4.start(ecl::generateFunctionObject(&ThreadMemberFunctions::g,b,2));

        thread1.join();
        thread2.join();
        thread3.join();
        thread4.join();

    std::cout << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << "                      Passed" << std::endl;
    std::cout << "***********************************************************" << std::endl;
    std::cout << std::endl;

    return 0;
}