paramMeta.h

/* ********************************************************************
    itom software
    URL: http://www.uni-stuttgart.de/ito
    Copyright (C) 2020, Institut für Technische Optik (ITO),
    Universität 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 für 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/>.
*********************************************************************** */
 
#pragma once
 
/* includes */
 
#include "byteArray.h"
#include "commonGlobal.h"
#include "retVal.h"
#include "typeDefs.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,  
        rttiStringListMeta = 14 
    };
 
    enum tRepresentation
    {
        Linear = 0x0001,      
        Logarithmic = 0x0002, 
        Boolean = 0x0004,     
        PureNumber = 0x0008,  
        HexNumber = 0x0010,   
        IPV4Address = 0x0020, 
        MACAddress = 0x0040,  
        UnknownRepresentation = 0x0080
    };
 
    explicit ParamMeta(ito::ByteArray category = ito::ByteArray());
 
    explicit ParamMeta(MetaRtti type, ito::ByteArray category = ito::ByteArray());
 
    ParamMeta(const ParamMeta &copy);
 
    ParamMeta &operator=(const ParamMeta &rhs);
 
    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());
 
    CharMeta(const CharMeta &copy);
 
    CharMeta &operator=(const CharMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    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;
    }
 
    void setUnit(const ito::ByteArray &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);
 
  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());
 
    IntMeta(const IntMeta &copy);
 
    IntMeta &operator=(const IntMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    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;
    }
 
    void setUnit(const ito::ByteArray &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);
 
  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());
 
    DoubleMeta(const DoubleMeta &copy);
 
    DoubleMeta &operator=(const DoubleMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    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;
    }
 
    void setUnit(const ito::ByteArray &unit);
 
    inline int getDisplayPrecision() const
    {
        return m_displayPrecision;
    }
 
    void setDisplayPrecision(int displayPrecision);
 
    inline DoubleMeta::tDisplayNotation getDisplayNotation() const
    {
        return m_displayNotation;
    }
 
    void setDisplayNotation(DoubleMeta::tDisplayNotation 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);
 
  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());
 
 
    explicit HWMeta(const ito::ByteArray &hwAddInName, ito::ByteArray category = ito::ByteArray());
 
    HWMeta(const HWMeta &cpy);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    HWMeta &operator=(const HWMeta &rhs);
 
    inline uint32 getMinType() const
    {
        return m_minType;
    }
 
    inline ito::ByteArray getHWAddInName() const
    {
        return m_HWName;
    }
 
  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();
 
    StringMeta &operator+=(const char *val); 
    StringMeta &operator=(const StringMeta &rhs);
    virtual bool operator==(const ParamMeta &other) const;
 
    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();                       
 
  private:
    StringMetaPrivate *p;
};
 
class ITOMCOMMON_EXPORT DObjMeta : public ParamMeta
{
  public:
 
    explicit DObjMeta(int minDim = 0, int maxDim = (std::numeric_limits<int>::max)(),
          ito::ByteArray category = ito::ByteArray());
 
    DObjMeta(const DObjMeta &cpy);
 
    DObjMeta &operator=(const DObjMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    int getNumAllowedDataTypes() const;
 
    ito::tDataType getAllowedDataType(int index) const;
 
    bool isDataTypeAllowed(ito::tDataType dataType) const;
 
    void appendAllowedDataType(ito::tDataType dataType);
 
    inline int getMinDim() const
    {
        return m_minDim;
    }
 
    inline int getMaxDim() const
    {
        return m_maxDim;
    }
 
    inline void setMinDim(int minDim)
    {
        m_minDim = minDim;
    }
 
    inline void setMaxDim(int maxDim)
    {
        m_maxDim = maxDim;
    }
 
  private:
    ito::ByteArray m_allowedTypes;
    int m_minDim;
    int m_maxDim;
};
 
class ITOMCOMMON_EXPORT ListMeta
{
public:
    ListMeta();
 
    explicit ListMeta(size_t numMin, size_t numMax, size_t numStepSize = 1);
 
    virtual ~ListMeta();
 
    virtual bool operator==(const ListMeta &other) const;
 
    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);
 
private:
    size_t m_numMin;
    size_t m_numMax;
    size_t m_numStep;
};
 
class ITOMCOMMON_EXPORT CharArrayMeta : public CharMeta, public ListMeta
{
  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());
 
    CharArrayMeta(const CharArrayMeta &cpy);
 
    CharArrayMeta &operator=(const CharArrayMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
};
 
class ITOMCOMMON_EXPORT IntArrayMeta : public IntMeta, public ListMeta
{
  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());
 
    IntArrayMeta(const IntArrayMeta &cpy);
 
    IntArrayMeta &operator=(const IntArrayMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
};
 
class ITOMCOMMON_EXPORT DoubleArrayMeta : public DoubleMeta, public ListMeta
{
  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());
 
    DoubleArrayMeta(const DoubleArrayMeta &cpy);
 
    DoubleArrayMeta &operator=(const DoubleArrayMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
};
 
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());
 
    DoubleIntervalMeta(const DoubleIntervalMeta &cpy);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    DoubleIntervalMeta &operator=(const DoubleIntervalMeta &rhs);
 
    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);
 
  private:
    float64 m_sizeMin;
    float64 m_sizeMax;
    float64 m_sizeStep;
};
 
class ITOMCOMMON_EXPORT StringListMeta : public StringMeta, public ListMeta
{
  public:
 
    explicit StringListMeta(tType type, size_t numMin, size_t numMax, size_t numStepSize = 1,
                            ito::ByteArray category = ito::ByteArray());
 
 
    explicit StringListMeta(tType type, const char *val, size_t numMin, size_t numMax, size_t numStepSize = 1,
                            ito::ByteArray category = ito::ByteArray());
 
 
    explicit StringListMeta(tType type, const ito::ByteArray &val, size_t numMin, size_t numMax, size_t numStepSize = 1,
                            ito::ByteArray category = ito::ByteArray());
 
    StringListMeta(const StringListMeta &cpy);
 
    virtual ~StringListMeta();
 
    virtual bool operator==(const ParamMeta &other) const;
 
    StringListMeta &operator=(const StringListMeta &rhs);
};
 
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());
 
    IntervalMeta(const IntervalMeta &cpy);
 
    IntervalMeta &operator=(const IntervalMeta &rhs);
 
    virtual bool operator==(const ParamMeta &other) const;
 
    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);
 
  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());
 
    RangeMeta(const RangeMeta &cpy);
 
    RangeMeta &operator=(const RangeMeta &rhs);
};
 
class ITOMCOMMON_EXPORT RectMeta : public ParamMeta
{
  public:
    explicit RectMeta(const ito::RangeMeta &widthMeta, const ito::RangeMeta &heightMeta,
                      ito::ByteArray category = ito::ByteArray());
 
    RectMeta(const RectMeta &cpy);
 
    RectMeta &operator=(const RectMeta &rhs);
 
    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();
    }
 
    void setUnit(const ito::ByteArray &unit);
 
    virtual bool operator==(const ParamMeta &other) const;
 
  protected:
    ito::RangeMeta m_heightMeta;
    ito::RangeMeta m_widthMeta;
};
 
} // end namespace ito