OperatorKernel.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_OPERATORKERNEL_H
#define STROMX_RUNTIME_OPERATORKERNEL_H

#include <map>
#include <set>
#include "stromx/runtime/DataRef.h"
#include "stromx/runtime/Exception.h"
#include "stromx/runtime/OperatorInfo.h"

namespace stromx
{
    namespace runtime
    {
        class DataContainer;
        class DataProvider;
        
        namespace impl
        {
            class SynchronizedOperatorKernel;
        }
        
        class STROMX_RUNTIME_API OperatorKernel : public OperatorInfo
        {
            friend class impl::SynchronizedOperatorKernel;
            friend class OperatorKernelTest;
            
        public:
            virtual ~OperatorKernel();
            
            virtual OperatorKernel* clone() const = 0;
            
            const std::string& type() const { return m_type; }
            
            const std::string& package() const { return m_package; }
            
            const Version& version() const { return m_version; }

            const std::vector<const Description*>& inputs() const { return m_inputs; }
            
            const std::vector<const Description*>& outputs() const { return m_outputs; }
            
            const std::vector<const Parameter*>& parameters() const { return m_parameters; }
            
            const Parameter & parameter(const unsigned int id) const;
            
            virtual const Description & input(const unsigned int id) const;
            
            virtual const Description & output(const unsigned int id) const;
            
            const OperatorProperties & properties() const;
            
            virtual void setParameter(const unsigned int, const Data&) { throw NotImplemented(); };
            
            virtual const DataRef getParameter(const unsigned int) const { throw NotImplemented(); };
            
            virtual void execute(DataProvider& provider) = 0;
            
            virtual void initialize() {}
            
            virtual void deinitialize();

            virtual void activate() {}

            virtual void deactivate() {}

            virtual void interrupt() {}
            
            
        protected:
            OperatorKernel(const std::string & type,
                    const std::string & package,
                    const Version & version,
                    const std::vector<const Parameter*>& parameters,
                    const OperatorProperties & properties = OperatorProperties());
                
            OperatorKernel(const std::string & type,
                    const std::string & package,
                    const Version & version,
                    const std::vector<const Description*>& inputs,
                    const std::vector<const Description*>& outputs,
                    const std::vector<const Parameter*>& parameters,
                    const OperatorProperties & properties = OperatorProperties());

            OperatorKernel(const std::string& type,
                    const std::string& package,
                    const runtime::Version& version,
                    const std::vector<const Description* >& inputs,
                    const std::vector<const Description* >& outputs,
                    const OperatorProperties & properties = OperatorProperties());
             
            OperatorKernel(const std::string & type,
                    const std::string & package,
                    const Version & version,
                    const OperatorProperties & properties = OperatorProperties());
            
            virtual void initialize(const std::vector<const Description*>& inputs,
                                    const std::vector<const Description*>& outputs,
                                    const std::vector<const Parameter*>& parameters);
            
            Parameter & parameter(const unsigned int id);
            
        private:
            void validateInputs(const std::vector<const Description*>& descriptors);
            void validateOutputs(const std::vector<const Description*>& descriptors);
            void validateParameters(const std::vector<const Parameter*>& descriptors);
            const Parameter & findParameter(const unsigned int id) const;
            
            std::string m_type;
            std::string m_package;
            Version m_version;
            std::vector<const Description*> m_inputs;
            std::vector<const Description*> m_outputs;
            std::vector<const Parameter*> m_parameters;
            
            std::map<unsigned int, const Parameter*> m_parameterMap;
            std::map<unsigned int, const Description*> m_inputMap;
            std::map<unsigned int, const Description*> m_outputMap;
            
            // the indices of all inputs, output and parameters which are
            // have been during initialization, i.e. which must be removed
            // upon deinitialization
            std::set<unsigned int> m_activeInputs;
            std::set<unsigned int> m_activeOutputs;
            std::set<unsigned int> m_activeParameters;
            
            OperatorProperties m_properties;
        };
    }
}

#endif // STROMX_RUNTIME_OPERATORKERNEL_H