Re: Get_Line

["Matthew Heaney" <mheaney@on2.com>]

"Chad R. Meiners" <crmeiners@hotmail.com> wrote in message
news:apuqd0$103i$1@msunews.cl.msu.edu...
>
> Would you be happy with the following instead?
>
> type Line is private;
>
> procedure Get_Line (File : File_Type; Item : out Line);
>

You already have a resizable string type, so you'd be better off using that.
The easiest solution would be to create a child of Ada.Strings.Unbounded:

with Ada.Text_IO;
package Ada.Strings.Unbounded.Text_IO is
   procedure Get_Line (File : File_Type; Item : out Unbounded_String);
end;

> function  To_String (Item : Line) return String;

Note that this isn't terribly efficient, for the same reasons
Ada.Strings.Unbounded is inefficient.  At least GNAT has
Ada.Strings.Unbounded.Aux, which allows you to get at the internal string
directly.

In C++, I can return a reference.  Something like:

class C
{
public:
   const std::string& f() const;
//...
};

The closest thing in Ada is to use an access type:

type Line_Type is private;

type String_Access is access all String;

function To_String_Access (Line : Line_Type) return String_Access;

and then you could:

declare
   S : String renames To_String_Access (Line).all;  --no copying
begin

You could tighten the safety by being able to decorate the access type, e.g.

type String_Access (<>) is limited access all String;

which would prevent users from holding on to a copy of the access value
returned by the selector function (forcing them to do a rename, as above).

All the Charles containers use this technique, to allow in-place
manipluation of container elements.  So you typically have a pair of
functions:

   function Element (Container : Container_Type)
     return Element_Type;

   generic
     type Element_Access is access all Element_Type;
   function Generic_Element (Container : Container_Type)
     return Element_Access;

This is analogous to the iterator dereference operators:

   value_type& operator*() const;

which allows you to do this:

   int& histogram = *iter;
   ++histogram;

This kind of in-place manipulation is awkward without references.  In my
container example above, you'd have:

declare
   Histogram : Integer renames To_Access (Iterator).all;
begin
   Histogram := Histogram + 1;
end;

See the Charles page for more info:

http://home.earthlink.net/~matthewjheaney/charles/charles-vectors-unbounded.
html

http://home.earthlink.net/~matthewjheaney/charles/index.html

Matt