ctimer.cpp

简单的linux下的timer类

#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
#include<signal.h>
#include<pthread.h>
#include<time.h>
#include<sys/time.h>

#include "ctimer.h"

int Timer::_iFlag = 0;
TIMER_S *Timer::_pTimeListHead = 0;

Timer::Timer()
{
    _pTimerNodeAddr = NULL;
}

Timer::~Timer()
{
    Clear();
}

int Timer::SetTimer(int iSec, pfTimerCallFunc pfFunc)
{
    TIMER_S *pTemp = new(TIMER_S);
    
    int iRet = 0;
    struct itimerval itv, oldtv;
    
    if (NULL == pTemp || iSec < 1 )
    {
        return -1;
    }

    _pTimerNodeAddr = pTemp;
    
    pTemp->left_time = -1;
    pTemp->total_time = iSec;
    pTemp->pfFunc = pfFunc;    

    HandlNode(pTemp, 1);
    
    if (0 == SetFlag())
    {
        signal(SIGALRM,Catch_Alarm);

        itv.it_interval.tv_sec = 1;
        itv.it_interval.tv_usec = 0;
        itv.it_value.tv_sec = 1;
        itv.it_value.tv_usec = 0;

        setitimer(ITIMER_REAL, &itv, &oldtv);
    }
}

void Timer::Start()
{
    if( NULL != _pTimerNodeAddr)
    {
        _pTimerNodeAddr->left_time = _pTimerNodeAddr->total_time;
    }
}

void Timer::ReStart()
{
    if( NULL != _pTimerNodeAddr)
    {
        _pTimerNodeAddr->left_time = _pTimerNodeAddr->total_time;
    }
}

void Timer::Stop()
{
    if( NULL != _pTimerNodeAddr)
    {
        _pTimerNodeAddr->left_time = -1;
    }
}

void Timer::Clear()
{
    HandlNode(_pTimerNodeAddr, 0);
    return;
}

void Timer::HandlNode(TIMER_S *Node, int iFlag)
{
    TIMER_S *pTemp = NULL;
    TIMER_S *pTempPre = NULL;

    switch(iFlag)
    {
        case 0: /* del node */
        {
            if (NULL == Node || NULL == _pTimeListHead)
            {
                return;
            }
            if( _pTimeListHead == Node)
            {
                _pTimeListHead = Node->pNextNode;
                delete Node;
                Node = NULL;
                return;
            }

            pTemp = _pTimeListHead->pNextNode;
            pTempPre = _pTimeListHead;
            
            while( NULL != pTemp)
            {
                if (pTemp == Node)
                {
                    pTempPre->pNextNode = Node->pNextNode;
                    delete Node;
                    Node = NULL;
                    break;
                }

                pTemp = pTemp->pNextNode;
                pTempPre = pTempPre->pNextNode;
            }
            break;
        }
        
        case 1: /* add node */       
        {
            if( NULL == _pTimeListHead)
            {
                _pTimeListHead = Node;
            }
            else
            {
                Node->pNextNode = _pTimeListHead->pNextNode;
                _pTimeListHead->pNextNode = Node;
            }
            break;
        }
        
        default:
        {
            break;
        }
    }
    return;
    
}

void Timer::Catch_Alarm(int iSig)
{
    
    TIMER_S *pTemp = _pTimeListHead;
        
    while(NULL != pTemp)
    {   
        
        if(pTemp->left_time > 0 )
        {
            pTemp->left_time--;
        }
        else
        {    
            if((0 == pTemp->left_time) && ( NULL != pTemp->pfFunc))
            {
                pTemp->pfFunc(iSig);
                pTemp->left_time=pTemp->total_time;     //循环计时
            }
        }

        pTemp = pTemp->pNextNode;
    }
    return;
    
}

int Timer::SetFlag()
{
    if(0 == _iFlag)
    {
        _iFlag = 1;
        return 0;
    }
    else
    {
        return 1;
    }
}