Zugriff auf Wertelisten über den Wertebezeichner

[Matsch]

Ich habe bisher vergeblich eine Möglichkeit gesucht, im Script die Bezeichner eines Elements einer Werteliste direkt nutzen zu können.
Beispiel, folgende Werteliste:

Funkklingel_Tastenmode.jpg (22.67 KiB) 502 mal betrachtet

Ich möchte nun im Script einen dieser Werte als Kriterium oder als Konstante benutzen. z.B. so:

Code: Alles auswählen

integer t = 4;
object o = dom.GetObject(ID_SYSTEM_VARIABLES).Get("Testvariable");

integer x = PlayWhilePressed;
  ! oder
o.State(PlayWhilePressed);
   ! oder
if (t == PlayWhilePressed) { ... }

Nun gibt es ja weder Konstanten (da ist mir auch kein Objekttyp "Konstante" bekannt), noch defines noch Makros.
Momentan realisiere ich das damit, am Scriptanfang die ganzen enum-Werte der Liste als Variable anzulegen:

Code: Alles auswählen

object oFK_Mode = dom.GetObject(ID_SYSTEM_VARIABLES).Get("SV_Funkklingel_Tastenmode");
   integer noop = 0;
   integer normal = 1;
   integer PlayWhilePressed = 2;
   integer PlayWhilePresedLoop = 3;
   integer PlayToEnd = 4;
   integer RandomAndRow = 5;
   integer RandomAndRowEnd = 6;
   
   

Das ist aber nicht sehr effektiv, insbesondere für die Softwarepflege. Zudem darf es dann bei mehreren Wertelisten keine Elementebezeichner doppelt geben, zumindest nicht, wenn sich der enum-Wert unterscheidet.
Kennt jemand doch noch einen Weg, wie man das eleganter lösen kann?
Ideal wäre eine Lösung, direkt die Elementebezeichner zu verwenden ohne sie erst im Script nochmal anlegen zu müssen und die sich dann automatisch an veränderte Wertelistendefinitionen anpassen.

[Baxxy]

Ich versteh's nicht so ganz.

Willst du:
- den Bezeichner des aktuellen Wertes der SysVar als Wert einer Script-Variable haben?
- den Bezeichner eines bestimmten Wertes der SysVar als Wert einer Script-Variable haben? (also du gibst die Position des Wertes im Script vor)

[Matsch]

Wie ich den Bezeichner auslese, weiss ich ja. Das hilft mir aber nicht weiter. Ich kenne ja die Elementebezeichner und will sie mit ihrem Namen im Script als Konstante einsetzen. Ich habe ja in 3 Beispielen gezeigt, wie ich die Elementebezeichner direkt im Script verwende - ohne dabei wissen zu müssen, welcher enum sich dahinter verbirgt.

Es geht nicht um den Inhalt einer Variablen vom Typ Werteliste, sondern den definierten enum-Wert hinter dem Elementenamen.

Theoretisch könnte ich ja statt wie bisher dem Elementenamen eine Konstante zuzuweisen, jeden Namen nacheinander in der Definition suchen und so die korrekte Konstante dazu ermitteln, aber das wäre eine ziemliche Überladung des Scripts. Insbesondere, wenn mehrere längere Wertelisten im Einsatz sind. Und extra definieren als Variable müßte ich trotzdem jeden einzelnen existierenden Elementenamen.

[[sprotte80]]

Hi

Ich habe bisher vergeblich eine Möglichkeit gesucht, im Script die Bezeichner eines Elements einer Werteliste direkt nutzen zu können.

Code: Alles auswählen

object Object = dom.GetObject(ID_SYSTEM_VARIABLES).Get('Testvariable');
string StringValue;

StringValue = web.webGetValueFromList(Object.ValueList(),Object.Value());

if(StringValue == 'noop')
{

}
elseif(StringValue == 'normal')
{

}
elseif(StringValue == 'PlayWhilePressed')
{

}
... 

Thomas

[Henke]

Der Wunsch ist mir nicht unbekannt, daher weiß ich wohl, was du möchtest.

Code: Alles auswählen

typedef Farbe =rot, blau=5, gruen;

Farbe kWert = Farbe.blau;

