SickThread.hpp

Go to the documentation of this file.

#include "sick_scan/sick_scan_base.h" /* Base definitions included in all header files, added by add_sick_scan_base_header.py. Do not edit this line. */
//
// SickThread.hpp
//
#ifndef SICKTHREAD_HPP
#define SICKTHREAD_HPP
 
#include <thread>
#include "sick_scan/tcp/BasicDatatypes.hpp"
#include "sick_scan/sick_ros_wrapper.h"
//#include <pthread.h>
#ifdef _MSC_VER
//#include <unistd_win.h>
#include <usleep.h>
#else
#include <unistd.h>
#endif
 
extern "C" void* wrapper_prerun(void*);
class ThreadWrapperBase
{
    //pthread_t t_id;
    std::thread* t_id = 0;
    friend void* wrapper_prerun(void*);
    virtual void thread_entry() = 0;
  protected:
    void* pthis;
        std::string m_thread_name;
  public:
        
        ThreadWrapperBase(const std::string& thread_name = "") : m_thread_name(thread_name) {pthis = NULL;};
        virtual ~ThreadWrapperBase() { delete t_id; };
          
    void run(void* classptr)
        {
                if (pthis == NULL)
                {
                        pthis = classptr;
                        // pthread_create(&t_id, NULL, wrapper_prerun, this);
                        t_id = new std::thread(&wrapper_prerun, this); 
                }
    }
    
    bool isRunning()
        {
                if (pthis == NULL)
                {
                        return false;
                }
                
                return true;
        }
        
    void join()
        {
                // pthread_join(t_id, NULL);
                if(t_id && t_id->joinable())
                    t_id->join();
                pthis = NULL;
    }
    
    // pthread_t* get_thread_id() { return &t_id; }
    std::thread* get_thread_id() { return t_id; }
 
};
 
 
 
template <typename T, void (T::*M)(bool&, UINT16&)>
class SickThread : public ThreadWrapperBase
{
        void thread_entry()
        {
                T* pt = static_cast<T*>(pthis);
 
                m_threadShouldRun = true;
                bool endThread = false;
                UINT16 sleepTimeMs = 0;
                ROS_INFO_STREAM("SickThread " << m_thread_name << " started.");
                
                while ((m_threadShouldRun == true) && (endThread == false))
                {
                        usleep(((UINT32)sleepTimeMs) * 1000);
                        (pt->*M)(endThread, sleepTimeMs);
                }
 
                ROS_INFO_STREAM("SickThread " << m_thread_name << " finished (flags: threadShouldRun=" << m_threadShouldRun << ", endThread=" << endThread << ").");
        }
        
                
public:
        void join()
        {
                m_threadShouldRun = false;
                ThreadWrapperBase::join();
        }
        
        SickThread(const std::string& thread_name = "") : ThreadWrapperBase(thread_name) {m_threadShouldRun = true;}
        virtual ~SickThread(){};
        bool m_threadShouldRun;
};
 
/*
template <typename T, void (T::*M)()>
class SickThread : public ThreadWrapperBase
{
        void thread_entry()
        {
                T* pt = static_cast<T*>(pthis);
                
                
                (pt->*M)();
        }
public:
        SickThread(){}
        virtual ~SickThread(){};
};
*/
 
 
 
// class SickThread
// {
// public:
//      /**
//       * The thread callback function.
//       *
//       * \param endThisThread A bool flag that may be set by the callback function
//       *  to "false" in case the thread function decides this thread
//       *  needs to end.
//       *
//       * \param sleepTimeMs The sleep time, in ms, that will be spent between
//       *  subsequent calls to the callback function. Default is 10 ms, but
//       *  other times may be set. Note that not all operating systems may be
//       *  able to schedule very short sleep times.
//       */
// //   int (*comp)(const void *, const void *)
//      typedef void (*ThreadFunction) (bool& endThisThread, UINT16& sleepTimeMs);
// 
//      /**
//       * The thread callback function (simpler version).
//       *
//       * \return True if the thread should continue to run and
//       * continuously call this function (after potentially some waiting
//       * time). False if this thread should end now.
//       */
// //   typedef std::function < bool (void) > ThreadFunctionSimple;
// 
//      /// Default constructor.
//      SickThread();
// 
//      /// Destructor. Will call stop() if thread is not yet stopped, and
//      /// wait for its completion before destructing this object.
//      ~SickThread();
// 
//      /// Start the thread.
//      bool start();
// 
//      /// Start the thread and also set the thread function. \sa start()
//      bool start(ThreadFunction function);
// 
//      /// Returns true if this thread was started and is running.
//      bool isRunning() const;
// 
//      /// Stops this thread and waits for its completion.
//      void stop();
// 
//      /// Set whether we want verbose debug output
//      void setVerboseDebugOutput(bool enableVerboseDebugOutput);
// 
//      /// Set the thread's "run" function
//      void setFunction(ThreadFunction threadFunction);
// 
//      /// Set the thread's "run" function, simpler version
// //   void setFunctionSimple(ThreadFunctionSimple threadFunctionSimple);
// 
//      /// Set the sleep time between subsequent ThreadFunctionSimple calls in [milliseconds]
//      void setSleepTimeMilliseconds(unsigned v);
// 
//      /// Returns the sleep time between subsequent ThreadFunctionSimple
//      /// calls in [milliseconds]. (Default value is zero.)
//      unsigned getSleepTimeMilliseconds() const { return m_sleepTimeMilliseconds; }
// 
// private:
//      static void* thread(void* ptr);                 // The thread function
//      void thread2();                                                 // The member thread function
// 
// //   typedef std::mutex Mutex;
// 
//      pthread_mutex_t m_mutex;        //  = PTHREAD_MUTEX_INITIALIZER;
// //   mutable Mutex m_threadMutex;
// //   boost::condition m_threadCondition;
//      ThreadFunction m_function;
// //   ThreadFunctionSimple m_functionSimple;
// 
// //   boost::scoped_ptr<std::thread> m_threadPtr;
//      bool m_threadShouldRun;
//      bool m_threadIsRunning;
//      bool m_beVerbose;
//      unsigned m_sleepTimeMilliseconds;
//      
//      // The thread
//      pthread_t m_thread;
// 
// };
 
/*
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
#define NUM_THREADS     5
 
void *TaskCode(void *argument)
{
   int tid;
 
   tid = *((int *) argument);
   printf("Hello World! It's me, thread %d!\n", tid);
 
   // optionally: insert more useful stuff here
 
   return NULL;
}
 
int main(void)
{
   pthread_t threads[NUM_THREADS];
   int thread_args[NUM_THREADS];
   int rc, i;
 
   // create all threads
   for (i=0; i<NUM_THREADS; ++i) {
      thread_args[i] = i;
      printf("In main: creating thread %d\n", i);
      rc = pthread_create(&threads[i], NULL, TaskCode, (void *) &thread_args[i]);
      assert(0 == rc);
   }
 
   // wait for all threads to complete
   for (i=0; i<NUM_THREADS; ++i) {
      rc = pthread_join(threads[i], NULL);
      assert(0 == rc);
   }
 
   exit(EXIT_SUCCESS);
}
*/
 
#endif // SICKTHREAD_HPP