notepad_commandqueue.cpp

Go to the documentation of this file.

/*
 * File Name: notepad_commandqueue.cpp
 */

/*
 * This file is part of notepad.
 *
 * notepad is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * notepad 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * Copyright (C) 2010 IREX Technologies B.V.
 * All rights reserved.
 */

#include "notepad_commandqueue.h"
#include "log.h"


namespace notepad
{

    
CmdQueue::CmdQueue()
    : thread(0)
    , current_command(0)
    , stop_flag(false)
    , flush_flag(false)
{
}

CmdQueue::~CmdQueue()
{
    empty_queue();
}

gpointer CmdQueue::thread_func(gpointer args) // gtk c to c++ wrap
{
    g_assert(args);
    CmdQueue* thiz = reinterpret_cast<CmdQueue *>(args);
    return thiz->non_static_thread_func();
}

// Worker thread
gpointer CmdQueue::non_static_thread_func()
{
    LOGPRINTF("entry");

    while (true)
    {
        LOGPRINTF("waiting for semaphore");
        sem.p();

        if (stop_flag)
        {
            MutexLocker ml(&queue_mutex);
            LOGPRINTF("break here");
            empty_queue();
            sem.set(0);
            stop_flag = false;
            break;
        }
        if (flush_flag)
        {
            MutexLocker ml(&queue_mutex);
            LOGPRINTF("flushing queue");
            empty_queue();
            sem.set(0);
            flush_flag = false;
            continue;
        }

        current_command = the_queue.front();
        current_command->execute();
        {
            MutexLocker ml(&queue_mutex);
            the_queue.pop_front();
        }
        current_command = 0;
        g_thread_yield(); // give room for mainthread
    }

    LOGPRINTF("exit");
    return 0;
}

void CmdQueue::empty_queue() 
{
    LOGPRINTF("entry");

    CommandQueueIter idx = the_queue.begin();
    // dont flush the current command
    if (current_command != 0) idx++; // pass command currently being executed
    while (idx != the_queue.end())
    {
        delete *idx;
        idx = the_queue.erase(idx);
        idx++;
    }
    the_queue.clear();
    g_assert(the_queue.empty());
    LOGPRINTF("exit");
}

void CmdQueue::flush() // interuppts the worker thread to empty queue
{
    LOGPRINTF("entry");
    if (thread == 0)
    {
        return;
    }
    flush_flag = true;
    sem.v();

    LOGPRINTF("exit");
}

bool CmdQueue::start() // starts the worker thread
{
    LOGPRINTF("entry");
    if (thread != 0)
    {
        // The thread has been started.
        return false;
    }

    thread = g_thread_create(thread_func, this, TRUE, 0);
    LOGPRINTF("exit");
    return thread != 0;
}

void CmdQueue::stop()
{
    LOGPRINTF("entry");
    if (thread == 0)
    {
        return;
    }
    stop_flag = true;
    sem.v();

    // Wait for worker thread to die.
    g_thread_join(thread);
    LOGPRINTF("thread is stopped");

    // Set the thread to be NULL
    thread = 0;
    LOGPRINTF("exit");
}

void CmdQueue::add(Command* new_command)
{
    LOGPRINTF("entry");
    g_assert(thread); // cmd can only be added when an workerthread is active

    // if being flushed wait for flush to ready
    while (flush_flag) 
    {
        g_thread_yield(); 
    }

    // Append task to the end of the task queue.
    {
        MutexLocker ml(&queue_mutex); //guard
        the_queue.push_back(new_command);
        sem.v();
    }
    LOGPRINTF("exit");
}


} // namespace