paramMeta.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut fuer Technische Optik (ITO),
    Universitaet Stuttgart, Germany

    This file is part of itom and its software development toolkit (SDK).

    itom is free software; you can redistribute it and/or modify it
    under the terms of the GNU Library General Public Licence as published by
    the Free Software Foundation; either version 2 of the Licence, or (at
    your option) any later version.
   
    In addition, as a special exception, the Institut fuer Technische
    Optik (ITO) gives you certain additional rights.
    These rights are described in the ITO LGPL Exception version 1.0,
    which can be found in the file LGPL_EXCEPTION.txt in this package.

    itom 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 Library
    General Public Licence for more details.

    You should have received a copy of the GNU Library General Public License
    along with itom. If not, see <http://www.gnu.org/licenses/>.
*********************************************************************** */

#ifndef PARAMMETA_H
#define PARAMMETA_H

/* includes */

#include "commonGlobal.h"
#include "typeDefs.h"
#include "byteArray.h"
#include "retVal.h"

#include <limits>



/* definition and macros */
/* global variables (avoid) */
/* content */

namespace ito
{
    class ITOMCOMMON_EXPORT ParamMeta
    {
    public:
        enum MetaRtti
        {
            rttiUnknown = 0,      
            rttiCharMeta = 1,     
            rttiIntMeta = 2,      
            rttiDoubleMeta = 3,   
            rttiStringMeta = 4,   
            rttiHWMeta = 5,       
            rttiDObjMeta = 6,     
            rttiIntArrayMeta = 7, 
            rttiDoubleArrayMeta = 8, 
            rttiCharArrayMeta = 9, 
            rttiIntervalMeta = 10, 
            rttiDoubleIntervalMeta = 11, 
            rttiRangeMeta = 12,    
            rttiRectMeta = 13      
        };


        enum tRepresentation
        {
            Linear = 0x0001,       
            Logarithmic = 0x0002,  
            Boolean = 0x0004,      
            PureNumber = 0x0008,   
            HexNumber = 0x0010,    
            IPV4Address = 0x0020,  
            MACAddress = 0x0040,   
            UnknownRepresentation = 0x0080
        };

        ParamMeta(ito::ByteArray category = ito::ByteArray());                
        ParamMeta(MetaRtti type, ito::ByteArray category = ito::ByteArray()); 
        virtual ~ParamMeta() {}                            
        inline MetaRtti getType() const { return m_type; } 
        inline ito::ByteArray getCategory() const { return m_category; } 
        void setCategory(const ito::ByteArray &category);

        virtual bool operator==(const ParamMeta& other) const;
        bool operator!=(const ParamMeta& other) const { return !(*this == other); }

    protected:
        MetaRtti m_type;
        ito::ByteArray m_category; 
    };

    class ITOMCOMMON_EXPORT CharMeta : public ParamMeta
    {
    public:

        explicit CharMeta(char minVal, char maxVal, char stepSize = 1, ito::ByteArray category = ito::ByteArray()); 
        static CharMeta* all(ito::ByteArray category = ito::ByteArray()); 
        inline char getMin() const { return m_minVal; }         
        inline char getMax() const { return m_maxVal; }         
        inline char getStepSize() const { return m_stepSize; }  
        inline ito::ByteArray getUnit() const { return m_unit; } 
        inline void setUnit(const ito::ByteArray &unit) { m_unit = unit; } 
        inline ParamMeta::tRepresentation getRepresentation() const { return m_representation; } 
        void setRepresentation(ParamMeta::tRepresentation representation); 


        void setMin(char val);
        

        void setMax(char val);


        void setStepSize(char val);

        virtual bool operator==(const ParamMeta& other) const;
    private:
        char m_minVal;
        char m_maxVal;
        char m_stepSize; // >= 1
        ito::ByteArray m_unit; 
        ParamMeta::tRepresentation m_representation; 
    };

    class ITOMCOMMON_EXPORT IntMeta : public ParamMeta
    {
    public:

