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 »

← Version précédente		Version du 9 avril 2013 à 09:19
Ligne 98 :		Ligne 98 :
	[[category:Objets itérateurs]]		[[category:Objets itérateurs]]
	[[category:Interface itération]]		[[category:Interface itération]]
	[[~~category~~:~~Tahoe~~]]		[[Category:Version650]]

Syfre le 10 février 2012 à 16:26

2012-02-10T16:26:09Z

← Version précédente		Version du 10 février 2012 à 16:26
Ligne 95 :		Ligne 95 :
	end;		end;
	</source>		</source>


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

Syfre le 10 février 2012 à 13:22

2012-02-10T13:22:59Z

← Version précédente		Version du 10 février 2012 à 13:22
Ligne 5 :		Ligne 5 :
	{\|class="wikitable"		{\|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;		fIndex: Integer;
	//IscrEnumerator		//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;		end;

	procedure ProcessusB.~~Open~~;		procedure ProcessusB.iteOpen;
	begin		begin
	fIndex := -1;		fIndex := -1;
	end;		end;

	function ProcessusB.~~MoveNext~~:boolean;		function ProcessusB.iteMoveNext:boolean;
	begin		begin
	if fIndex=-1 then		if fIndex=-1 then
Ligne 56 :		Ligne 56 :
	end;		end;

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

	function ProcessusB.~~GetIndex~~:Integer;		function ProcessusB.iteGetIndex:Integer;
	begin		begin
	Result := fIndex;		Result := fIndex;

Syfre le 10 février 2012 à 09:41

2012-02-10T09:41:52Z

← Version précédente		Version du 10 février 2012 à 09:41
Ligne 6 :		Ligne 6 :
	\|-		\|-
	\|[[Open (IscrEnumerator)\|Open]]		\|[[Open (IscrEnumerator)\|Open]]
	\|procedure Open~~(iMode:TEnumeratorMode)~~;		\|procedure Open;
	\|-		\|-
	\|[[MoveNext (IscrEnumerator)\|MoveNext]]		\|[[MoveNext (IscrEnumerator)\|MoveNext]]
Ligne 31 :		Ligne 31 :
	fIndex: Integer;		fIndex: Integer;
	//IscrEnumerator		//IscrEnumerator
	procedure Open~~(iMode:TEnumeratorMode)~~;		procedure Open;
	function MoveNext:boolean;		function MoveNext:boolean;
	procedure GetCurrent(var Dest:variant);		procedure GetCurrent(var Dest:variant);
Ligne 37 :		Ligne 37 :
	end;		end;

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

Syfre le 10 février 2012 à 09:09

2012-02-10T09:09:41Z

← Version précédente		Version du 10 février 2012 à 09:09
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"		{\|class="wikitable"

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]]