Thread.h

/* 
*  Copyright 2011 Matthias Fuchs
*
*  Licensed under the Apache License, Version 2.0 (the "License");
*  you may not use this file except in compliance with the License.
*  You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
*  Unless required by applicable law or agreed to in writing, software
*  distributed under the License is distributed on an "AS IS" BASIS,
*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*  See the License for the specific language governing permissions and
*  limitations under the License.
*/

#ifndef STROMX_RUNTIME_THREAD_H
#define STROMX_RUNTIME_THREAD_H

#include <string>
#include <vector>
#include "stromx/runtime/Color.h"
#include "stromx/runtime/Config.h"
#include "stromx/runtime/Input.h"

namespace stromx
{
    namespace python
    {
        class ThreadUtilities;
    }
    
    namespace runtime
    {
        class Operator;
        
        namespace impl
        {
            class Network;
            class ThreadImpl;
            class ThreadImplObserver;
        }
        
        class STROMX_RUNTIME_API Thread
        {    
            friend class Stream;
            friend class ThreadTest;
            friend class stromx::python::ThreadUtilities;
            
        public:
            enum Status
            {
                INACTIVE,
                ACTIVE,
                DEACTIVATING,
                PAUSED
            };
            
            virtual ~Thread();
            
            Status status() const;
            
            const std::string & name() const;
            
            void setName(const std::string& name);
            
            const Color & color() const;
            
            void setColor(const Color & color);
            
            const std::vector<Input> & inputSequence() const;
            
            void addInput(Operator* const op, const unsigned int inputId);
            
            void insertInput(const unsigned int position, Operator* const op, const unsigned int inputId);
            
            void removeInput(const unsigned int position);
            
            void removeInput(Operator* const op, const unsigned int inputId);
                
        private:
            explicit Thread(const impl::Network* const network);
            unsigned int findInput(Operator* const op, const unsigned int inputId);
            
            void start();
            void stop();
            void join();
            void pause();
            void resume();
            
            void setDelay(const unsigned int delay);
            
            void removeOperator(const Operator* op);
            
            void setObserver(const impl::ThreadImplObserver* const observer);
            
            void setInterruptedFlag(const bool value) { m_interruptedFlag = value; }
            bool interruptedFlag() const { return m_interruptedFlag; }
            
            impl::ThreadImpl* m_thread;
            std::string m_name;
            const impl::Network* m_network;
            std::vector<Input> m_inputSequence;
            Color m_color;
            bool m_interruptedFlag;
        };
    }
}

#endif // STROMX_RUNTIME_THREAD_H