        explicit IntMeta(int32 minVal, int32 maxVal, int32 stepSize = 1, ito::ByteArray category = ito::ByteArray()); 
        static IntMeta* all(ito::ByteArray category = ito::ByteArray()); 
        inline int32 getMin() const { return m_minVal; }              
        inline int32 getMax() const { return m_maxVal; }              
        inline int32 getStepSize() const { return m_stepSize; }       
        inline ito::ByteArray getUnit() const { return m_unit; } 
        inline void setUnit(const ito::ByteArray &unit) { m_unit = unit; } 
        inline ParamMeta::tRepresentation getRepresentation() const { return m_representation; } 
        void setRepresentation(ParamMeta::tRepresentation behaviour); 
        

        void setMin(int32 val);
        

        void setMax(int32 val);


        void setStepSize(int32 val);

        virtual bool operator==(const ParamMeta& other) const;
    private:
        int32 m_minVal;
        int32 m_maxVal;
        int32 m_stepSize; // >= 1
        ito::ByteArray m_unit; 
        ParamMeta::tRepresentation m_representation; 
    };

    class ITOMCOMMON_EXPORT DoubleMeta : public ParamMeta
    {
    public:
        enum tDisplayNotation
        {
            Automatic,  
            Fixed,      
            Scientific  
        };


        explicit DoubleMeta(float64 minVal, float64 maxVal, float64 stepSize = 0.0 /*0.0 means no specific step size*/, ito::ByteArray category = ito::ByteArray());
        static DoubleMeta* all(ito::ByteArray category = ito::ByteArray()); 
        inline float64 getMin() const { return m_minVal; }        
        inline float64 getMax() const { return m_maxVal; }        
        inline float64 getStepSize() const { return m_stepSize; } 
        inline ito::ByteArray getUnit() const { return m_unit; } 
        inline void setUnit(const ito::ByteArray &unit) { m_unit = unit; } 
        inline int getDisplayPrecision() const { return m_displayPrecision; } 
        inline void setDisplayPrecision(int displayPrecision) { m_displayPrecision = displayPrecision; } 
        inline DoubleMeta::tDisplayNotation getDisplayNotation() const { return m_displayNotation; } 
        inline void setDisplayNotation(DoubleMeta::tDisplayNotation displayNotation) { m_displayNotation = displayNotation; } 
        inline ParamMeta::tRepresentation getRepresentation() const { return m_representation; } 
        void setRepresentation(ParamMeta::tRepresentation representation); 
        

        void setMin(float64 val);
        

        void setMax(float64 val);


        void setStepSize(float64 val);

        virtual bool operator==(const ParamMeta& other) const;

    private:
        float64 m_minVal;
        float64 m_maxVal;
        float64 m_stepSize; // >= 0, 0.0 means no specific step size
        ito::ByteArray m_unit; 
        int m_displayPrecision; 
        tDisplayNotation m_displayNotation; 
        ParamMeta::tRepresentation m_representation; 
    };

    class ITOMCOMMON_EXPORT HWMeta : public ParamMeta
    {
        public:

            explicit HWMeta(uint32 minType, ito::ByteArray category = ito::ByteArray()) : ParamMeta(rttiHWMeta, category), m_minType(minType)
            {
            }


            explicit HWMeta(const char *HWAddInName, ito::ByteArray category = ito::ByteArray()) : ParamMeta(rttiHWMeta, category), m_minType(0), m_HWName(HWAddInName)
            {
            }


            HWMeta(const HWMeta& cpy) : ParamMeta(cpy), m_minType(cpy.m_minType), m_HWName(cpy.m_HWName)
            {
            }

            inline uint32 getMinType() const { return m_minType; }             
            inline ito::ByteArray getHWAddInName() const { return m_HWName; }  

            virtual bool operator==(const ParamMeta& other) const;
        private:
            uint32 m_minType;            
            ito::ByteArray m_HWName;     
    };

    class StringMetaPrivate; //forward declaration

    class ITOMCOMMON_EXPORT StringMeta : public ParamMeta
    {
        public:
            enum tType 
            {
                String,   
                Wildcard, 
                RegExp    
            };


