VariableTypes.h

Go to the documentation of this file.

#pragma once
#include <gii/gen/InformationBase.h>
#include <misc/gen/TVector.h>
#include <misc/gen/Value.h>
#include <utility>
 
namespace sf
{
 
class VariableReference;
 
class Variable;
 
class VariableTypes : public InformationTypes
{
  public:
    typedef TVector<Variable*> PtrVector;
 
    typedef TVector<Variable> Vector;
 
    typedef TVector<VariableReference*> ReferenceVector;
 
    class State
    {
      public:
        State()
          : _name(Value::_invalidStr)
        {}
 
        State(std::string name, const Value& value)
          : _name(std::move(name))
          , _value(value)
        {}
 
        State(const State& s)
        {
          assign(s);
        }
 
        std::string _name;
        Value _value;
 
        State& assign(const State& s)
        {
          _name = s._name;
          _value = s._value;
          return *this;
        }
 
        State& operator=(const State& s)
        {
          assign(s);
          return *this;
        }
 
        bool operator==(const State& state) const
        {
          return (_name == state._name) && (_value == state._value);
        }
 
        bool operator!=(const State& state) const
        {
          return (_name != state._name) || (_value != state._value);
        }
 
        typedef TVector<State> Vector;
    };
 
    enum EEvent : int
    {
      veConvert = 64000,
      veNewId = -32000,
      veUserGlobal,
      veFirstLocal = 0,
      veFlagsChange = 1,
      veValueChange = 2,
      veInvalid = 3,
      veConverted = 4,
      veUserLocal = 5,
      veFirstPrivate = 16000,
      veIdChanged = 16001,
      veDesiredId = 16002,
      veRemove = 16003,
      veGetOwner = 16004,
      veLostOwner = 16005,
      veLinked = 16006,
      veUnlinked = 16007,
      veSetup = 16008,
      veUserPrivate = 16009
    };
 
    enum EField : int
    {
      vfId = 0,
      vfName,
      /***/
      vfUnit,
      vfFlags,
      vfDescription,
      vfType,
      vfConversionType,
      vfRound,
      vfDefault,
      vfMinimum,
      vfMaximum,
      vfFirstState
    };
 
    enum EFlag : flags_type
    {
      flgReadonly = 1 << 0,
      flgArchive = 1 << 1,
      flgShare = 1 << 2,
      flgLink = 1 << 3,
      flgFunction = 1 << 4,
      flgParameter = 1 << 5,
      flgHidden = 1 << 6,
      flgExport = 1 << 7,
      flgWriteable = 1 << 8
    };
 
    enum EStringType : int
    {
      stNormal = 0,
      stMulti,
      stPath,
      stDirectory,
      stFilename,
      stSubdirectory
    };
 
    struct Definition
    {
      public:
        bool _valid{false};
        id_type _id{0};
        std::string _name;
        flags_type _flags{0};
        std::string _description;
        std::string _unit;
        std::string _convertOption;
        Value::EType _type;
        Value _roundValue;
        Value _defaultValue;
        Value _minValue;
        Value _maxValue;
        State::Vector _states;
    };
};
 
}// namespace sf