if ( kWert  == Farbe.blau )
Ausgabe, wo ist blau

Kurz und bündig, vergiss es. So etwas ist in anderen Sprachen mehr oder weniger gut implementiert. Im CCU-Script habe ich überlegt wie es zu realisieren ist, aber damit wird der Code extrem aufgebläht. So wie du es machst, mit der nochmaligen Definition, ist mMn das Optimum des machbaren.

[Matsch]

Hmm, den Vorschlag von Thomas muss ich mir nochmal auf der Zunge zergehen lassen. Der Unterschied besteht ja vor allem darin, dass ich bisher den echten enum-Wert speichere oder vergleiche, also eine integer.
Sein Vorschlag geht ja dahin, nicht den tatsächlichen Wert zu speichern, sondern den zugeordneten Elementenamen als string.
Muss ich mal für alle Fälle durchtesten, ob das effektiver zu handhaben ist.

[Tyfys]

aber damit wird der Code extrem aufgebläht.

Da hat Henke natürlich recht.
so sähe das in etwa aus :

Code: Alles auswählen

!varliste= "noop;normal;PlayWhilePressed;PlayWhilePresedLoop;PlayToEnd;RandomAndRow;RandomAndRowEnd";
string SepChar= ";";
string ListVarName = "SV_Funkklingel_Tastenmode";
object Arr = SepChar # dom.GetObject(ID_SYSTEM_VARIABLES).Get(ListVarName).ValueList()# SepChar;

