einen Datensatzmitgliedsnamen dynamisch zuweisen

[neumimnemecky]

Ich habe versucht, dem Beispiel in # 15 zu folgen. der Übersetzer nimmt keine Aufzeichnungen vor (Der Übersetzer nimmt den Code nicht; The compiler does not accept that). Ich probiere die Klasse aus. Fehler:

Code:

TBasicGroupSettings = record
  path: string;
  check_files_exist: boolean;
  start_name: string; // first_filename
  first: string;  // first_filename
  last: string;   // end_frame
end;
// ini.basic has some general settings too
type TBasicSettings = class
  is_scroll_vertical: boolean;
  is_image_direction_up: boolean;
  is_search_colors_HSL: boolean;
  check_files_exist_A: boolean;
  check_files_exist_B: boolean;
  RAM_disk: string;
  RAM_free: LongWord; // v MB
  A: TBasicGroupSettings;
  B: TBasicGroupSettings;
  fps: byte;
  scroll_max_shift: integer;
  property basic[G:String] TBasicGroupSettings read Get_A write Set_A;
end;

[Error] constants_ini.pas(47): ':' expected but identifier 'TBasicGroupSettings' found

Code:

property basic[G:String] TBasicGroupSettings read Get_A write Set_A;

[himitsu]

Die Hilfe ist kaputt ... bei der automatischen Übersetzung sind ein paar Zeichen verloren gegangen.

Zitat:

[Error] constants_ini.pas(47): ':' expected but identifier 'TBasicGroupSettings' found

Rate mal, was zwischen Name und Typ kommt, bzw. vor den Typ.







BasicGroupSettings = class und dann in TBasicSettings.Create die beiden Instanzen erstellen.

Und natürlich im TBasicSettings.Destroy wieder freigeben,
oder Beides als = class(TComponent) , beim Erstellen das den Owner auf Self und automatisch freigeben lassen.

Zitat:

Set_A

Als RECORD kann nur der gesamte Record zugewiesen werden.

Delphi-Quellcode:

// bei einem RECORD landet "first" nur im Result von Get_A, aber wird nicht automatisch in Set_A zurückgeschrieben.
basicsetting.basic['A'].first := 'abc';

// daher .... als CLASS gäbe es dieses Problem nicht
// eventuell vorher auslesen: temp := basicsetting.basic['A'];  
temp.first := 'abc';
basicsetting.basic['A'] := temp;

[neumimnemecky]

Dann habe ich versucht, es mit einem Array zu tun, aber dort sagt es mir inkompatible Typen hinter dem Wort write.

Code:

type TBasicSettings = class
  private
  fGroups: array[0..1] of TBasicGroupSettings;
  function getA(Index: byte): TBasicGroupSettings;
  function getB(Index: byte): TBasicGroupSettings;
  procedure setA(Index: byte; O: TBasicGroupSettings);
  procedure setB(Index: byte; O: TBasicGroupSettings);
  public
  is_scroll_vertical: boolean;  //  scroll_type=vertical
  is_image_direction_up: boolean; //  image_direction
  is_search_colors_HSL: boolean;
  check_files_exist_A: boolean;
  check_files_exist_B: boolean;
  RAM_disk: string;
  RAM_free: LongWord; // v MB
  start_name_A: string;
//  A: TBasicGroupSettings; 
//  B: TBasicGroupSettings;
  fps: byte;
  scroll_max_shift: integer;
  // property basic[G:String] TBasicGroupSettings read Get_A write Set_A;
  property A: TBasicGroupSettings Index 0 read GetA write SetA;
  property B: TBasicGroupSettings Index 1 read GetB write SetB;
end;

[Delphi.Narium]

In Delphi 7 gibt es diese Möglichkeiten noch nicht.

[neumimnemecky]

Zitat von himitsu:

Die Hilfe ist kaputt ... bei der automatischen Übersetzung sind ein paar Zeichen verloren gegangen.

Zitat:

[Error] constants_ini.pas(47): ':' expected but identifier 'TBasicGroupSettings' found

Rate mal, was zwischen Name und Typ kommt, bzw. vor den Typ.

Also wie hier (ich bevorzuge diese Quelle - das ist für mich leichter zu verstehen - weil sie die Beispiele enthält):
http://www.delphibasics.co.uk/RTL.asp?Name=Property

Code:

7.Property Name[Index : IndexType] : BaseType read Getter {default;}

Das habe ich in Beitrag 15# nicht gesehen.

Sie erklären auch das Standardwort, das mir unklar war.
"Default allows the Getter and Setter method calls to be replaced as in the following example:"

Code:

myValue := MyClass.Getter(23); 
// can be replaced by : 
myValue := MyCLass[23];

:

[himitsu]

Array-Property gingen in D7, aber Einiges davon funktioniert oftmals nur, wenn es auch als Default deklariert ist, sonst nicht.


Darum ist es in der StringList auch so

Delphi-Quellcode:

property Value[Name: String]: String ...
property ValueByIndex[Index: Integer]: String ...

weil es so nicht ging

Delphi-Quellcode:

property Value[Name: String]: String ...
property Value[Index: Integer]: String ...

seit den class-operators hatte ich mir dann so beholfen

Delphi-Quellcode:

type
  TIndexName = record
    Index: Integer;
    Name: string;
    class operator Implicit(Value: Integer): TIndexName;
    class operator Implicit(Value: String): TIndexName;
  end;

property Value[Name: TIndexName]: String ...; default;

ja, hier wäre auch Variant möglich , aber alles da oben stellt sicher, dass "nur" Integer oder String rein geht (Float, Boolean und Anderes wird direkt vom Compiler bemängelt)
property Value[Name: Variant]: String ...; default;

