UpsKrn.Hachage

Définition


/****************************************************************/

Type Hachage(TypeElement : Type) Implemente Public : ICollection(Nul Ou TypeElement) Defaut Final TailleSegment 16 ConserverObjets

/* Objet : Definition du type Hachage. */

/****************************************************************/

/*-------------------------------------------------------------*/

/* Heritage des proprietes d'Objet.  */

/*-------------------------------------------------------------*/

Prive :

	
	EstInstanceDe : Type Lecture Public;

/*-------------------------------------------------------------*/

/* Heritage des proprietes de ICollection.   					      */

/*-------------------------------------------------------------*/

Prive :


	
	NbElements : Entier Lecture Public;

/*-------------------------------------------------------------*/

/* Proprietes propres.                                         */

/*-------------------------------------------------------------*/

Prive :


	
   CalculerCle : Nul Ou Fonction(O : Nul Ou TypeElement) Retourner Entier Lecture Public;
	

   NbCles : Entier Lecture Public;

/*-------------------------------------------------------------*/

/* Heritage des methodes d'Objet.    					      */

/*-------------------------------------------------------------*/

Public :

	
	Fonction Optimiser(Invariant) Identique(O : Nul Ou Objet) Retourner Nul Ou Booleen;
	

	Procedure Convertir(O : Nul Ou Objet);
	

	Fonction Optimiser(Invariant) CreeParLeServeur() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeParLeProcessus() Retourner Entier;
	

	Fonction Optimiser(Invariant) CreeDansLEntrepot() Retourner Entrepot;
	

	Fonction Cloner(EntrepotCible : Nul Ou Entrepot=Nul, Profondeur : ModeClonage = ClonageObjetSeul) Retourner Nul Ou Objet;
	

	Fonction LirePropriete(NomPropriete : Caractere) Retourner Nul Ou Objet;
	

	Procedure EcrirePropriete(NomPropriete : Caractere, Valeur : Nul Ou Objet);
	

	Fonction IncrementerDecrementerPropriete(NomPropriete : Nul Ou Caractere, Incrementer : Booleen, Prefixe : Booleen) Retourner Nul Ou Objet;
	

	Procedure SupprimerPropriete(NomPropriete : Caractere);
	

	Fonction Optimiser(Invariant) EnumererProprietes(NumeroPropriete : Entier, TypePropriete : Nul Ou Type=? Sortie, PeutEtreNul : Booleen=? Sortie, Aide : Nul Ou Caractere=? Sortie, NomEnumere : Nul Ou Caractere=? Sortie) Retourner Nul Ou Caractere;
	

	Fonction Optimiser(Invariant) Adresse() Retourner Nul Ou Caractere;

Prive :

	
	Fonction Exporter(E : Nul Ou IEchangeElementaire) Retourner Boolean;
	

	Fonction Importer(E : Nul Ou IEchangeElementaire, EntrepotCible : Nul Ou Entrepot=Nul, EstFiltre : Booleen=Faux, V : Entier=0, R : Entier=0, C : Entier=0) Retourner Nul Ou Objet;

/*-------------------------------------------------------------*/

/* Heritage des methodes d'IIterateur.      					      */

/*-------------------------------------------------------------*/

