Type declared in record?

Type declared in record?

[Freejack]

When using Ada records, is there a way to do something like this...

	type Foo is record
		type Bar is array(1..Blah) of Positive;
		Foo1 : Natural;
		Foo2 : Natural;
		<ect...>
	end record;

I know I can achieve the same(or a similiar) effect using a tagged type.
I was just curious if the above approach is possible, if there was a type
constraint that could be placed on type Bar that would garauntee a
correct elaboration at either compile time or run-time.

Just curious.

Frejack

Re: Type declared in record?

[Marius Amado Alves]

On Tue, 2003-11-11 at 20:19, Freejack wrote:
> When using Ada records, is there a way to do something like this...
> 
> 	type Foo is record
> 		type Bar is array(1..Blah) of Positive;
> 		Foo1 : Natural;
> 		Foo2 : Natural;
> 		<ect...>
> 	end record;

This is not representative of any problem I can think of. Maybe you want
an array component, maybe a generic type, maybe something else. Please
rethink your problem and restate it.

Re: Type declared in record?

[Freejack]

On Tue, 11 Nov 2003 17:08:56 -0500, Marius Amado Alves wrote:

> On Tue, 2003-11-11 at 20:19, Freejack wrote:
> 
> This is not representative of any problem I can think of. Maybe you want
> an array component, maybe a generic type, maybe something else. Please
> rethink your problem and restate it.
 
Right now I'm working on Variant Records. For example...

generic

	type Item is private;

package storage is

	type Data_Structure is (Tree, Stack, List);
	type Store(DatConf : Data_Structure) is private;
private

	type Node_Pointer is access Store;
	
	subtype BlockSize is Positive range 1..1024;

	type Item_Array is array(BlockSize) of Item; 

	type STree is record
		Value 		: Item;
		LPointer	: Node_Pointer;
		RPointer	: Node_Pointer;
		TPointer	: Node_Pointer;	-- Could be used for Threading, or NULL. --
	end record;

	type DLinkedList is record
		Element		: Item;
		Next		: Node_Pointer;
		Prev		: Node_Pointer;
	end record; 


	type Store (DatConf : Data_Structure) is record
		
		case DatConf is 
			when Tree =>
				TreeConf : STree;
					 
			when Stack =>
				StackConf : Item_Array;
			
			when List =>
				ListConf : DLinkedList;
		end case;

	end record;


end storage;


This is all swell...but working with it would be a bit of a pain, so I'm
toying around with other ideas that might give me better results.

Freejack.

Re: Type declared in record?

[James Rogers]

Freejack <user@nospam.net> wrote in 
news:pan.2003.11.11.20.25.14.453080.936@nospam.net:

> When using Ada records, is there a way to do something like this...
> 
>      type Foo is record
>           type Bar is array(1..Blah) of Positive;
>           Foo1 : Natural;
>           Foo2 : Natural;
>           <ect...>
>      end record;
> 
> I know I can achieve the same(or a similiar) effect using a tagged type.
> I was just curious if the above approach is possible, if there was a type
> constraint that could be placed on type Bar that would garauntee a
> correct elaboration at either compile time or run-time.
>

type Bar is array(Positive range <>) of Positive;

type Foo (Blah : Positive) is record
   Bar1 : Bar(1..Blah);
   Foo1 : Natural;
   Foo2 : Natural;
   <etc...>
end record;

Jim Rogers

Re: Type declared in record?

[Dmitry A. Kazakov]

On Tue, 11 Nov 2003 22:43:15 GMT, Freejack <user@nospam.net> wrote:

>On Tue, 11 Nov 2003 17:08:56 -0500, Marius Amado Alves wrote:
>
>> On Tue, 2003-11-11 at 20:19, Freejack wrote:
>> 
>> This is not representative of any problem I can think of. Maybe you want
>> an array component, maybe a generic type, maybe something else. Please
>> rethink your problem and restate it.
> 
>Right now I'm working on Variant Records. For example...
>
>generic
>
>	type Item is private;
>
>package storage is
>
>	type Data_Structure is (Tree, Stack, List);
>	type Store(DatConf : Data_Structure) is private;
>private
>
>	type Node_Pointer is access Store;
>	
>	subtype BlockSize is Positive range 1..1024;
>
>	type Item_Array is array(BlockSize) of Item; 
>
>	type STree is record
>		Value 		: Item;
>		LPointer	: Node_Pointer;
>		RPointer	: Node_Pointer;
>		TPointer	: Node_Pointer;	-- Could be used for Threading, or NULL. --
>	end record;
>
>	type DLinkedList is record
>		Element		: Item;
>		Next		: Node_Pointer;
>		Prev		: Node_Pointer;
>	end record; 
>
>
>	type Store (DatConf : Data_Structure) is record
>		
>		case DatConf is 
>			when Tree =>
>				TreeConf : STree;
>					 
>			when Stack =>
>				StackConf : Item_Array;
>			
>			when List =>
>				ListConf : DLinkedList;
>		end case;
>
>	end record;
>
>
>end storage;
>
>
>This is all swell...but working with it would be a bit of a pain, so I'm
>toying around with other ideas that might give me better results.

Tagged types!

------------ Interface package ------------
generic
   type Item is private;
package Storage is
   type Store is
      new abstract Ada.Finalization.Limited_Controlled
         with private;
   function Get (Container : Store; ...) return Item is abstract;
   ... -- All other interface methods

private
   type Store is
      new abstract Ada.Finalization.Limited_Controlled
         with null record;
end Storage;

------------ An implementation using bounded arrays ---------
generic
   Max_Number_Of_Items : Positive;
package Storage.Bounded_Arrays is
   type Array_Store is new Store with private;
   function Get (Container : Array_Store; ...) return Item;
      -- Implements Get for Array_Store
   ...

private
   type Item_Array is
      array (Integer range 1..Max_Number_Of_Items) of Item;
   type Array_Store is new Store with record
      Size : Natural := 0;
      Data : Item_Array;
   end record;
end Storage.Bounded_Arrays;

------------ An implementation using double-linked lists ---------
....

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de