Interface d’un type de donnée : Représentation vs Interprétation : Ada

Auteur	Message
Hibou Administrateur	Discussion ouverte sur le cas concret d’une adresse IP. La représentation est une liste ou tableau de 4 octets de 8 bits chacun. L’interprétation, si on pense aux masques CIDR (Classless InterDomain Routing), est un entier de 32 bits (4 * 8 bits). L’interface du type de donnée devrait‑elle correspondre à la représentation ou à l’interprétation ? C’est finalement une colle. Le représentation correspond naturellement à une interface standard, mais rend dans le cas présent, le type de donnée moins abstrait peut‑être (voir plus loin pourquoi). L’interprétation est plus adaptée au traitement, mais offre une interface peu naturelle est moins standard. Exemple concret de l’un et de l’autre, en supposant d’abord définies les caractéristiques d’une adresse IP par les constantes et types suivants : Octet dans le contexte du protocole IP : Source Ada : package `IPv4`.`Byte` is `Number_Of_Bits` : constant := 8; type `Instance_Type` is mod 2 `*` `Number_Of_Bits`; end; Spécification temporairement partielle pour l’adresse IP : Source Ada : with* `IPv4`.`Byte`; package `IPv4`.`Address` is `Number_Of_Bytes` : constant := 4; `Number_Of_Bits` : constant := `Number_Of_Bytes` `` `Byte`.`Number_Of_Bits`; end; En se basant sur la représentation, on peut définir l’adresse IP comme suit : Source Ada : subtype* `Byte_Type` is `Byte`.`Instance_Type`; type `Index_Type` is range 1 .. `Number_Of_Bytes`; type `Instance_Type` is array (`Index_Type`) of `Byte_Type`; En se basant cette fois sur l’interprétation, on pourrait la définir comme suit : Source Ada : type `Instance_Type` is mod 2 `*` `Number_Of_Bits`; On peut évidement ajouter une fonction au premier exemple : Source Ada : function* `Representation` (`Instance` : `Instance_Type`) return `Representation_Type`; … ou ajouter une fonction au second example : Source Ada : function `Interpretation` (`Instance` : `Instance_Type`) return `Interpretation_Type`; Ceci supposant que Representation_Type et Interpretation_Type sont définis quelque part. En résumé, deux possibilités. Interface basée sur la représentation avec une fonction donnant l’interprétation. Interface basée sur l’interprétation avec une fonction donnant la représentation. Les deux solutions sont‑elles équivalentes ? L’une est‑elle plus légitime et plus propre que l’autre ? Mais. Il existe une troisième voie, celle d’un type de donnée purement abstrait, avec une fonction pour la représentation et une fonction pour l’interprétation. Source Ada : type `Instance_Type` is private; type `Representation_Type` is array (`Index_Type`) of `Byte_Type`; type `Interpretation_Type` is mod 2 `*` `Number_Of_Bits`; function* `Representation` (`Instance` : `Instance_Type`) return `Representation_Type`; function `Interpretation` (`Instance` : `Instance_Type`) return `Interpretation_Type`; Mais il faut alors définir un constructeur pour Instance_Type. Il pourrait être basé au choix… …sur la représentation Source Ada : function `Create` (`Representation` : `Representation_Type`) return `Instance_Type`; … ou sur l’interprétation Source Ada : function `Create` (`Interpretation` : `Interpretation_Type`) return `Instance_Type`; … ou encore les deux Est‑ce celle‑ci la solution la plus propre et la mieux formalisée ? L’exemple repose sur le cas concret d’une adresse IP, mais représente bien la question générale. Personnellement, je trouve que la solution basée sur un type abstrait totalement opaque est la meilleure, mais ça m’emballerait bien d’avoir des opinions divergentes et de les peser. Bien sûr, la question ne se pose pas pour tous les types de donnée, seulement pour ceux avec lesquels l’usage fait que leur représentation est autant présente dans les faits, que leur interprétation. Avec la plupart des types de données, la représentation s’efface devant l’interprétation. Il existe cependant des exceptions, dont l’adresse IP est un exemple. En connaissez‑vous d’autres exemples ? Si oui, ne vous privez pas de les partager ici .

Auteur

Message

Administrateur