            StringMeta(tType type, ito::ByteArray category = ito::ByteArray());


            StringMeta(tType type, const char* val, ito::ByteArray category = ito::ByteArray());


            StringMeta(tType type, const ito::ByteArray &val, ito::ByteArray category = ito::ByteArray());

            StringMeta(const StringMeta& cpy);

            virtual ~StringMeta();


            tType getStringType() const;                   
            void setStringType(tType type);                
            int getLen() const;                            
            const char* getString(int idx = 0) const;      
            bool addItem(const char *val);                 
            bool addItem(const ito::ByteArray &val);       
            void clearItems();                             
            StringMeta & operator += (const char *val);    
            StringMeta & operator = (const StringMeta& rhs);
            virtual bool operator==(const ParamMeta& other) const;

        private:

            StringMetaPrivate *p;
            
    };

    class ITOMCOMMON_EXPORT DObjMeta : public ParamMeta
    {
        public:

            explicit DObjMeta(uint32 allowedTypes = 0xFFFF, int minDim = 0, int maxDim = (std::numeric_limits<int>::max)(), ito::ByteArray category = ito::ByteArray()) : ParamMeta(rttiDObjMeta, category), m_allowedTypes(allowedTypes), m_minDim(minDim), m_maxDim(maxDim) {}
            inline int getAllowedTypes() const { return m_allowedTypes; }
            inline int getMinDim() const { return m_minDim; } 
            inline int getMaxDim() const { return m_maxDim; } 
            virtual bool operator==(const ParamMeta& other) const;

        private:
            uint32 m_allowedTypes;
            int m_minDim;
            int m_maxDim;
    };

    class ITOMCOMMON_EXPORT CharArrayMeta : public CharMeta
    {
    public:

        explicit CharArrayMeta(char minVal, char maxVal, char stepSize = 1, ito::ByteArray category = ito::ByteArray());
        explicit CharArrayMeta(char minVal, char maxVal, char stepSize, size_t numMin, size_t numMax, size_t numStepSize = 1, ito::ByteArray category = ito::ByteArray());
        inline size_t getNumMin() const { return m_numMin; }         
        inline size_t getNumMax() const { return m_numMax; }         
        inline size_t getNumStepSize() const { return m_numStep; }   


        void setNumMin(size_t val);
        

        void setNumMax(size_t val);


        void setNumStepSize(size_t val);

        virtual bool operator==(const ParamMeta& other) const;

    private:
        size_t m_numMin;
        size_t m_numMax;
        size_t m_numStep;
    };

    class ITOMCOMMON_EXPORT IntArrayMeta : public IntMeta
    {
    public:

        explicit IntArrayMeta(int32 minVal, int32 maxVal, int stepSize = 1, ito::ByteArray category = ito::ByteArray());
        explicit IntArrayMeta(int32 minVal, int32 maxVal, int stepSize, size_t numMin, size_t numMax, size_t numStepSize = 1, ito::ByteArray category = ito::ByteArray());
        inline size_t getNumMin() const { return m_numMin; }         
        inline size_t getNumMax() const { return m_numMax; }         
        inline size_t getNumStepSize() const { return m_numStep; }   


        void setNumMin(size_t val);
        

        void setNumMax(size_t val);


        void setNumStepSize(size_t val);

        virtual bool operator==(const ParamMeta& other) const;

    private:
        size_t m_numMin;
        size_t m_numMax;
        size_t m_numStep;
    };

    class ITOMCOMMON_EXPORT DoubleArrayMeta : public DoubleMeta
    {
    public:

        explicit DoubleArrayMeta(float64 minVal, float64 maxVal, float64 stepSize = 0.0, ito::ByteArray category = ito::ByteArray());
        explicit DoubleArrayMeta(float64 minVal, float64 maxVal, float64 stepSize, size_t numMin, size_t numMax, size_t numStepSize = 1, ito::ByteArray category = ito::ByteArray());
        inline size_t getNumMin() const { return m_numMin; }         
        inline size_t getNumMax() const { return m_numMax; }         
        inline size_t getNumStepSize() const { return m_numStep; }   


