cerhu > comp.lang.* > comp.lang.ada

Blady (12/05/2020, 12h02)
Bonjour,

Je crée un container issu de Ada.Finalization.Controlled pour pouvoir
conserver la propriété de tri de ses composants avec les procédures
Initialize et Adjust.

J'ai ajouté aussi les aspects Constant_Indexing et Variable_Indexing
pour pouvoir référencer un élément naturellement par son index.

type Sorted_Vector is new Ada.Finalization.Controlled with private with
Constant_Indexing => Get,
Variable_Indexing => Reference,
Iterable => (First => First, Next => Next,
Has_Element => Has_Element, Element => Get);

Par exemple sur des entiers :
I := V2 (5);
V2 (5) := -99;

Par contre lors de cette dernière modification l'élément d'index 5 prend
la valeur -99, comment faire pour que le container conserve son tri de
façon automatique ?
Ne faudrait-il pas ajouter un aspect Adjust_Indexing ?
Avec la déclaration d'une procédure appelée après la modification du
composant ayant la signature:
procedure Adjust (Self : in out Sorted_Vector; Index : Positive);

Qu'en pensez-vous ?

Merci, Pascal.
[..]
J-P. Rosen (12/05/2020, 14h26)
Le 12/05/2020 à 12:02, Blady a écrit :
> Par exemple sur des entiers :
>    I  := V2 (5);
>    V2 (5) := -99;
> Par contre lors de cette dernière modification l'élément d'index 5 prend
> la valeur -99, comment faire pour que le container conserve son tri de
> façon automatique ?
> Ne faudrait-il pas ajouter un aspect Adjust_Indexing ?
> Avec la déclaration d'une procédure appelée après la modification du
> composant ayant la signature:
>   procedure Adjust (Self : in out Sorted_Vector; Index : Positive);
> Qu'en pensez-vous ?

Boaf boaf...
Avec ton conteneur, en écrivant:
V2 (5) := -99;
I := V2 (5);
I ne vaut pas -99 ! Ca aurait de quoi surprendre...

Si c'est un tableau trié, je ne vois pas pourquoi on donnerait un index,
vu qu'il y a peu de chances qu'on insère à cet endroit. A mon avis, il
vaudrait mieux avoir une procédure Insert_Sorted (x).

En tout cas, je ne pense pas que le nombre de cas d'utilisations soit
suffisant pour justifier une modification au langage.
Blady (15/05/2020, 10h10)
Le 12/05/2020 à 14:26, J-P. Rosen a écrit :
> Le 12/05/2020 à 12:02, Blady a écrit :
> Boaf boaf...
> Avec ton conteneur, en écrivant:
> V2 (5) := -99;
> I := V2 (5);
> I ne vaut pas -99 ! Ca aurait de quoi surprendre...
> Si c'est un tableau trié, je ne vois pas pourquoi on donnerait un index,
> vu qu'il y a peu de chances qu'on insère à cet endroit. A mon avis, il
> vaudrait mieux avoir une procédure Insert_Sorted (x).
> En tout cas, je ne pense pas que le nombre de cas d'utilisations soit
> suffisant pour justifier une modification au langage.


Effectivement, l'exemple est capillotracté.
Je pourrais prendre un autre exemple sur les chaines de caractères où
l'on veut conserver une propriété comme les caractères sont toujours en
majuscule par exemple.
Là aussi autant définir Replace_Upper_Case, ok, il faut même l'inclure
par défaut dans le paquetage.
Par contre cela n'empêche pas un utilisateur du paquetage d'écrire :
S(3) := 'à';
Je pourrais aussi ne pas utiliser l'aspect Variable_Indexing mais ça va
limiter l'intérêt du paquetage.
La procédure Adjust dans Ada.Finalization a bien sa place.
Par cohérence, ne serait-il pas intéressant de définir un aspect
Adjust_Indexing ?
Pascal.
J-P. Rosen (15/05/2020, 15h15)
Le 15/05/2020 à 10:10, Blady a écrit :
> La procédure Adjust dans Ada.Finalization a bien sa place.
> Par cohérence, ne serait-il pas intéressant de définir un aspect
> Adjust_Indexing ?

Honnètement, je ne pense pas. Le principe de redéfinir l'indexation,
c'est de permettre à l'utilisateur de redéfinir le moyen de passer d'un
"index" à une variable en mémoire; ce qui se passe lors de l'affectation
n'est pas concerné.

