Conversions de mesures

Le moteur de conversion d'unités de mesure est implémenté dans l'unité ConvUtils ($DELPHI\source\rtl\common\ConvUtils.pas).

Tous les types d'unités de mesure sont déclarés dans des unités séparées. Delphi 6 fournit une unité qui déclare les types les plus standards : StdConvs.pas. On retrouve cette unité dans le même dossier que ConvUtils.

Sachant que :

type
  TConvFamily = type Word;
  TConvType = type Word;

Delphi définit une unité de mesure à travers deux propriétés :

• ConvType de type TconvType ;
• ConvFamily de type TconvFamily.

ConvFamily représente la famille d'unités de mesure (exemple : les distances).
ConvType représente l'unité de mesure (exemple : les mètres).

À chaque famille et unité de mesure recensée correspond un numéro unique (TConvFamily et TConvType sont de type Word…) attribué lors de la déclaration.

Qu'est-ce que le recensement et à quoi sert-il ?

Recenser une famille ou un type d'unité de mesure, c'est procéder à travers un mécanisme global, à la mémorisation des informations nécessaires à l'utilisation des ces données et de garder une référence sur ces données. En fait le recensement attribue en mémoire :

• un identifiant unique ;
• une description unique.

Et ceci à chaque famille et unité de mesure, pendant la durée d'exécution de l'application.

N'importe quelle unité, pour recenser une nouvelle famille ou unité de mesure, utilise le même mécanisme de recensement global (à condition d'insérer ConvUtils dans la clause uses). D'autres fonctions globales de ConvUtils permettent de prendre connaissance de la liste des familles et unités de mesure recensées globalement dans l'application.

Le recensement a lieu dans la section Initialization de l'unité, ici StdConvs.pas dont voici un extrait :

var
  { *************************************************************** }
  { Distance Conversion Units }
  { basic unit of measurement is meters }
  cbDistance: TConvFamily;
 
  duMicromicrons: TConvType;
  duAngstroms: TConvType;
  duMillimicrons: TConvType;
  duMicrons: TConvType;
  duMillimeters: TConvType;
  duCentimeters: TConvType;
