July 08, 2005
I have a function that takes a string as an argument, and returns an unique id to that string. It has to return the same id if the string is looked up twice, and the ids also have to be sequential (0,1,2..) since I use them as array indices later.

This is my current solution:
< int list[char[]];
< int current;
< int addString(char[] str)
< {
<    int *i = str in list;
<    if(i == null)
<    {  // str is not in the list, we must add it
<       list[str] = current; // Double lookup!
<       return current++;
<    }
<    return *i;
< }

Does anyone have any tips on how this could be done without double lookups? If not, I would like to propose a .add property or similar for AAs that looks up a value and adds it if it is not present. This would work exactly as AA lookups did before Walter changed it. The code then becomes

< int addString(char[] str)
< {
<    int *i = &list.add(str); // Get pointer to new or existing element
<    if(*i == 0) // Define zero to mean a 'new' string
<       *i = ++current; // Assign the id (never zero, since we pre-increase)
<    return *i;
< }

Opinions anyone?

Nick


July 08, 2005
Nick wrote:
> I have a function that takes a string as an argument, and returns an unique id
> to that string. It has to return the same id if the string is looked up twice,
> and the ids also have to be sequential (0,1,2..) since I use them as array
> indices later.
> 
> This is my current solution:
> < int list[char[]];
> < int current;
> < int addString(char[] str)
> < {
> <    int *i = str in list;
> <    if(i == null)
> <    {  // str is not in the list, we must add it
> <       list[str] = current; // Double lookup!
> <       return current++;
> <    }
> <    return *i;
> < }
> 
> Does anyone have any tips on how this could be done without double lookups? If
> not, I would like to propose a .add property or similar for AAs that looks up a
> value and adds it if it is not present. This would work exactly as AA lookups
> did before Walter changed it. The code then becomes
> 
> < int addString(char[] str)
> < {
> <    int *i = &list.add(str); // Get pointer to new or existing element
> <    if(*i == 0) // Define zero to mean a 'new' string
> <       *i = ++current; // Assign the id (never zero, since we pre-increase)
> <    return *i;
> < }
> 
> Opinions anyone?
> 
> Nick
> 
> 
I agree, add() would be nice.

I actually liked the way Walter had it before( in for checking, auto create when assigning/looking up).

Seems like weird semantics now for no real benefit.

-DavidM
July 08, 2005
"Nick" <Nick_member@pathlink.com> wrote in message news:dalsfo$1tj$1@digitaldaemon.com...
>I have a function that takes a string as an argument, and returns an unique id
> to that string. It has to return the same id if the string is looked up
> twice,
> and the ids also have to be sequential (0,1,2..) since I use them as array
> indices later.
>
> This is my current solution:
> < int list[char[]];
> < int current;
> < int addString(char[] str)
> < {
> <    int *i = str in list;
> <    if(i == null)
> <    {  // str is not in the list, we must add it
> <       list[str] = current; // Double lookup!
> <       return current++;
> <    }
> <    return *i;
> < }
>
> Does anyone have any tips on how this could be done without double
> lookups? If
> not, I would like to propose a .add property or similar for AAs that looks
> up a
> value and adds it if it is not present. This would work exactly as AA
> lookups
> did before Walter changed it. The code then becomes
>
> < int addString(char[] str)
> < {
> <    int *i = &list.add(str); // Get pointer to new or existing element
> <    if(*i == 0) // Define zero to mean a 'new' string
> <       *i = ++current; // Assign the id (never zero, since we
> pre-increase)
> <    return *i;
> < }
>
> Opinions anyone?
>
> Nick
>
>

I think it's a bug that & doesn't insert:
    int[char[]] x;
    int* p = &x["hello"];
If the idea is that x["hello"] inserts when an lvalue is expected then &
should do the same thing that x["hello"]++ does.


Top | Discussion index | About this forum | D home