um sowas machen zu können

Delphi-Quellcode:

xyz.Value[123]
xyz.Value['abc']
xyz[123]
xyz['abc']

[neumimnemecky]

Also habe ich verschiedene Dinge ausprobiert, aber alles falsch ...

property A: TBasicGroupSettings Index 0 read GetA write SetA;default;
property B: TBasicGroupSettings Index 1 read GetB write SetB;default;
property group[Index: byte]: TBasicGroupSettings read GetB write SetB;default;

Denn dort muss String vorhanden sein, nicht Objekt. Das Objekt, das ich manuell in den Getter- und Setter-Implementierungscode implementieren muss.

[himitsu]

Wo ist da ein "String"?

Und was ist "Falsch"?


; default; gibt es ausschließlich für Array-Property.
default EineOrdinaleKonstante; , bzw. stored TrueOderFalseOderFunktion; , gibt es dagegen nur für einfache Property.


String: Meinst du sowas?

Delphi-Quellcode:

property Value[GroupABC: Char; Value: string]: string read GetValue write SetValue;

xxx.Value['A', 'start_name'] := 'abc';
xxx['A', 'start_name'] := 'abc';  // wenn mit "default"

PS:
property group[Index: Byte = 0]: TBasicGroupSettings read GetB write SetB; läßt der Compiler erstmal durch, aber dann beim Setter/Getter knallt es, weil
procedure GetB(Index: Byte = 0): TBasicGroupSettings); zwar noch geht,
es aber hier procedure SetB(Index: Byte = 0; Value: TBasicGroupSettings {= nil}); leider nicht.

[neumimnemecky]

Deklaration und Implementierung nur zu Testzwecken ist fertig. Aber das Programm hat jetzt viele Fehler im Anwendungsteil. Ich kann es also nicht als Ganzes kompilieren.

Code:

type TBasicSettings = class // the ini.basic
  private
  fGroups: array[0..1] of TBasicGroupSettings;
  function getA_(G:String): String;
  procedure setA_(G:String; V: String);
  function getA(Index: Integer): String;
  procedure setA(Index: Integer; V: String);
  function getAA(Index: Integer): String;
  procedure setAA(Index: Integer; V: String);
  public
  AA: TBasicGroupSettings;
  BB: TBasicGroupSettings;
  property basic[G:String]: String read GetA_ write SetA_;
  property A: String Index 0 read GetA write SetA;
  property B: String Index 1 read GetA write SetA;
  property group[Index: Integer]: String read GetA write SetA;default;
  constructor Create;
end;

type TSettings = record
  basic: TBasicSettings; // the ini
end;

implementation

constructor TBasicSettings.Create;
begin
end;

function TBasicSettings.getA_(G:String): String;
begin
  Result := 'test';
end;
procedure TBasicSettings.setA_(G:String; V: String);
begin
  G := V;
end;
function TBasicSettings.getA(Index: Integer): String;
begin
  Result := 'test';
end;
procedure TBasicSettings.setA(Index: Integer; V: String);
begin
  Index := 0;
end;
function TBasicSettings.getAA(Index: Integer): String;
begin
  Result := fGroups[0].path;
end;
procedure TBasicSettings.setAA(Index: Integer; V: String);
begin
  Index := 0;
end;

Jetzt ist die Frage, wie ich das Ganze modifizieren kann, damit ich den Code im Anwendungsteil ändern kann, zum Beispiel gibt es so eine Funktion:

Code:

// definition part - This must be edited to work correctly with newly created properties
procedure get_prefix_and_zeros_count(ini: TSettings; var prefix: string; var count: byte);
var i: byte;
begin
  with ini.bVal.A do
  prefix := copy(start,1,length(start)-length(ini.basic.A.first));
  i:=length(prefix);
  count := 0;
  repeat
    if prefix[i]='0' then
      inc(count);
    dec(i);
  until (prefix[i]<>'0') or (i=1);
  prefix := copy(prefix, 1, length(prefix)-count);
end;

Code:

// application part - This must be edited to work correctly with newly created properties
get_prefix_and_zeros_count(ini, ini.bVal.A.prefix, ini.bVal.A.maxZeros2Add);
get_prefix_and_zeros_count(ini, ini.bVal.B.prefix, ini.bVal.B.maxZeros2Add);

Ich persönlich denke, es wäre am besten, es so anzugehen:

Code:

get_prefix_and_zeros_count('A');
get_prefix_and_zeros_count('B');

Code:

// definition part changed
procedure get_prefix_and_zeros_count(g: string);
var count, i: byte;
begin
  // ini.bVal(g).maxZeros2Add is count of zeros
  with ini.bVal(g) do
  begin
  prefix := copy(start,1,length(start)-length(ini.basic(g).first));
  i:=length(prefix);
  count := 0;
  repeat
    if prefix[i]='0' then
      inc(count);
    dec(i);
  until (prefix[i]<>'0') or (i=1);
  ini.bVal(g, count);
  prefix := copy(prefix, 1, length(prefix)-count);
end;
end;

Aber ist eine Zuordnung auf diese Weise überhaupt möglich?

Code:

ini.bVal(g).prefix :=

Also sollte ich es nicht wiederholen, damit es so geht?

Code:

ini.bVal.A.prefix :=

Code:

ini.bVal.B.prefix :=

oder eher

Code:

ini.bVal[g].prefix :=

bVal ist Basic ähnlich, hat aber abgeleitete und berechnete Werte, während Basic die Einstellungen aus der INI-Datei hat.