        void setNumMin(size_t val);
        

        void setNumMax(size_t val);


        void setNumStepSize(size_t val);

        virtual bool operator==(const ParamMeta& other) const;

    private:
        size_t m_numMin;
        size_t m_numMax;
        size_t m_numStep;
    };


    class ITOMCOMMON_EXPORT DoubleIntervalMeta : public DoubleMeta
    {
    public:

        explicit DoubleIntervalMeta(float64 minVal, float64 maxVal, float64 stepSize = 0.0, ito::ByteArray category = ito::ByteArray());
        explicit DoubleIntervalMeta(float64 minVal, float64 maxVal, float64 stepSize, float64 sizeMin, float64 sizeMax, float64 sizeStep = 0.0, ito::ByteArray category = ito::ByteArray());
        inline float64 getSizeMin() const { return m_sizeMin; }         
        inline float64 getSizeMax() const { return m_sizeMax; }         
        inline float64 getSizeStepSize() const { return m_sizeStep; }   


        void setSizeMin(float64 val);
        

        void setSizeMax(float64 val);


        void setSizeStep(float64 val);

        virtual bool operator==(const ParamMeta& other) const;

    private:
        float64 m_sizeMin;
        float64 m_sizeMax;
        float64 m_sizeStep;
    };


    class ITOMCOMMON_EXPORT IntervalMeta : public IntMeta
    {
    public:
        explicit IntervalMeta(int32 minVal, int32 maxVal, int32 stepSize = 1, ito::ByteArray category = ito::ByteArray());
        explicit IntervalMeta(int32 minVal, int32 maxVal, int32 stepSize, int32 sizeMin, int32 sizeMax, int32 intervalStep = 1, ito::ByteArray category = ito::ByteArray());
        inline int getSizeMin() const { return m_sizeMin; }         
        inline int getSizeMax() const { return m_sizeMax; }         
        inline int getSizeStepSize() const { return m_sizeStep; }   
        inline bool isIntervalNotRange() const { return m_isIntervalNotRange; }


        void setIntervalMin(int32 val);
        

        void setIntervalMax(int32 val);


        void setIntervalStep(int32 val);

        virtual bool operator==(const ParamMeta& other) const;

    protected:
        int32 m_sizeMin;
        int32 m_sizeMax;
        int32 m_sizeStep;
        bool m_isIntervalNotRange; 
    };


    class ITOMCOMMON_EXPORT RangeMeta : public IntervalMeta
    {
    public:
        explicit RangeMeta(int32 minVal, int32 maxVal, int32 stepSize = 1, ito::ByteArray category = ito::ByteArray());
        explicit RangeMeta(int32 minVal, int32 maxVal, int32 stepSize, size_t sizeMin, size_t sizeMax, size_t sizeStep = 1, ito::ByteArray category = ito::ByteArray());
    };


    class ITOMCOMMON_EXPORT RectMeta : public ParamMeta
    {
    public:
        explicit RectMeta(const ito::RangeMeta &widthMeta, const ito::RangeMeta &heightMeta, ito::ByteArray category = ito::ByteArray());
        inline const ito::RangeMeta& getWidthRangeMeta() const { return m_widthMeta; }
        inline const ito::RangeMeta& getHeightRangeMeta() const { return m_heightMeta; }

        void setWidthRangeMeta(const ito::RangeMeta &widthMeta);
        void setHeightRangeMeta(const ito::RangeMeta &heightMeta);

        inline ito::ByteArray getUnit() const { return m_heightMeta.getUnit(); } 
        inline void setUnit(const ito::ByteArray &unit) { m_heightMeta.setUnit(unit); } 

        virtual bool operator==(const ParamMeta& other) const;

    protected:
        ito::RangeMeta m_heightMeta;
        ito::RangeMeta m_widthMeta;
    };



} //end namespace ito

#endif