Initialize with aggregate?

Initialize with aggregate?

[ejijott]

Hi there!

Regarding the code below, what syntax do I use to initialize tempstore
with an aggregate?
[code]
.
.
.
    type node;
    type storage is access node;
    type node is
        record
            next:  storage;       -- Pekare till nästa nod.
            item:  string(1..50); -- En textsträng
            len:   integer :=-1;  -- Längden på strängen.
            count: integer := 0;  -- Antalet förekomster av strängen
        end record;
.
.
.
        tempstore:=new Node;
        tempstore.item(1 .. Val'length):=Val;
        tempstore.len:=Val'length;
        tempstore.count:=1;
        if S /= null then
            tempstore.next:=S;
        end if;
        S:=tempstore;
[/code]

Re: Initialize with aggregate?

[Gautier Write-only]

ejijott@gmail.com:

> Regarding the code below, what syntax do I use to initialize tempstore
> with an aggregate?

The syntax is there (The Maunal, 4.8: Allocators) with examples:
  http://www.adaic.com/standards/95lrm/html/RM-4-8.html

Maybe that exmple can also help
  http://homepage.sunrise.ch/mysunrise/gdm/e3d_html/unzip__adb.htm#567_15

It should be enough to do the job, isn't it ?
______________________________________________________________ 
Gautier     --     http://www.mysunrise.ch/users/gdm/index.htm 
Ada programming -- http://www.mysunrise.ch/users/gdm/gsoft.htm

Re: Initialize with aggregate?

[Simon Wright]

ejijott@gmail.com writes:

> Regarding the code below, what syntax do I use to initialize tempstore
> with an aggregate?
> [code]
> .
> .
> .
>     type node;
>     type storage is access node;
>     type node is
>         record
>             next:  storage;       -- Pekare till n�sta nod.
>             item:  string(1..50); -- En textstr�ng
>             len:   integer :=-1;  -- L�ngden p� str�ngen.
>             count: integer := 0;  -- Antalet f�rekomster av str�ngen
>         end record;
> .
> .
> .
>         tempstore:=new Node;
>         tempstore.item(1 .. Val'length):=Val;
>         tempstore.len:=Val'length;
>         tempstore.count:=1;
>         if S /= null then
>             tempstore.next:=S;
>         end if;
>         S:=tempstore;
> [/code]

S := new Node'(Next => S,
               Item => <<a function padding Val to 50 characters>>,
               Len => Val'Length,
               Count => 1);

If S is null then it can do no harm to assign it to the new node's
Next field.

You might consider replacing Item and Len by a bounded string of
length up to 50.

Re: Initialize with aggregate?

[Robert A Duff]

ejijott@gmail.com writes:

> Hi there!
> 
> Regarding the code below, what syntax do I use to initialize tempstore
> with an aggregate?
> [code]
> .
> .
> .
>     type node;
>     type storage is access node;
>     type node is
>         record
>             next:  storage;       -- Pekare till n�sta nod.
>             item:  string(1..50); -- En textstr�ng
>             len:   integer :=-1;  -- L�ngden p� str�ngen.
>             count: integer := 0;  -- Antalet f�rekomster av str�ngen
>         end record;
> .
> .
> .
>         tempstore:=new Node;
>         tempstore.item(1 .. Val'length):=Val;
>         tempstore.len:=Val'length;
>         tempstore.count:=1;
>         if S /= null then
>             tempstore.next:=S;
>         end if;
>         S:=tempstore;
> [/code]

How about something like this:

    type node;
    type storage is access node;
    type node(len: natural) is
        record
            next:  storage;       -- Pekare till n�sta nod.
            item:  string(1..len); -- En textstr�ng
            count: integer := 0;  -- Antalet f�rekomster av str�ngen
        end record;

    tempstore:=new Node'(
            len => val'length,
            next => S,
            item => val,
            count => 1);
    S:=tempstore;

Hardwiring Item'Length to 50 isn't a good idea, and it makes the
programming harder, because you have to carefully avoid the junk
at the end.

- Bob

Re: Initialize with aggregate?

[Adam Beneschan]

Robert A Duff wrote:
> ejijott@gmail.com writes:
>
> > Hi there!
> >
> > Regarding the code below, what syntax do I use to initialize tempstore
> > with an aggregate?
> > [code]
> > .
> > .
> > .
> >     type node;
> >     type storage is access node;
> >     type node is
> >         record
> >             next:  storage;       -- Pekare till nästa nod.
> >             item:  string(1..50); -- En textsträng
> >             len:   integer :=-1;  -- Längden på strängen.
> >             count: integer := 0;  -- Antalet förekomster av strängen
> >         end record;
> > .
> > .
> > .
> >         tempstore:=new Node;
> >         tempstore.item(1 .. Val'length):=Val;
> >         tempstore.len:=Val'length;
> >         tempstore.count:=1;
> >         if S /= null then
> >             tempstore.next:=S;
> >         end if;
> >         S:=tempstore;
> > [/code]
>
> How about something like this:
>
>     type node;
>     type storage is access node;
>     type node(len: natural) is
>         record
>             next:  storage;       -- Pekare till nästa nod.
>             item:  string(1..len); -- En textsträng
>             count: integer := 0;  -- Antalet förekomster av strängen
>         end record;
>
>     tempstore:=new Node'(
>             len => val'length,
>             next => S,
>             item => val,
>             count => 1);
>     S:=tempstore;
>
> Hardwiring Item'Length to 50 isn't a good idea, and it makes the
> programming harder, because you have to carefully avoid the junk
> at the end.

I don't see how you can make a blanket statement like this.  If you
code it the way you've shown, you can't change "len" in a node once
you've allocated it.  But sometimes changing "item" and "len" in an
existing node to change the length of the string, without changing the
other fields in the node, is what you want to do, so there are cases
where the original poster's implementation is more appropriate than
using a discriminant record.  (Using Ada.Strings.Bounded may make
programming easier still, but you still have to hardwire a maximum
length.)

                                    -- Adam

Re: Initialize with aggregate?

[Adam Beneschan]

Simon Wright wrote:

> >     type node;
> >     type storage is access node;
> >     type node is
> >         record
> >             next:  storage;       -- Pekare till nästa nod.
> >             item:  string(1..50); -- En textsträng
> >             len:   integer :=-1;  -- Längden på strängen.
> >             count: integer := 0;  -- Antalet förekomster av strängen
> >         end record;
> > .
> > .
> > .
> >         tempstore:=new Node;
> >         tempstore.item(1 .. Val'length):=Val;
> >         tempstore.len:=Val'length;
> >         tempstore.count:=1;
> >         if S /= null then
> >             tempstore.next:=S;
> >         end if;
> >         S:=tempstore;
> > [/code]
>
> S := new Node'(Next => S,
>                Item => <<a function padding Val to 50 characters>>,
>                Len => Val'Length,
>                Count => 1);

You don't need a separate function.  This should work:

S := new Node' (Next => S,
                        Item => Val & ((Val'Length + 1) .. 50 => ' '),
                        Len => Val'Length,
                        Count => 1);

[Apologies for any spacing problems.  Google Groups' latest improvement
prevents me from using a fixed font when composing a post.]

                                         -- Adam

Re: Initialize with aggregate?

[Simon Wright]

"Adam Beneschan" <adam@irvine.com> writes:

> You don't need a separate function.  This should work:
>
> S := new Node' (Next => S,
>                         Item => Val & ((Val'Length + 1) .. 50 => ' '),
>                         Len => Val'Length,
>                         Count => 1);

Neat! (the coding, not the layout :-)

--S

Re: Initialize with aggregate?

[Robert A Duff]

"Adam Beneschan" <adam@irvine.com> writes:

> > Hardwiring Item'Length to 50 isn't a good idea, and it makes the
> > programming harder, because you have to carefully avoid the junk
> > at the end.
> 
> I don't see how you can make a blanket statement like this.

You're right.  Perhaps I should say, "Hardwiring Item'Length to 50 is
_almost_never_ a good idea."  The way I showed is fine if the string
doesn't change its length.  If it does, Strings.Unbounded is most likely
what you want.  In the unlikely event that the length changes, and "50"
is an appropriate upper-bound, Strings.Bounded is probably best, as you
mention below.

A blank-padded string is unlikely to be a good idea.

>...If you
> code it the way you've shown, you can't change "len" in a node once
> you've allocated it.  But sometimes changing "item" and "len" in an
> existing node to change the length of the string, without changing the
> other fields in the node, is what you want to do, so there are cases
> where the original poster's implementation is more appropriate than
> using a discriminant record.  (Using Ada.Strings.Bounded may make
> programming easier still, but you still have to hardwire a maximum
> length.)

- Bob