Webmaster  |  Imprint 

C++ Server Pages

Main  |  License  |  Documentation  |  Download 

/home/tommi/cxxtools/include/cxxtools/thread.h

/*
 * Copyright (C) 2006-2008 Marc Boris Duerner
 * Copyright (C) 2006-2008 Tommi Maekitalo
 * 
 * This library 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 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
#if !defined(PT_SYSTEM_THREAD_H)
#define PT_SYSTEM_THREAD_H

#include <cxxtools/noncopyable.h>
#include <cxxtools/callable.h>
#include <cxxtools/function.h>
#include <cxxtools/method.h>

namespace cxxtools {

    class Thread : protected NonCopyable
    {
        public:
            enum State
            {
                Ready    = 0, 
                Running  = 1, 
                Finished = 2  
            };

        protected:
            Thread();

            explicit Thread(const Callable<void>& cb);

            void init(const Callable<void>& cb);

        public:
            virtual ~Thread();

            State state() const
            { return _state; }

            void start();

            void create()
            { this->start(); }

            static void exit();

            static void yield();

            static void sleep(unsigned int ms);

        protected:
            void detach();

            void join();

            bool joinNoThrow();

            void terminate();

        private:
            Thread::State _state;

            class ThreadImpl* _impl;
    };

    class AttachedThread : public Thread
    {
        public:
            explicit AttachedThread(const Callable<void>& cb)
            : Thread(cb)
            {}

            ~AttachedThread()
            {
                Thread::joinNoThrow();
            }

            void join()
            {
                Thread::join();
            }

            void terminate()
            {
                Thread::terminate();
            }
    };

    class DetachedThread : public Thread
    {
        typedef void (*FuncPtrT)();

        public:
            explicit DetachedThread(FuncPtrT fp)
            : Thread( callable(fp) )
            {
                Thread::detach();
            }

        protected:
            DetachedThread()
            : Thread()
            {
                Thread::init( callable(*this, &DetachedThread::exec) );
                Thread::detach();
            }

            virtual void destroy()
            { delete this; }

            virtual void run()
            {}

        private:
            void exec()
            {
                this->run();
                this->destroy();
            }
    };

} // !namespace cxxtools

#endif // namespace cxxtools

Copyright © 2008 The Tntnet Development Team

Tntnet 1.6