Discussion :

[Tchaill39]

Bonjour à tous

Juste une petite question qui va peut être vous paraitre idiote, mais bon, qui n'apprend pas, ne progresse pas !!!!
Peux-on dans Delphi faire un overload d'une propriété ? ex :

Property F[index : Integer] : real read Get_Valeur write Set_Valeur;overload;

Property F[index : Integer ; Nodent : integer] : real read Get_Valeur_Nodent write Set_Valeur_Nodent;overload;

[ShaiLeTroll]

Tu ne peux pas faire d'overload, mais plus une sorte d'override ...

dans une classe A, tu peux avoir la propriété Tata, et dans la Classe B, qui hérite de A, tu peux redéclarer la propriété Tata avec d'autres accesseurs, et tu ne peux accéder à Tata avec les accesseurs de A, avec inherited

je "surcharge" l'Items de la TList par ceux de la TCraftDataList ...

Ton besoin ressemble plus à Items et State à la limite, ils faut deux nom, et des accesseurs différents vu les indices différents ...

exemple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// Les Structures suivantes ne peuvent pas être utilisé dans un Parçage par Transtypage de Zone Mémoire
type
  TCraftParserState = (cpsNone, cpsParsed, cpsUsed, cpsToPack, cpsPacked);
  TCraftData = Pointer;
  PCraftEnveloppe = ^TCraftEnveloppe;
  TCraftEnveloppe = record
    DataType: TEnumCraftDataType; // TOleEnumCraftDataType ne Limite pas l'Enumération aux seules constantes, vérification de l'étendue Manuelle
    DataHeader: String; // Contient l'Entete, Craft_HEADER_*
    DataRaw: String; // Contient la Chaine tel que reçu
    Data: TCraftData; // Contient une Structure PCraftPatient, PCraftSejour, ...
    DataList: TStringList; // sous forme de Liste de Chaine
    State: TCraftParserState;
  end;
 
  // Classe Listant les Données d'un Buffer décomposé
  TCraftDataList = class(TList)
  protected
    function GetItem(Index: Integer): TCraftEnveloppe;
    function GetState(Index: Integer): TCraftParserState;
    procedure SetState(Index: Integer; State: TCraftParserState);
  public
    function Add(const CraftEnveloppe: TCraftEnveloppe): Integer;
    procedure Clear; override;
    procedure Delete(Index: Integer);
    procedure Insert(Index: Integer; const CraftEnveloppe: TCraftEnveloppe);
    function First: TCraftEnveloppe;
    function Last: TCraftEnveloppe;
    // Propriétés
    property Items[Index: Integer]: TCraftEnveloppe read GetItem; default;
    property State[Index: Integer]: TCraftParserState read GetState write SetState;
  end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// TCraftDataList ---------------------------------------------------------------
//                                                                             -
//                    TCraftDataList - Protected                                -
//                                                                             -
// TCraftDataList ---------------------------------------------------------------
 
// TCraftDataList - Protected ---------------------------------------------------
function TCraftDataList.GetItem(Index: Integer): TCraftEnveloppe;
begin
     // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
     Result := TCraftEnveloppe(inherited Items[Index]^);
end;
 
// TCraftDataList - Protected ---------------------------------------------------
function TCraftDataList.GetState(Index: Integer): TCraftParserState;
begin
     // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
     Result := TCraftEnveloppe(inherited Items[Index]^).State;
end;
 
// TCraftDataList - Protected ---------------------------------------------------
procedure TCraftDataList. SetState(Index: Integer; State: TCraftParserState);
begin
     // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
     TCraftEnveloppe(inherited Items[Index]^).State := State;
end;
 
 
// TCraftDataList ---------------------------------------------------------------
//                                                                             -
//                     TCraftDataList - Public                                  -
//                                                                             -
// TCraftDataList ---------------------------------------------------------------
 
// TCraftDataList - Public ------------------------------------------------------
function TCraftDataList.Add(const CraftEnveloppe: TCraftEnveloppe): Integer;
var
   TmpCraftEnveloppe: PCraftEnveloppe;
begin
     New(TmpCraftEnveloppe);
     TmpCraftEnveloppe^.DataType   := CraftEnveloppe.DataType;
     TmpCraftEnveloppe^.DataHeader := CraftEnveloppe.DataHeader;
     TmpCraftEnveloppe^.Data       := CraftEnveloppe.Data;
     TmpCraftEnveloppe^.DataRaw    := CraftEnveloppe.DataRaw;
     TmpCraftEnveloppe^.DataList   := CraftEnveloppe.DataList;
 
     Result := inherited Add(TmpCraftEnveloppe);
end;
 
// TCraftDataList - Public ------------------------------------------------------
procedure TCraftDataList.Clear;
var
   Index: Integer;
begin
     for Index := Count - 1 downto 0 do begin
         if Assigned(inherited Items[Index]) then begin
            if Assigned(TCraftEnveloppe(inherited Items[Index]^).Data) then begin
               Dispose(TCraftEnveloppe( inherited Items[Index]^).Data);
            end;
            if Assigned(TCraftEnveloppe(inherited Items[Index]^).DataList) then begin
               TCraftEnveloppe(inherited Items[Index]^).DataList.Free();
               TCraftEnveloppe(inherited Items[Index]^).DataList := nil;
            end;
            Dispose(inherited Items[Index]);
         end;
     end;
 
     inherited Clear();
end;
 
// TCraftDataList - Public ------------------------------------------------------
procedure TCraftDataList.Delete(Index: Integer);
begin
     Dispose(TCraftEnveloppe(inherited Items[Index]^).Data);
     Dispose(inherited Items[Index]);
 
     inherited Delete(Index);
end;
 
// TCraftDataList - Public ------------------------------------------------------
procedure TCraftDataList.Insert(Index: Integer; const CraftEnveloppe: TCraftEnveloppe);
var
   TmpCraftEnveloppe: PCraftEnveloppe;
begin
     New(TmpCraftEnveloppe);
     TmpCraftEnveloppe^.DataType   := CraftEnveloppe.DataType;
     TmpCraftEnveloppe^.DataHeader := CraftEnveloppe.DataHeader;
     TmpCraftEnveloppe^.Data       := CraftEnveloppe.Data;
     TmpCraftEnveloppe^.DataRaw    := CraftEnveloppe.DataRaw;
     TmpCraftEnveloppe^.DataList   := CraftEnveloppe.DataList;
 
     inherited Insert(Index, TmpCraftEnveloppe);
end;
 
// TCraftDataList - Public ------------------------------------------------------
function TCraftDataList.First: TCraftEnveloppe;
begin
     // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
     Result := TCraftEnveloppe(inherited First^);
end;
 
// TCraftDataList - Public ------------------------------------------------------
function TCraftDataList.Last: TCraftEnveloppe;
begin
     // On veut une Structure TCraftEnveloppe, et n'ont pas un pointeur, donc déférencement (^)
     Result := TCraftEnveloppe(inherited Last()^);
end;