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

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

"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.