notepad_commandqueue.h

Go to the documentation of this file.

#ifndef NOTEPAD_COMMANDQUEUE_H__
#define NOTEPAD_COMMANDQUEUE_H__

/**
 * File Name  : notepad_commandqueue.h
 *
 * Description: command queue class for notepad prerender thread. 
 *              and helper classes mutex, scopemutex, counting semaphore.
 */

/*
 * 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 <list>
#include <glib.h>
#include <string>
#include <vector>
#include <set>


namespace notepad
{


    // helper classes
    class Mutex
    {
        public:
            Mutex()
            {
                if (!g_thread_supported ()) g_thread_init (NULL);
                mutex_ = g_mutex_new(); 
            }
            ~Mutex() { g_mutex_free(mutex_); }

            void lock() { g_mutex_lock(mutex_); }
            void unlock() { g_mutex_unlock(mutex_); }
            GMutex* get_gmutex() { return mutex_; }
        private:
            GMutex *mutex_;
    };

    class MutexLocker
    {
        public:
            MutexLocker(Mutex *m) : mutex_(m) { mutex_->lock(); }
            ~MutexLocker() { mutex_->unlock(); }
        private:
            Mutex* mutex_;
    };


    class CSemaphore
    {
        public:
            CSemaphore():s(0) { m = g_mutex_new(); c = g_cond_new(); };
            CSemaphore(gint v):s(v) { m = g_mutex_new(); c = g_cond_new(); };
            ~CSemaphore() { g_mutex_free(m); m=0; g_cond_free(c); c=0; };

            void p()
            {
                while ( s == 0 ) 
                {
                    g_cond_wait(c, m);
                }
                --s;
            }

            void v()
            {
                ++s;
                g_cond_signal(c);
            }


            bool try_p() 
            { 
                bool ret = false;
                GTimeVal tv = {0,1};
                while ( s == 0 ) 
                {
                    ret = g_cond_timed_wait(c, m, &tv);
                }
                --s;
                return ret;
            }

            void set(unsigned int n)
            {
                s = n;
                g_cond_signal(c);
            }

        private: 
            int s;
            GCond* c;
            GMutex* m;
    };


    class Command
    {
        public:
            Command() {}
            virtual ~Command() {}
            virtual bool execute() = 0; // must be implemented by derived command
    };



    // The command queue
    class CmdQueue
    {
        public:
            CmdQueue();
            ~CmdQueue();

            bool start();
            void stop();
            void add(Command* new_command);
            void flush();

        private:
            static gpointer thread_func(gpointer args);
            gpointer non_static_thread_func();
            void empty_queue();

        private:
            typedef std::list<Command*>    CommandQueue;
            typedef CommandQueue::iterator CommandQueueIter;
        private:
            GThread*         thread;
            CommandQueue     the_queue;
            Command*         current_command;
            CSemaphore       sem;
            bool             stop_flag;
            bool             flush_flag;

            // Mutexes and conditions
            Mutex            queue_mutex;
    };

};



#endif // NOTEPAD_COMMANDQUEUE_H__