warthreadpooltask.cpp

ftpserver very good sample

#include "StdAfx.h"
#include "WarThreadPoolTask.h"   // class implemented

#ifndef WAR_THRED_POOL_H
#   include "WarThreadPool.h" 
#endif

#ifndef WAR_THREAD_FOR_POOL_H
#   include "WarThreadForPool.h"
#endif

#ifndef WAR_AUTO_LOCK_H
#   include "WarAutoLock.h"
#endif

#ifndef WAR_LOG_H
#   include "WarLog.h"
#endif

#ifndef WAR_ASSERT_H_INCLUDED
#   include <assert.h>
#endif

using namespace std;

/////////////////////////////// PUBLIC ///////////////////////////////////////

#define AUTO_LOCK WarAutoLock MyLock(*mspLock);

int WarThreadPoolTask::msTotalTaskCnt;

//============================= LIFECYCLE ====================================

WarThreadPoolTask::WarThreadPoolTask(int Type)
: mState(STATE_NOT_SET),
mType(Type),
mpThread(NULL),
mPriority(PRI_NORMAL),
mStartTime((war_time_t)0),
mEndTime((war_time_t)0),
mTaskCookie(0)
{
    {
        AUTO_LOCK
        mTaskCookie = ++msTotalTaskCnt;
    }

#if WAR_CATCH_ALL
    try
#endif
    {
        WarLog thread_log(WARLOG_THREADS, "WarThreadPoolTask::WarThreadPoolTask()");
        thread_log << "Task " 
            << mTaskCookie 
            << " is created"
            << war_endl;
    }

#if WAR_CATCH_ALL    
    catch(...)
    {
    }
#endif
}

WarThreadPoolTask::~WarThreadPoolTask()
{
#if WAR_CATCH_ALL
    try
#endif
    {
        WarLog thread_log(WARLOG_THREADS, "WarThreadPoolTask::~WarThreadPoolTask()");
        thread_log << "Task " 
            << mTaskCookie 
            << " is destroyed"
            << war_endl;
    }

#if WAR_CATCH_ALL    
    catch(...)
    {
    }
#endif
}



//============================= OPERATIONS ===================================

void WarThreadPoolTask::SetState(RequestStateE State)
{
    switch(State)
    {
    case STATE_PROCESSING:
        if (mStartTime.IsEmpty())
            mStartTime.Reset();
        break;
    case STATE_ABORTED:
    case STATE_PROCESSED:
        if (mEndTime.IsEmpty())
            mEndTime.Reset();
        break;
    case STATE_QUEUED:
        ; // Nothing
        break;
    default:
        WarThrow(WarError(WAR_ERR_INVALID_CASE_VALUE), NULL);
    }
    mState = State;
}

//============================= ACCESS     ===================================
//============================= INQUIRY    ===================================

war_ccstr_t WarThreadPoolTask::GetStateName() const
{
    static war_ccstr_t sstate_names[] =
    {
        {"STATE_NOT_SET"},
        {"STATE_QUEUED"},
        {"STATE_PROCESSING"},
        {"STATE_PROCESSED"},
        {"STATE_ABORTED"},
    };
    
    assert(GetState() >= STATE_NOT_SET);
    assert(GetState() <= STATE_ABORTED);
    
    return sstate_names[GetState()];
}

std::string WarThreadPoolTask::GetTypeName() const
{
    string return_val;
    
    if (GetType() == REQUEST_NOOP)
        return_val = "REQUEST_NOOP";
    else
    {
        char buf[64];
        sprintf(buf, "Type=%d", GetType());
        return_val = buf;
    }
    
    return return_val;
}

war_ccstr_t WarThreadPoolTask::GetPriorityName() const
{
    static war_ccstr_t spriority_names[] =
    {
        {"PRI_HIGHEST"},
        {"PRI_HIGH"},
        {"PRI_NORMAL"},
        {"PRI_LOW"},
        {"PRI_VERY_LOW"},
    };
    
    assert(GetPriority() >= PRI_HIGHEST);
    assert(GetPriority() <= PRI_VERY_LOW);
    
    return spriority_names[GetPriority()];
}

const std::string WarThreadPoolTask::GetInfo() const
{
    return "";
}

war_uint32_t WarThreadPoolTask::GetElapsedTimeMs() const
{
    war_uint32_t return_val = 0;
    
    if (!mStartTime.IsEmpty())
    {
        WarTime EndTime = mEndTime;
        if (EndTime.IsEmpty())
            EndTime.Reset();
        return_val = (war_uint32_t)(EndTime.mTime - mStartTime.mTime);
    }
    
    return return_val;
}


/////////////////////////////// PROTECTED  ///////////////////////////////////

/////////////////////////////// PRIVATE    ///////////////////////////////////