Classe itérateur - Historique des versions

Syfre : Remplacement du texte — « category:Tahoe » par « Category:Version650 »

2013-04-09T09:19:54Z

Remplacement du texte — « category:Tahoe » par « Category:Version650 »

Syfre le 10 février 2012 à 16:26

2012-02-10T16:26:09Z

Syfre le 10 février 2012 à 13:22

2012-02-10T13:22:59Z

Syfre le 10 février 2012 à 09:41

2012-02-10T09:41:52Z

Syfre le 10 février 2012 à 09:09

2012-02-10T09:09:41Z

Syfre : Page créée avec « Une classe métier utilisée comme itérateur dans une instruction ForEach doit supportée une interface technique d'itération. Cette interface est défini par le support d… »

2012-02-10T09:08:19Z

Page créée avec « Une classe métier utilisée comme itérateur dans une instruction ForEach doit supportée une interface technique d'itération. Cette interface est défini par le support d… »

Nouvelle page

Une classe métier utilisée comme itérateur dans une instruction ForEach doit supportée une interface technique d'itération.

Cette interface est défini par le support des quatres méthodes suivantes :

{|class="wikitable"
|-
|[[Open (IscrEnumerator)|Open]]
|procedure Open(iMode:TEnumeratorMode);
|-
|[[MoveNext (IscrEnumerator)|MoveNext]]
|function MoveNext:boolean;
|-
|[[GetCurrent (IscrEnumerator)|GetCurrent]]
|procedure GetCurrent(var Dest:variant);
|-
|[[GetIndex (IscrEnumerator)|GetIndex]]
|function GetIndex:Integer;
|}

{{tip|Le support de l'interface est testé à l'exécution et pas à la compilation}}

'''Exemple:'''

Dans cet exemple la classe ProcessusB supporte l'interface itérateur :

<source lang="delphi">

Type
ProcessusB = class
fCursor : Cursor;
fIndex: Integer;
//IscrEnumerator
procedure Open(iMode:TEnumeratorMode);
function MoveNext:boolean;
procedure GetCurrent(var Dest:variant);
function GetIndex:Integer;
end;

procedure ProcessusB.Open(iMode:TEnumeratorMode);
begin
fIndex := -1;
end;

function ProcessusB.MoveNext:boolean;
begin
if fIndex=-1 then
begin
fCursor.ClassName := 'ClassC';
fCursor.Open;
end
else fCursor.Next;
Result := not fCursor.Eoi;
if not Result
then fCursor.Close
else fIndex := fIndex+1;
end;

procedure ProcessusB.GetCurrent(var Dest:variant);
begin
Dest := fCursor.Instance;
end;

function ProcessusB.GetIndex:Integer;
begin
Result := fIndex;
end;
</source>

Ce processus est utilisé par un autre processus comme itérateur :

<source lang="delphi">
Type
ProcessusA = class
procedure doProcess(inst:ClassC);
function TestForEach:Integer;
end;

procedure ProcessusA.doProcess(inst:ClassC);
begin
withP transaction do
begin
inst.unEntierC := inst.unEntierC+1;
end;
end;

function ProcessusA.TestForEach:Integer;
var iterator:ProcessusB; inst:ClassC; count:Integer;
begin
iterator := ProcessusB.Create;
foreach inst in iterator index count do
begin
doProcess(inst);
end;
Result := 1+count;
end;
</source>

[[category:Objets itérateurs]]
[[category:Tahoe]]

@@ Ligne 98 : / Ligne 98 : @@
 [[category:Objets itérateurs]]
 [[category:Interface itération]]
-[[category:Tahoe]]
+[[Category:Version650]]

@@ Ligne 5 : / Ligne 5 : @@
 {|class="wikitable"
 |-
-|[[Open (IscrEnumerator)|Open]]
+|[[iteOpen (IscrEnumerator)|iteOpen]]
-|procedure Open;
+|procedure iteOpen;
 |-
-|[[MoveNext (IscrEnumerator)|MoveNext]]
+|[[iteMoveNext (IscrEnumerator)|iteMoveNext]]
-|function MoveNext:boolean;
+|function iteMoveNext:boolean;
 |-
-|[[GetCurrent (IscrEnumerator)|GetCurrent]]
+|[[iteGetCurrent (IscrEnumerator)|iteGetCurrent]]
-|procedure GetCurrent(var Dest:variant);
+|procedure iteGetCurrent(var Dest:variant);
 |-
-|[[GetIndex (IscrEnumerator)|GetIndex]]
+|[[iteGetIndex (IscrEnumerator)|iteGetIndex]]
-|function GetIndex:Integer;
+|function iteGetIndex:Integer;
 |}
@@ Ligne 31 : / Ligne 31 : @@
     fIndex: Integer;
     //IscrEnumerator
-    procedure Open;
+    procedure iteOpen;
-    function MoveNext:boolean;
+    function iteMoveNext:boolean;
-    procedure GetCurrent(var Dest:variant);
+    procedure iteGetCurrent(var Dest:variant);
-    function GetIndex:Integer;
+    function iteGetIndex:Integer;
    end;
-procedure ProcessusB.Open;
+procedure ProcessusB.iteOpen;
 begin
   fIndex := -1;
 end;
-function ProcessusB.MoveNext:boolean;
+function ProcessusB.iteMoveNext:boolean;
 begin
    if fIndex=-1 then
@@ Ligne 56 : / Ligne 56 : @@
 end;
-procedure ProcessusB.GetCurrent(var Dest:variant);
+procedure ProcessusB.iteGetCurrent(var Dest:variant);
 begin
    Dest := fCursor.Instance;
 end;
-function ProcessusB.GetIndex:Integer;
+function ProcessusB.iteGetIndex:Integer;
 begin
    Result := fIndex;

@@ Ligne 1 : / Ligne 1 : @@
-Une classe métier utilisée comme itérateur dans une instruction ForEach doit supportée une interface technique d'itération.
+Une classe métier peut être utilisée comme itérateur dans une instruction ForEach à condition de supporter une interface technique d'itération.
-Cette interface est défini par le support des quatres méthodes suivantes :
+Cette interface est définie par les quatre méthodes suivantes :
 {|class="wikitable"