// …
// …
initialization
  { ********************************************************************* }
  { Distance's family type }
  cbDistance := RegisterConversionFamily(SDistanceDescription);
 
  { Distance's various conversion types }
  duMicromicrons := RegisterConversionType(cbDistance, SMicromicronsDescription, 1E-12);
  duAngstroms := RegisterConversionType(cbDistance, SAngstromsDescription, 1E-10);
  duMillimicrons := RegisterConversionType(cbDistance, SMillimicronsDescription, 1E-9);
  duMicrons := RegisterConversionType(cbDistance, SMicronsDescription, 1E-6);
  duMillimeters := RegisterConversionType(cbDistance, SMillimetersDescription, 0.001);
  duCentimeters := RegisterConversionType(cbDistance, SCentimetersDescription, 0.01);
  // …
  // etc

Pour rappel, dès lors qu'une unité figure dans le projet, si elle comporte une clause Initialization, les instructions qui suivent cette clause sont exécutées dès le démarrage du programme.

La première instruction enregistre une nouvelle famille, celle des distances :

cbDistance := RegisterConversionFamily(SDistanceDescription);

Le recensement (RegisterConversionFamily) sert à attribuer un numéro à la variable cbDistance. Ce numéro sera unique parmi toutes les familles de conversion et valide durant l'exécution du programme. Comment fonctionne RegisterConversionFamily ?

function RegisterConversionFamily(const ADescription: string): TConvFamily;
var
  LFamily: TConvFamily;
begin
  GConvFamilySync.BeginWrite;
  try
    if DescriptionToConvFamily(ADescription, LFamily) then
      RaiseConversionError(SConvDuplicateFamily, [ADescription]);
 
    Inc(GLastConvFamily);
    if GLastConvFamily > Length(GConvFamilyList) - 1 then
      SetLength(GConvFamilyList, GLastConvFamily + CListGrowthDelta);
 
    Result := GLastConvFamily;
    GConvFamilyList[Result] := TConvFamilyInfo.Create(Result, ADescription);
  finally
    GConvFamilySync.EndWrite;
  end;
end;

Explications du code ci-dessus

• GConvFamilySync est une variable globale de type TMultiReadExclusiveWriteSynchronizer. Cela va permettre de protéger l'accès à la mémoire globale de façon à contraindre un accès exclusif en écriture et permettre un accès simultané en lecture. Ainsi on est certain que deux familles de conversion ne pourront obtenir le même numéro dans le cas où leur enregistrement serait exécuté à partir d'une application multithread. On indique à GConvFamilySync que l'ont souhaite accéder à la mémoire en écriture en appelant sa méthode BeginWrite.
• La fonction DescriptionToConvFamily vérifie qu'il n'existe pas déjà de famille portant la même description.
• Le dernier numéro attribué est incrémenté et la taille du tableau dynamique qui stocke la liste des familles est ajusté.
• Le résultat est affecté à Result, résultat du retour de fonction.
• Le tableau dynamique GConvFamily[] est un tableau d'objets de type TConvFamilyInfo.

TConvFamillyInfo - objet représentant une famille de conversions - est instancié avec pour paramètres : le numéro attribué à la famille et sa description.

• On indique à GConvFamilySync que l'on a fini d'écrire dans la mémoire globale en appelant sa méthode EndWrite.

Une fois que la famille de conversion est recensée, le recensement des unités de mesure de cette famille débute :

duMicromicrons := RegisterConversionType(cbDistance, SMicromicronsDescription, 1E-12);

Le principe général est le même que pour les familles. Cependant, RegisterConversionType est une fonction redéclarée (directive overload) trois fois avec des paramètres différents pour chaque version :

function RegisterConversionType(const AFamily: TConvFamily;  const ADescription: string; const AFactor: Double): TConvType; overload;
function RegisterConversionType(const AFamily: TConvFamily;const ADescription: string; const AToCommonProc,  AFromCommonProc: TConversionProc): TConvType; overload;
function RegisterConversionType(AConvTypeInfo: TconvTypeInfo; out AType: TConvType): Boolean; overload;

Donc selon les paramètres passés lors de l'appel à la fonction, c'est l'implémentation de telle ou telle version qui est exécutée. Dans le cas d'enregistrement de « duMicromicrons », c'est :

function RegisterConversionType(const AFamily: TConvFamily;
  const ADescription: string; const AFactor: Double): TConvType;
var
  LInfo: TConvTypeInfo;
begin
  LInfo := TConvTypeFactor.Create(AFamily, ADescription, AFactor);
  if not RegisterConversionType(LInfo, Result) then
  begin
    LInfo.Free;
    RaiseConversionRegError(AFamily, ADescription);
  end;
end;

Un objet représentant l'unité de mesure - de type TConvTypeFactor - est créé.

Il faut savoir que TConvTypeFactor hérite de TConvTypeInfo (fig. 7) et que cette classe implémente la conversion simple (cf. début du document). Nous verrons plus loin comment fonctionne cette classe lors de la conversion effective. Nous ne sommes encore que dans une phase préparatoire de déclaration et de recensement des types.

Un deuxième appel à RegisterConversionType est effectué, mais cette fois-ci avec des paramètres différents : l'objet TConvTypeFactor qui vient d'être créé et le résultat - encore vide - (paramètre de type out qui sera lu en sortie de fonction). Voici l'implémentation de cet appel RegisterConversionType(LInfo, Result) :

function RegisterConversionType(AConvTypeInfo: TConvTypeInfo;
  out AType: TConvType): Boolean;
begin
  GConvTypeSync.BeginWrite;
  try
    Result := not DescriptionToConvType(AConvTypeInfo.ConvFamily,
                                        AConvTypeInfo.Description, AType);
    if Result then
    begin
      Inc(GLastConvType);
      if GLastConvType > Length(GConvTypeList) - 1 then
        SetLength(GConvTypeList, GLastConvType + CListGrowthDelta);
      AType := GLastConvType;
      AConvTypeInfo.FConvType := AType;
      GConvTypeList[AType] := AConvTypeInfo;
    end;
  finally
    GConvTypeSync.EndWrite;
  end;
end;

On retrouve pour les unités de mesure un principe identique au recensement des familles :

• protection de la mémoire avec un TmultiReadExclusiveWriteSynchronizer ;
• vérification de non-existence de doublon de la description du type recensé ;
• mémorisation du type attribué dans un tableau dynamique dédié.

Si aucune erreur n'est rencontrée, le résultat de la fonction, de type booléen, est true. De plus, le numéro attribué au nouveau type est affecté au paramètre Atype (paramètre déclaré out).

L'appel d'origine était :

if not RegisterConversionType(LInfo, Result) then // ...

Donc Result récupère la valeur de Atype dans Result, par là même clôturant l'exécution de la fonction.

Nous allons évoquer le côté persistent du recensement, c'est dire l'identification et la sauvegarde des informations utiles aux calculs de conversion : Recensement et Persistence !

Nous avons vu que le recensement attribuait à chaque famille et unité de mesure un identifiant unique.

Ces identifiants sont valables jusqu'à la fermeture de l'application et il n'est pas garanti que lors de la prochaine exécution, les mêmes familles et unités possèdent le même identifiant (en réalité, il est possible de s'en assurer, à condition de respecter certaines règles que nous verrons plus loin).

II-D-1. Problématique▲

II-D-2. Recommandations▲

II-D-3. L'identifiant de type GUID▲

['{BF68A8A7-F026-4E4E-8C19-3F62BA406782}']

interface
   TConvUniqueTypeFactor = class(TConvTypeFactor)
  public
    GUID: TGUID;
    constructor Create(const AFamily: TConvFamily; const ADescription: string;
    AFactor: Double; AGUID: TGUID);
  end;
 
var
  uniqueType: TconvType;
  
implementation
 { TConvUniqueTypeFactor }
 
constructor TConvUniqueTypeFactor.Create(const AFamily: TConvFamily;
  const ADescription: string; AFactor: Double; AGUID: TGUID);
begin
  inherited Create(AFamily, ADescription, AFactor);
  GUID := AGUID;
end;
 
// Recensement
function RegisterConvUniqueType(const AFamily: TConvFamily;
  const ADescription: string;AFactor: Double;
  AGUID: TGUID): TConvType; overload;
var
  UniqueInfo: TConvTypeInfo;
begin
  UniqueInfo := TConvUniqueTypeFactor.Create(AFamily, ADescription,AFactor, AGUID);
  if not RegisterConversionType(UniqueInfo, Result) then
  begin
    UniqueInfo.Free;
    RaiseConversionRegError(AFamily, ADescription);
  end;
end;
 
initialization
uniqueType := RegisterConvUniqueType(cbDecathlon,'unique',1,StringtoGUID('DEBA952A-4B62-4D99-B4F2-344BC8559C83'));