Public :


	
	Fonction Optimiser(Invariant) ParcoursAuDebut(NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction Optimiser(Invariant) ParcoursALaFin(NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction Optimiser(Invariant) ParcoursAuMilieu(Position : Nul Ou Entier, NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction Suivant(NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction Precedent(NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction Optimiser(Invariant) PremierElement() Retourner Nul Ou TypeElement;
	

	Fonction Optimiser(Invariant) DernierElement() Retourner Nul Ou TypeElement;
	

	Fonction Optimiser NumeroElement(NumeroIterateur : Entier=0) Retourner Nul Ou Entier;
	

	Fonction Optimiser Element(NumeroIterateur : Entier=0) Retourner Nul Ou TypeElement;
	

	Fonction AllouerIterateur() Retourner Entier;
	

	Procedure LibererIterateur(NumeroIterateur : Entier);

/*-------------------------------------------------------------*/

/* Heritage des methodes de ICollection.     					      */

/*-------------------------------------------------------------*/

Public :


	
	Fonction Optimiser(Invariant, NulAbsorbant) Gauche(Taille : Nul Ou Entier) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction Optimiser(Invariant, NulAbsorbant) Droite(Taille : Nul Ou Entier) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction Optimiser(Invariant, NulAbsorbant) Milieu(Position : Nul Ou Entier, Taille : Nul Ou Entier) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction Optimiser(Invariant, NulAbsorbant) Inserer(L : Nul Ou Hachage(Nul Ou TypeElement), Position : Nul Ou Entier) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction Optimiser(Invariant) Compter(Modele : Nul Ou TypeElement, Position : Nul Ou Entier=Nul) Retourner Nul Ou Entier;
	

	Fonction Optimiser(Invariant) Rechercher(Modele : Nul Ou TypeElement, Position : Nul Ou Entier=Nul) Retourner Nul Ou Entier;
	

   Procedure HabilitationContextuelle Supprimer(NumeroIterateur : Entier=0);
	

	Procedure HabilitationContextuelle Remplacer(Remplacant : Nul Ou TypeElement, NumeroIterateur : Entier=0);
	

	Fonction Optimiser(Invariant) RemplacerTous(Modele : Nul Ou TypeElement, Remplacant : Nul Ou TypeElement, Position : Nul Ou Entier=Nul) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction Optimiser(Invariant) SupprimerTous(Modele : Nul Ou TypeElement, Position : Nul Ou Entier=Nul) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction HabilitationContextuelle AjouterAuDebut(O : Nul Ou TypeElement) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Fonction HabilitationContextuelle AjouterALaFin(O : Nul Ou TypeElement) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

   Operateur HabilitationContextuelle +(O : Nul Ou TypeElement) Retourner Nul Ou Hachage(Nul Ou TypeElement);
	

	Operateur Optimiser(Invariant) [](Position : Nul Ou Entier) Retourner Nul Ou TypeElement;
	

   Operateur [](Position : Nul Ou Entier, Valeur : Nul Ou TypeElement, MethodeAComposer : Nul Ou Fonction(P1 : Nul Ou TypeElement, P2 : Nul Ou TypeElement) Retourner Nul Ou TypeElement);
	

   Operateur [](Position : Nul Ou Entier, Prefixe : Booleen, MethodeAComposer : Nul Ou Fonction(P1 : Nul Ou TypeElement, P2 : Booleen) Retourner Nul Ou TypeElement) Retourner Nul Ou TypeElement;

/*-------------------------------------------------------------*/

/* Methodes propres.                                           */

/*-------------------------------------------------------------*/

Public :


	
   Constructeur(T: Nul Ou Type, CalculerLaCle:Nul Ou Fonction(O:Nul Ou TypeElement) Retourner Entier=Nul, NbDeCles:Entier=16);
	

   Operateur =(C: Nul Ou ICollection(Nul Ou TypeElement));

Prive :

	
   Destructeur(MettreEnAnteMemoire : Booleen) Retourner Booleen;

Fin Type

Le type Hachage modélise une table de hachage. Il permet un accès plus rapide en recherche, mise à jour et suppression par rapport au type Liste du fait de l'indexation par la clé.

Le type Hachage possède un constructeur explicite permettant de construire une table de hachage comportant une fonction CalculerLaCle calculant une clé de répartition et le nombre de clés NbDeCles servant à l'éclatement. Si CalculerLaCle est Nul, l'algorithme par défaut se base sur l'adresse de l'objet. Si la valeur de CalculerLaCle dépasse celle de NbDeCles alors un modulo est utilisé.

Le type Hachage est paramétré par le type TypeElement correspondant au type d'élément de la table de hachage.

Chaque objet du type Hachage possède des moteurs d'itérations permettant de parcourir ses éléments. Les itérateurs sont numérotés de 0 à n, 0 étant l'itérateur implicite qui n'a pas besoin d'être alloué par l'appel à AllouerIterateur. Chaque itérateur alloué, une fois utilisé, doit être libéré par l'appel LibererIterateur.

Opérateurs

Le type Hachage possède les opérateurs standards suivants:

= pour l'affectation d'une table de hachage dans une autre.
= pour l'affectation d'une collection d'élements dans la table de hachage. Le contenu de la table de hachage est alors remplacé.
== pour l'égalité entre deux tables de hachage. Le résultat est un booléen.
!= pour l'inégalité entre deux tables de hachage. Le résultat est un booléen.
+ pour ajouter à la table de hachage un objet en queue de liste de la clé.
+= pour ajouter à la table de hachage un objet en queue de liste de la clé et affecter le résultat à cette même table.
[] pour retrouver un élément d'après son numéro dans la table de hachage. Le premier élément à pour 0 et le dernier élément à pour numéro NbElements - 1. Un numéro d'index incorrect provoque l'exception CollectionIndexImpossible.

Exemple

Pour un exemple complet, merci de se référer à Hachage.

Principal /*******/ Variable /******/


	L : HachageDe Caractere;

	C : Caractere;




Debut

/* Construction d'une liste a trois éléments. */

L=HachageDe("A");

L+="B";

L+="C";

/* Parcours de cette liste. */

Pour C=L.ParcoursAuDebut() JusquA L.DernierElement() Faire

	Ecran.Ecrire(C);

Fin Pour

Fin Principal

Voir aussi

Appel, ArbreBinaire, Binaire, Caractere, Date, Entier, Entrepot, Enumere, Exception, Fichier, FileDAttente, Liste, Module, Objet, Reel, Reference, Serveur, Tableau, Travail, Type et Segment pour connaître les autres types de base.

Traduction


-	-	-	-	-	-	-	-	-