Dans le cas où on voudrait convertir en majuscules, il suffit de faire
un tableau d'éléments contrôlés (qui, eux, gouvernent ce qui se passe au
moment de l'affectation).
Blady (15/05/2020, 17h52)
Le 15/05/2020 à 15:15, J-P. Rosen a écrit :
> Le 15/05/2020 à 10:10, Blady a écrit :
> Honnètement, je ne pense pas. Le principe de redéfinir l'indexation,
> c'est de permettre à l'utilisateur de redéfinir le moyen de passer d'un
> "index" à une variable en mémoire; ce qui se passe lors de l'affectation
> n'est pas concerné.
> Dans le cas où on voudrait convertir en majuscules, il suffit de faire
> un tableau d'éléments contrôlés (qui, eux, gouvernent ce qui se passe au
> moment de l'affectation).


En fait, je voulais obtenir un comportement assez tordu :
Les fonctions définies par l'aspect Variable_Indexing (en fait il y a
plusieurs surchargées) de mon container renvoient une référence sur un
élément temporaire puis une fois l'affectation réalisée dans cet
emplacement temporaire sa valeur est mise avec un post-traitement
(Adjust_Indexing) dans le container avec même index.

Sinon, est-ce qu'il une façon de faire cela avec Ada ?

Merci, Pascal.
J-P. Rosen (16/05/2020, 06h48)
Le 15/05/2020 à 17:52, Blady a écrit :
> En fait, je voulais obtenir un comportement assez tordu : Les
> fonctions définies par l'aspect Variable_Indexing (en fait il y a
> plusieurs surchargées) de mon container renvoient une référence sur
> un élément temporaire puis une fois l'affectation réalisée dans cet
> emplacement temporaire sa valeur est mise avec un post-traitement
> (Adjust_Indexing) dans le container avec même index.

Je n'ai pas tout compris... L'affectation a lieu bien après le calcul
d'index, donc beaucoup trop tard pour qu'un Adjust_Indexing puisse faire
quelque chose?

> Sinon, est-ce qu'il une façon de faire cela avec Ada ?

Il faudrait que tu nous expliques pourquoi tu as besoin de ça (i.e. le
quoi plutôt que le comment)
Blady (17/05/2020, 09h50)
Le 16/05/2020 à 06:48, J-P. Rosen a écrit :
> Le 15/05/2020 à 17:52, Blady a écrit :
> Je n'ai pas tout compris... L'affectation a lieu bien après le calcul
> d'index, donc beaucoup trop tard pour qu'un Adjust_Indexing puisse faire
> quelque chose?
> Il faudrait que tu nous expliques pourquoi tu as besoin de ça (i.e. le
> quoi plutôt que le comment)


Bien bien, je voudrais construire un container de caractères de taille
dynamique avec indexation et itération. Je simplifie ici un peu car
j'aimerais stocker directement des caractères encodés en UTF-8.

En simplifiant donc, j'encapsule alors le type Unbounded_String dans un
type container pour lui permettre l'indexation simple et les itérations
avec "of" (ce ne permet pas Unbounded_String ! peut être en Ada 202x ?).

7. type UXString is tagged private with
8. Constant_Indexing => Get,
9. Variable_Indexing => Reference,
10. Iterable => (First => First, Next => Next,
Has_Element => Has_Element, Element => Get);
et
23. type UXString is tagged record
24. Char : aliased Character;
25. Data : Unbounded_String;
26. end record;

Je peut alors écrire :
S1 : UXString;
....
C := S1 (3);
et
for CC of S1 loop

Mais aussi :
S1(4) := 'A';
S1(5) := 'd';
S1(6) := 'a';

Sauf que je n'ai pas accès à un pointeur sur le caractère indexé de
Data, j'utilise alors un pointeur sur un élément temporaire Char :

19. type Character_Reference (Char : not null access Character) is
limited null record with
20. Implicit_Dereference => Char;
....
42. function Reference (Source : aliased in out UXString; Index :
Positive) return Character_Reference is
43. (Char => Source.Char'Access);

Et là patatras, je n'ai rien de simple pour mettre la valeur temporaire
de Char dans Data au bon index.

Pascal.
Discussions similaires
Container ?

container

OLE Container

container à clé


Fuseau horaire GMT +2. Il est actuellement 01h09. | Privacy Policy