var noop = "noop";
noop =  web.webGetValueListCount(Arr.Substr(0, Arr.Find(SepChar # noop # SepChar) + (SepChar # noop # SepChar).Length())).ToInteger() - 3;
WriteLine(Mittag);

var normal ="normal";
normal =  web.webGetValueListCount(Arr.Substr(0, Arr.Find(SepChar # normal # SepChar) + (SepChar # normal # SepChar).Length())).ToInteger() - 3;
WriteLine(normal);

!usw, usw

So wie du es machst, mit der nochmaligen Definition, ist mMn das Optimum des machbaren.

Man könnte sich die paar Definitionszeilen noch per Skript erzeugen und dann in das passende kopieren.

Code: Alles auswählen

!Definitiuonszeilen erstellen
string ListVarName = "SV_Funkklingel_Tastenmode";
string Line;
string element;
integer enum =0;
foreach (element, (dom.GetObject(ID_SYSTEM_VARIABLES).Get(ListVarName).ValueList()).Split(";"))
{
Line = "integer " # element  #" = " # enum #";";
WriteLine(Line);
enum = enum +1;
}

[[sprotte80]]

Hi

nicht den tatsächlichen Wert zu speichern, sondern den zugeordneten Elementenamen als string.

Ich hab da nen HowTo gefunden wo ich gefragt hab ob ichs posten darf:

Code: Alles auswählen

! HM-Internals Dokumentation (HowTo)
! Wertelisten anhand des Text-Wertes einer Werteliste synchronisieren und/oder ändern
! (C)2018 by BadenPower
! hierbei können sich die Wertelisten anhand der String-Werte, Anzahl und Reiehnfolge unterscheiden
!-------------------------------

!Namen der Systemvariablen
object lObjSysVarSourceName = "SysVar_ValueListSource";
object lObjSysVarDestSyncName = "SysVar_ValueListDestSync";
object lObjSysVarDestChangeName = "SysVar_ValueListDestChange";

!Konstante String-Werte, welche in den Wertelisten Verwendung finden
string lConstKeyValueA = "ValueA";
string lConstKeyValueB = "ValueB";
string lConstKeyValueC = "ValueC";
string lConstKeyValueD = "ValueD";
string lConstKeyValueE = "ValueE";
string lConstKeyValueV = "ValueV";
string lConstKeyValueW = "ValueW";
string lConstKeyValueX = "ValueX";
string lConstKeyValueY = "ValueY";
string lConstKeyValueZ = "ValueZ";

!sonstige Einstellungen
boolean lUse_webGetValueFromList = false;
boolean lTestWithoutSysVars = true;
integer lTestSourceValueIndex = 5;
string lTestValueListSource = lConstKeyValueA # ";" # lConstKeyValueB # ";" # lConstKeyValueC # ";" # lConstKeyValueD # ";" # lConstKeyValueE;
string lTestValueListDestSync = lConstKeyValueD # ";" # lConstKeyValueE # ";" # lConstKeyValueA # ";" # lConstKeyValueC;
string lTestValueListDestChange = lConstKeyValueV # ";" # lConstKeyValueW # ";" # lConstKeyValueX # ";" # lConstKeyValueY # ";" # lConstKeyValueZ;

!-------------------------------
!ab hier keine Änderungen mehr vornehmen

object lObjSysVarSource;
object lObjSysVarDestSync;
object lObjSysVarDestChange;

string lValueListSource;
string lValueListDestSync;
string lValueListDestChange;

object lObjKeyValueListSource;
object lObjKeyValueListDestSync;
object lObjKeyValueListDestChange;

string lSourceValueString;
integer lSourceValueIndex;
string lDestValueStringNew;
boolean lDestDoChange;
string lEnum;
object lNullObject;
integer lCount;
object lObjKeyValue;
string lKeyString;

if(lTestWithoutSysVars)
{
  lValueListSource = lTestValueListSource;
  lValueListDestSync = lTestValueListDestSync;
  lValueListDestChange = lTestValueListDestChange;
  lSourceValueIndex = lTestSourceValueIndex;
}
else
{
  lObjSysVarSource = (dom.GetObject(ID_SYSTEM_VARIABLES)).Get(lObjSysVarSourceName);
  lObjSysVarDestSync = (dom.GetObject(ID_SYSTEM_VARIABLES)).Get(lObjSysVarDestSyncName);
  lObjSysVarDestChange = (dom.GetObject(ID_SYSTEM_VARIABLES)).Get(lObjSysVarDestChangeName);
  if((lObjSysVarSource) && (lObjSysVarSource.IsTypeOf(OT_VARDP)))
  {
    lValueListSource = lObjSysVarSource.ValueList();
    lSourceValueIndex = lObjSysVarSource.Value();
  }
  if((lObjSysVarDestSync) && (lObjSysVarDestSync.IsTypeOf(OT_VARDP)))
  {
    lValueListDestSync = lObjSysVarDestSync.ValueList();
  }
  if((lObjSysVarDestChange) && (lObjSysVarDestChange.IsTypeOf(OT_VARDP)))
  {
    lValueListDestChange = lObjSysVarDestChange.ValueList();
  }
}

if((lTestWithoutSysVars) || ((lObjSysVarSource) && (lObjSysVarDestSync) && (lObjSysVarDestChange)))
{
  !Erstellen der Zuordnungslisten für Index / Stringwert
  lObjKeyValueListSource = dom.CreateObject(OT_ENUM,"KeyValueListSource");
  lCount = web.webGetValueListCount(lValueListSource);
  if(lCount > 0)
  {
    foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
    {
      lKeyString = web.webGetValueFromList(lValueListSource,system.ToInt(lEnum));
      lObjKeyValue = dom.CreateObject(OT_VARDP,lKeyString);
      if(lObjKeyValue)
      {
        lObjKeyValue.ValueType(ivtInteger);
        lObjKeyValue.State(system.ToInt(lEnum) );         !
        lObjKeyValueListSource.Add(lObjKeyValue);
      }
    }
  }
  lObjKeyValueListDestSync = dom.CreateObject(OT_ENUM,"KeyValueListDestSync");
  lCount = web.webGetValueListCount(lValueListDestSync);
  if(lCount > 0)
  {
    foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
    {
      lKeyString = web.webGetValueFromList(lValueListDestSync,system.ToInt(lEnum));
      lObjKeyValue = dom.CreateObject(OT_VARDP,lKeyString);
      if(lObjKeyValue)
      {
        lObjKeyValue.ValueType(ivtInteger);
        lObjKeyValue.State(system.ToInt(lEnum) );         !
        lObjKeyValueListDestSync.Add(lObjKeyValue);
      }
    }
  }
  lObjKeyValueListDestChange = dom.CreateObject(OT_ENUM,"KeyValueListDestChange");
  lCount = web.webGetValueListCount(lValueListDestChange);
  if(lCount > 0)
  {
    foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
    {
      lKeyString = web.webGetValueFromList(lValueListDestChange,system.ToInt(lEnum));
      lObjKeyValue = dom.CreateObject(OT_VARDP,lKeyString);
      if(lObjKeyValue)
      {
        lObjKeyValue.ValueType(ivtInteger);
        lObjKeyValue.State(system.ToInt(lEnum) );         !
        lObjKeyValueListDestChange.Add(lObjKeyValue);
      }
    }
  }

  !Ermitteln des aktuellen String-Wertes der Source-Werteliste
  if(lUse_webGetValueFromList)
  {
    !Ermitteln via webGetValueFromList
    !ungenau, da bei Index-Über- oder Unterschreitung ein leerer String zurückgegeben wird
    lSourceValueString = web.webGetValueFromList(lValueListSource,lSourceValueIndex);
  }
  else
  {
    !Ermitteln via GetAt
    if(lObjKeyValueListDestSync.GetAt(lSourceValueIndex))
    {
      lSourceValueString = (lObjKeyValueListSource.GetAt(lSourceValueIndex)).Name();
    }
    else
    {
      WriteLine("----------------------------------------");
      WriteLine("Source-Index ausserhalb der Grenzen");
    }
  }

  !Ausgabe der Zuordnungen
  if(lTestWithoutSysVars)
  {
    lCount = lObjKeyValueListSource.Count();
    if(lCount > 0)
    {
      WriteLine("----------------------------------------");
      WriteLine("Zuordnungen in Werteliste " # lObjSysVarSourceName # ":");
      foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
      {
        Write((lObjKeyValueListSource.GetAt(system.ToInt(lEnum))).Name());
        Write(" = ");
        WriteLine((lObjKeyValueListSource.GetAt(system.ToInt(lEnum))).State());
      }
    }
    lCount = lObjKeyValueListDestSync.Count();
    if(lCount > 0)
    {
      WriteLine("----------------------------------------");
      WriteLine("Zuordnungen in Werteliste " # lObjSysVarDestSyncName # ":");
      foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
      {
        Write((lObjKeyValueListDestSync.GetAt(system.ToInt(lEnum))).Name());
        Write(" = ");
        WriteLine((lObjKeyValueListDestSync.GetAt(system.ToInt(lEnum))).State());
      }
    }
    lCount = lObjKeyValueListDestChange.Count();
    if(lCount > 0)
    {
      WriteLine("----------------------------------------");
      WriteLine("Zuordnungen in Werteliste " # lObjSysVarDestChangeName # ":");
      foreach(lEnum,system.GenerateEnum(0,(lCount - 1)))
      {
        Write((lObjKeyValueListDestChange.GetAt(system.ToInt(lEnum))).Name());
        Write(" = ");
        WriteLine((lObjKeyValueListDestChange.GetAt(system.ToInt(lEnum))).State());
      }
    }
    WriteLine("Source ValueString; " # lSourceValueString);
    WriteLine("Source Index; " # lSourceValueIndex);
  }

  !ErrorHandlingBlock um bei einem ScriptRuntimeError die angelegten Objekte löschen zu können
  if(true)
  {
    !in diesem Block befinden sich die eigentlchen Aktionen

    !synchronisieren der 2. Werteliste
    lObjKeyValue = lObjKeyValueListDestSync.Get(lSourceValueString);
    if(lObjKeyValue)
    {
      if(lTestWithoutSysVars)
      {
        WriteLine("----------------------------------------");
        WriteLine("Synchronisation:");
        WriteLine("SysVar " # lObjSysVarDestSyncName # ": neuer Wert = " # lObjKeyValue.State());
      }
      else
      {
        lObjSysVarDestSync.State(lObjKeyValue.State());
      }
    }
    else
    {
      if(lTestWithoutSysVars)
      {
        WriteLine("----------------------------------------");
        WriteLine("SysVar " # lObjSysVarDestSyncName # ": Keine Übereinstimmung zum Synchronisieren gefunden.");
      }
    }

    !ändern der 3. Werteliste
    lDestValueStringNew = "";
    lDestDoChange = false;
    if(lSourceValueString == lConstKeyValueA)
    {
      lDestValueStringNew = lConstKeyValueV;
      lDestDoChange = true;
    }
    elseif(lSourceValueString == lConstKeyValueB)
    {
      lDestValueStringNew = lConstKeyValueW;
      lDestDoChange = true;
    }
    elseif(lSourceValueString == lConstKeyValueC)
    {
      lDestValueStringNew = lConstKeyValueX;
      lDestDoChange = true;
    }
    elseif(lSourceValueString == lConstKeyValueD)
    {
      lDestValueStringNew = lConstKeyValueY;
      lDestDoChange = true;
    }
    elseif(lSourceValueString == lConstKeyValueE)
    {
      lDestValueStringNew = lConstKeyValueZ;
      lDestDoChange = true;
    }

    if(lDestDoChange)
    {
      lObjKeyValue = lObjKeyValueListDestChange.Get(lDestValueStringNew);
      if(lObjKeyValue)
      {
        if(lTestWithoutSysVars)
        {
          WriteLine("----------------------------------------");
          WriteLine("Änderung:");
          WriteLine("SysVar " # lObjSysVarDestChangeName # ": neuer Wert = " # lObjKeyValue.State() # " (" # lDestValueStringNew # ")");
        }                                                                                                       
        else
        {
          lObjSysVarDestChange.State(lObjKeyValue.State());
        }
      }
    }
    else
    {
      if(lTestWithoutSysVars)
      {
        WriteLine("----------------------------------------");
        WriteLine("SysVar " # lObjSysVarDestSyncName # ": Keine Übereinstimmung zum Ändern gefunden.");
      }
    }

  } !Ende ErrorHandlingBlock

  !angelegte Objekte löschen
  if(lObjKeyValueListSource)
  {
    foreach(lEnum,lObjKeyValueListSource.EnumIDs())
    {
      dom.DeleteObject(system.ToInt(lEnum));
    }
    dom.DeleteObject(lObjKeyValueListSource);
    lObjKeyValueListSource = lNullObject;
  }
  if(lObjKeyValueListDestSync)
  {
    foreach(lEnum,lObjKeyValueListDestSync.EnumIDs())
    {
      dom.DeleteObject(system.ToInt(lEnum));
    }
    dom.DeleteObject(lObjKeyValueListDestSync);
    lObjKeyValueListDestSync = lNullObject;
  }
  if(lObjKeyValueListDestChange)
  {
    foreach(lEnum,lObjKeyValueListDestChange.EnumIDs())
    {
      dom.DeleteObject(system.ToInt(lEnum));
    }
    dom.DeleteObject(lObjKeyValueListDestChange);
    lObjKeyValueListDestChange = lNullObject;
  }
}

Thomas

[Henke]

Gut das das den Code nicht aufbläht...

[Matsch]

Man könnte sich die paar Definitionszeilen noch per Skript erzeugen und dann in das passende kopieren.

So, nachdem ich mich erstmal um eine dringende Baustelle kümmern mußte (Scriptänderung verursachte DC-Hochlauf bis Anschlag), habe ich deine Idee mal umgesetzt, um eine vollständige Liste aller Systemvariablen vom Typ Werteliste aufzulisten samt Elemente.

Code: Alles auswählen

! Auflisten aller vorhandenen Systemvariablen vom Typ Werteliste

string ListVarName;
string element;
integer enum =0;
object oSV = dom.GetObject(ID_SYSTEM_VARIABLES);

string n;
string svIDs = oSV.EnumIDs();
foreach(n,svIDs){object o=dom.GetObject(n);
   if (o.ValueType() == ivtInteger)
   {
      enum = 0;
      WriteLine("object o_" # o.Name() # " = dom.GetObject(ID_SYSTEM_VARIABLES).Get(\"" # o.Name() # "\");" );
      ListVarName = o.Name();
      foreach (element, (oSV.Get(ListVarName).ValueList()).Split(";"))
      {
         WriteLine("   integer " # element  #" = " # enum #";");
         enum = enum +1;
      }
      WriteLine("");
   }
}

Das Ergebnis sieht dann (kopierfähig in das Script) ausschnittsweise so aus:

Was noch bleibt, ist das Risiko, dass Elementenamen doppelt vorkommen können mit unterschiedlichen enum-Werten.