// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*

    This is an example illustrating the use of the threaded_object 
    from the dlib C++ Library.


    This is a very simple example.  It creates a single thread that
    just prints messages to the screen.
*/


#include <iostream>
#include <dlib/threads.h>
#include <dlib/misc_api.h>  // for dlib::sleep

using namespace std;
using namespace dlib;

class my_object : public threaded_object
{
public:
    my_object()
    {
        // Start our thread going in the thread() function
        start();
    }

    ~my_object()
    {
        // Tell the thread() function to stop.  This will cause should_stop() to 
        // return true so the thread knows what to do.
        stop();

        // Wait for the thread to stop before letting this object destruct itself.
        // Also note, you are *required* to wait for the thread to end before 
        // letting this object destruct itself.
        wait();
    }

private:

    void thread()
    {
        // This is our thread.  It will loop until it is told that it should terminate.
        while (should_stop() == false)
        {
            cout << "hurray threads!" << endl;
            dlib::sleep(500);
        }
    }
};

int main()
{
    // Create an instance of our threaded object.   
    my_object t;

    dlib::sleep(4000);
    
    // Tell the threaded object to pause its thread.  This causes the
    // thread to block on its next call to should_stop().
    t.pause();

    dlib::sleep(3000);
    cout << "starting thread back up from paused state" << endl;

    // Tell the thread to unpause itself.  This causes should_stop() to unblock 
    // and to let the thread continue.
    t.start();

    dlib::sleep(4000);

    // Let the program end.  When t is destructed it will gracefully terminate your
    // thread because we have set the destructor up to do so.
}