Description.h

/* 
 *  Copyright 2015 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_DESCRIPTIONBASE_H
#define STROMX_RUNTIME_DESCRIPTIONBASE_H

#include <vector>

#include <string>
#include "stromx/runtime/Config.h"
#include "stromx/runtime/VariantHandle.h"
#include "stromx/runtime/Enum.h"
#include "stromx/runtime/None.h"

namespace stromx
{
    namespace runtime
    {
        class EnumDescription
        {
        public:            
            explicit EnumDescription(const Enum & value)
              : m_value(value)
            {}
            
            EnumDescription(const Enum & value, const std::string & title)
              : m_value(value),
                m_title(title)
            {}
            
            const Enum value() const { return m_value; }
            
            const std::string & title() const { return m_title; }
            
        private:
            Enum m_value;
            std::string m_title;
        };
        
        class STROMX_RUNTIME_API Description
        {
        public:
            enum Type 
            {
                NO_TYPE,
                PARAMETER,
                INPUT,
                OUTPUT
            };
            
            enum UpdateBehavior
            {
                PERSISTENT,
                PUSH,
                PULL,
                INTERNAL
            };
            
            Description(const unsigned int id, const VariantHandle& variant);
            
            virtual ~Description() {}
            
            const std::string & title() const { return m_title; }
            
            unsigned int id() const { return m_id; }
            
            const VariantHandle & variant() const { return m_variant; }
            
            void setTitle(const std::string & title) { m_title = title; }
            
            const VariantHandle & visualization() const { return m_visualization; }
            
            void setVisualization(const VariantHandle & visualization);
            
            virtual const Data& max() const { return NONE; }
            
            virtual const Data& min() const { return NONE; }
            
            virtual const Data& step() const { return NONE; }
            
            virtual const std::vector<EnumDescription> & descriptions() const { return NO_DESCRIPTIONS; }
            
            virtual unsigned int rows() const { return 0; }
            
            virtual unsigned int cols() const { return 0; }
            
            virtual Type originalType() const { return NO_TYPE; }
            
            virtual Type currentType() const { return NO_TYPE; }
            
        private:
            static const std::vector<EnumDescription> NO_DESCRIPTIONS;
            static const None NONE;
            
            std::string m_title;
            unsigned int m_id;
            VariantHandle m_variant;
            VariantHandle m_visualization;
        };
    }
}

#endif // STROMX_RUNTIME_DESCRIPTIONBASE_H