Discussion ouverte sur le cas concret d’une adresse IP.

La représentation est une liste ou tableau de 4 octets de 8 bits chacun. L’interprétation, si on pense aux masques CIDR (Classless InterDomain Routing), est un entier de 32 bits (4 * 8 bits).

L’interface du type de donnée devrait‑elle correspondre à la représentation ou à l’interprétation ? C’est finalement une colle.

Le représentation correspond naturellement à une interface standard, mais rend dans le cas présent, le type de donnée moins abstrait peut‑être (voir plus loin pourquoi). L’interprétation est plus adaptée au traitement, mais offre une interface peu naturelle est moins standard.

Exemple concret de l’un et de l’autre, en supposant d’abord définies les caractéristiques d’une adresse IP par les constantes et types suivants :

Octet dans le contexte du protocole IP :

Source Ada :

package IPv4.Byte is
   Number_Of_Bits : constant := 8;
   type Instance_Type is mod 2 ** Number_Of_Bits;
end;

Spécification temporairement partielle pour l’adresse IP :

Source Ada :

with IPv4.Byte;

package IPv4.Address is
   Number_Of_Bytes : constant := 4;
   Number_Of_Bits : constant := Number_Of_Bytes * Byte.Number_Of_Bits;
end;

En se basant sur la représentation, on peut définir l’adresse IP comme suit :

Source Ada :

subtype Byte_Type is Byte.Instance_Type;
type Index_Type is range 1 .. Number_Of_Bytes;
type Instance_Type is array (Index_Type) of Byte_Type;

En se basant cette fois sur l’interprétation, on pourrait la définir comme suit :

Source Ada :

type Instance_Type is mod 2 ** Number_Of_Bits;

On peut évidement ajouter une fonction au premier exemple :

Source Ada :

function Representation (Instance : Instance_Type) return Representation_Type;

… ou ajouter une fonction au second example :

Source Ada :

function Interpretation (Instance : Instance_Type) return Interpretation_Type;

Ceci supposant que Representation_Type et Interpretation_Type sont définis quelque part.

En résumé, deux possibilités.

Interface basée sur la représentation avec une fonction donnant l’interprétation.
Interface basée sur l’interprétation avec une fonction donnant la représentation.

Les deux solutions sont‑elles équivalentes ? L’une est‑elle plus légitime et plus propre que l’autre ?

Mais.

Il existe une troisième voie, celle d’un type de donnée purement abstrait, avec une fonction pour la représentation et une fonction pour l’interprétation.

Source Ada :

type Instance_Type is private;
type Representation_Type is array (Index_Type) of Byte_Type;
type Interpretation_Type is mod 2 ** Number_Of_Bits;

function Representation
  (Instance : Instance_Type)
   return Representation_Type;

function Interpretation
  (Instance : Instance_Type)
   return Interpretation_Type;

Mais il faut alors définir un constructeur pour Instance_Type. Il pourrait être basé au choix…

…sur la représentation

Source Ada :

function Create
  (Representation : Representation_Type) 
   return Instance_Type;

… ou sur l’interprétation

Source Ada :

function Create
  (Interpretation : Interpretation_Type) 
   return Instance_Type;

… ou encore les deux Clin d’œil

Est‑ce celle‑ci la solution la plus propre et la mieux formalisée ?

L’exemple repose sur le cas concret d’une adresse IP, mais représente bien la question générale.

Personnellement, je trouve que la solution basée sur un type abstrait totalement opaque est la meilleure, mais ça m’emballerait bien d’avoir des opinions divergentes et de les peser.

Bien sûr, la question ne se pose pas pour tous les types de donnée, seulement pour ceux avec lesquels l’usage fait que leur représentation est autant présente dans les faits, que leur interprétation. Avec la plupart des types de données, la représentation s’efface devant l’interprétation. Il existe cependant des exceptions, dont l’adresse IP est un exemple. En connaissez‑vous d’autres exemples ? Si oui, ne vous privez pas de les partager ici Sourire doux

Règles du forum

Interface d’un type de donnée : Représentation vs Interprétation

Source Ada :

Source Ada :

Source Ada :

Source Ada :

Source Ada :

Source Ada :

Source Ada :

Source Ada :

Source Ada :