Re: C array to Ada pointer to unconstrained array without copying memory

[Duncan Sands <baldrick@free.fr>]

> > Hi Robert, maybe I can explain it like this.  The data I have is on
> > the heap.  I want the array bounds on the heap as well.
>
> Then put them there!  I'll leave the details to you, since you know what
> you are trying to do.  But I'll explain what you seem to want.
>
> You have an object, in C, that you "know" the bounds of.  You want to
> write a procedure that can accept a (C) pointer to the data on the heap,
> and construct an Ada object that you can work with.  You also don't seem
> to want to move the data.  (If you are willing to do so, this all gets a
> lot easier.)
>
> Now define an Ada record type, probably in a (library) package spec,
> since you want to be able to pass objects of the type around.  The
> package will be implementing what is referred to as an abstract data
> type.  You can make the type private and put the implementation details
> in the private part of the spec, or even in the body if you really want
> to.  But easiest is to let other units see the implementation at first.

Hi Robert, thanks for your help.  Don't worry - I know all about abstract
data types.  I've been using Ada for many years now :)  I was asking
a specific GNAT dependant technical question, simply because I would
like to know (for my own satisfaction) if I can create a true unconstrained
Ada array on the heap from C data without copying.  There is such a
thing as intellectual curiosity!

All the best,

Duncan. 

> The record type will contain the bounds, and a pointer to the data.  For
> example:
>
>      type Some_Data is record
>         First, Last: Integer;
>         Data: Some_Pointer;
>         -- may be from an instantiation of Interfaces.C.Pointers.
>      end record;
>
> Now add your own access type:
>
>     type My_Pointer is access Some_Data;
>
> Next go off and write all the code that passes objects of type Some_Data
> around.  As you do so, you may want to "reach into" your data.  Resist
> the temptation, and write inquiry functions such as:
>
>     function First_Element(P: My_Pointer) return Data_Element;
>
> and put them in your package body.  You probably also want a create
> function that calls the C routine, creates an object on the heap, and
> returns a pointer.  (Notice that the data is also on the heap but it
> doesn't get moved around.  The object you create only contains the bounds.)
>
> It sounds like a lot of work, and it will be for you at first.  But when
> you get used to it, this is a very useful design pattern in Ada.  Of
> course, if you didn't insist on putting the data on the heap, you could
> just pass objects of type Some_Data around.  In Ada you will soon find
> that this is easier than creating access types all over the place.