Discussion :

[AlienAttack2k]

bonjour à tous,

mon soucis du moment est que j'ai un package générique qui me vient d'une API (des listes chaînées) qui ne fait pas exactement ce que je voulais. Le problème c'est que tous les clients de cette liste utilisent déjà les méthodes Append() et autres mais le codage de cette méthode ne fait pas ce que décrit la spécification.

Du coup pour éviter de demander à tout le monde de changer leur code, je voulais faire un type dérivé du package générique en surchageant cette fameuse méthode et ainsi coder le bon comportement de façon transparente.

Voici le spec de la liste chaînée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
generic
 
   --  Type of the items contained in a list :
   type T_Item is limited private;
 
   --  Access type of the items contained in a list :
   type T_Item_Access is access all T_Item;
   -- Copy procedure for Items 
   with procedure Copy (Destination : out T_Item; Origin : in T_Item);
   --  [The returned boolean is worth true if the two items are deeply
   --      equal, and false otherwise.]
   with function "=" (Left, Right : in T_Item) return Boolean is <>;
 
package Util.Containers.Linked_List is
 
   pragma Preelaborate;
 
   -- Linked_List type and access :
   -- Use 0 as Static_Size for a dynamic allocation (allocation at
   -- initialization), greater than 0 for a static allocation.
   type T_Linked_List (Static_Size : Lang.Primitifs.T_Nat) is new
     Lang.Object.T_Object with private;
   type T_Linked_List_Access is access all T_Linked_List;
 
 
procedure Insert
     (This     : in out T_Linked_List;
      Iterator : in T_Iterator;
      Item     : in T_Item);
 
procedure Remove (This : in out T_Linked_List; Iterator : in T_Iterator);
 
function Ref (It : in T_Iterator) return T_Item_Access;
 
private
 
   -- Super class
   package Super renames Lang.Object;
   subtype T_Super is Super.T_Object;
 
   type T_Linked_List (Static_Size : Lang.Primitifs.T_Nat) is new T_Super with
      record
         Pool  : Elem_Pool.T_Data_Pool (Static_Size => Static_Size);
         First : T_Elem_Access;
         Last  : T_Elem_Access;
      end record;
 
end Util.Containers.Linked_List;

Et la classe dérivée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
With Util.Containers.Linked_List;
 
--++ class My_Linked_List
generic
  with package Linked_List_Instantiation is new Util.Containers.Linked_List(<>);
  -- generic type for Items contained by the list
    type T_Item is limited private;
    type T_Item_Access is access all T_Item;
  -- copy method of one Item
    with procedure Copy (Destination : out T_Item; Origin : in T_Item);
    with function "="
         (Left, Right : in T_Item)
          return Boolean
       is <>;
 
package My_Linked_List is
 
  type T_My_Linked_List is new Linked_List_Instantiation.T_Linked_List With private;
  type T_My_Linked_List_Access is access all T_My_Linked_List;
 
end My_Linked_List;

Mais du coup j'ai une erreur à la compilation :

error: missing actual "Linked_List_Instantiation"

Qu'est-ce que je fais de travers ?

PS : un petit détail, ce code est généré par Rhapsody in ADA, j'ai donc supposé qu'il était bon mais je commence à douter...
RE-PS : le code ne compile peut-être pas, j'ai élagué les lignes inutiles par soucis de clarté mais j'ai peut-être fait des coquilles.

Merci d'avance !

[AlienAttack2k]

Ah, j'ai oublié l'instanciation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package L_Instanciation is
 
  type T_L_Instanciation is tagged private;
  type T_L_Instanciation_Access is access all T_L_Instanciation;
 
  --Public Nested classes -------------------
 
  --++ class L_Instanciation::My_Linked_List
  package My_Reference_List is new My_Linked_List(
    T_Item => My_Reference_List.T_My_Reference_List,
    T_Item_Access => My_Reference.T_My_Reference_Access,
    Copy => My_Reference.Copy,
    "=" => My_Reference."="
  );

En fait ma classe dérivée est elle aussi un template mais je ne sais pas si c'est correct. J'ai vu qu'on pouvait faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
with My_Liste is new Util.Containers.Linked_List;

Mais du coup je ne sais pas comment passer les arguments