TimerThread.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
//
//  TimerThread.h
//
//  Timer for scheduling future events
//
//  Copyright (c) 2017 h3ctrl <h3ctrl@gmail.com>
//
//  SOFTWARE NOTICE AND LICENSE
//
//  This file is part of OpenZWave.
//
//  OpenZWave is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published
//  by the Free Software Foundation, either version 3 of the License,
//  or (at your option) any later version.
//
//  OpenZWave is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public License
//  along with OpenZWave.  If not, see <http://www.gnu.org/licenses/>.
//
//-----------------------------------------------------------------------------
 
#ifndef _TIMERTHREAD_H_
#define _TIMERTHREAD_H_
 
#if __cplusplus >= 201103L || __APPLE__ || _MSC_VER
#include <functional>
using std::bind;
using std::function;
#else
#include <tr1/functional>
using std::tr1::bind;
using std::tr1::function;
#endif
 
#include "Defs.h"
#include "platform/Event.h"
#include "platform/Mutex.h"
#include "platform/TimeStamp.h"
 
namespace OpenZWave
{
    class Driver;
    class Thread;
    class Timer;

    class OPENZWAVE_EXPORT TimerThread
    {
        friend class Timer;
    //-----------------------------------------------------------------------------
    //  Timer based actions
    //-----------------------------------------------------------------------------
    public:
        typedef function<void(uint32)> TimerCallback;

        TimerThread( Driver *_driver );

        ~TimerThread();
 
        struct TimerEventEntry
        {
            Timer *instance;
            TimeStamp timestamp;
            TimerCallback callback;
            uint32 id;
        };

        static void TimerThreadEntryPoint( Event* _exitEvent, void* _context );
 
    private:
        //Driver*   m_driver;

        TimerEventEntry* TimerSetEvent( int32 _milliseconds, TimerCallback _callback, Timer *_instance, uint32 id );

        void TimerDelEvent(TimerEventEntry *);

        void TimerThreadProc( Event* _exitEvent );
 

        list<TimerEventEntry *> m_timerEventList;
 
        Event*             m_timerEvent;   // Event to signal new timed action requested
        Mutex*             m_timerMutex;   // Serialize access to class members
        int32                  m_timerTimeout; // Time in milliseconds to wait until next event
    };

 
    class OPENZWAVE_EXPORT Timer
    {
    public:
        Timer( Driver *_driver );
 
        Timer();
        ~Timer();
        TimerThread::TimerEventEntry* TimerSetEvent( int32 _milliseconds, TimerThread::TimerCallback _callback, uint32 id );
        void TimerDelEvents();
        void TimerDelEvent(TimerThread::TimerEventEntry *te);
        void TimerDelEvent(uint32 id);

        void SetDriver(Driver *_driver);
        void TimerFireEvent(TimerThread::TimerEventEntry *te);
    private:
        Driver*   m_driver;
        list<TimerThread::TimerEventEntry *> m_timerEventList;
 
 
    };
} // namespace OpenZWave
 
#endif // _TIMERTHREAD_H_