Operator.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_OPERATOR_H
#define STROMX_RUNTIME_OPERATOR_H

#include <map>
#include <set>
#include <string>
#include "stromx/runtime/ConnectorObserver.h"
#include "stromx/runtime/DataContainer.h"
#include "stromx/runtime/DataRef.h"
#include "stromx/runtime/Exception.h"
#include "stromx/runtime/OperatorInfo.h"
#include "stromx/runtime/Position.h"

namespace stromx
{
    namespace runtime
    {
        class AbstractFactory;
        class Id2DataMapper;
        class OperatorInfo;
        class OperatorKernel;
        
        namespace impl
        {
            class InputNode;
            class Network;
            class MutexHandle;
            class OutputNode;
            class SynchronizedOperatorKernel;
        }
        
        class STROMX_RUNTIME_API Operator
        {
            friend class FactoryTest;
            friend class OperatorTest;
            friend class InputNodeTest;
            friend class NetworkTest;
            friend class OperatorTester;
            friend class OutputNodeTest;
            friend class ThreadImplTest;
            friend class SendReceiveTest;
            friend class Stream;
            friend class Thread;
            friend class impl::Network;
            
        public:
            enum Status
            {
                NONE,
                INITIALIZED,
                ACTIVE,
                EXECUTING
            };
            
            explicit Operator(OperatorKernel* const kernel);
            
            virtual ~Operator();
            
            const std::string & name() const { return m_name; }
            
            void setName(const std::string & name) { m_name = name; }
            
            const Position & position() const { return m_position; }
            
            void setPosition(const Position & position) { m_position = position; }
            
            const OperatorInfo& info() const;
            
            Status status() const;
            
            void setParameter(const unsigned int id, const Data& value);
            
            void setParameter(const unsigned int id, const Data& value, const unsigned int timeout);
            
            DataRef getParameter(const unsigned int id) const;
            
            DataRef getParameter(const unsigned int id, const unsigned int timeout) const;
            
            const DataContainer getOutputData(const unsigned int id) const;
            
            void setInputData(const unsigned int id, const DataContainer & data);
            
            void clearOutputData(const unsigned int id);
            
            void addObserver(const ConnectorObserver* const observer);
            
            void removeObserver(const ConnectorObserver* const observer);
            
            const AbstractFactory* factory() const;
            
            void setFactory(const AbstractFactory* const factory);
            
        private:
            class InternalObserver;
            
            Operator(const Operator& op);
            
            void initialize();
            void deinitialize();
            impl::InputNode* getInputNode(const unsigned int id) const;
            impl::OutputNode* getOutputNode(const unsigned int id) const;
            void activate();
            void deactivate();
            void interrupt();
            void observeInput(const unsigned int id, const DataContainer & oldData,
                              const DataContainer & newData) const;
            void observeOutput(const unsigned int id, const DataContainer & oldData,
                               const DataContainer & newData) const;
            
            std::string m_name;
            InternalObserver* m_inputObserver;
            InternalObserver* m_outputObserver;
            impl::SynchronizedOperatorKernel* m_kernel;
            std::map<unsigned int, impl::OutputNode*> m_outputs;
            std::map<unsigned int, impl::InputNode*> m_inputs;
            std::set<const ConnectorObserver*> m_observers;
            Position m_position;
            impl::MutexHandle*  m_observerMutex;
        };
    }
}

#endif // STROMX_RUNTIME_OPERATOR_H