LSL Wiki : key

Key

The key type is a specialized string, a unique identifier that can be used to reference objects, inventory items and agents in Second Life.

Sometimes also referred to as UUID (Universal Unique IDentifier), UID, or asset-ID, a key can be represented as a string of hexadecimal numbers in the format "00000000-0000-0000-0000-000000000000" (for example "66864f3c-e095-d9c8-058d-d6575e6ed1b8"). A key is 36 characters long when converted to a string in LSL (32 hexadecimal digits + 4 dashes).

There are 2^128 possible key combinations, yielding 340,282,366,920,938,463,463,374,607,431,768,211,456 possible keys. Because of this, there is little worry over SL running out of keys for objects, scripts, sounds, and textures.

Because a key is really just a specialized string, any string can be stored into a key variable, though it shouldn't be expected to work in a function that needs a UUID if the key variable contains "Hello". Note that keys must be explicitly typecast to strings, even though they are implicitly typecast from strings. If data needs to be typecast from any other type to a key, it must first be cast to a string.

That being said, if a UUID is not needed to be passed in a llMessageLinked call, a second string can be passed as long as it is cast as a key and then recast back to a string in the receiving link_message event.

Example:

llMessageLinked(LINK_SET, 5, "String one", (key)"String two");

This hack can be pretty useful, but keep in mind that you're relying on things that might change at any time when using it.

Note that in some cases, you don't need to explicitly state (string)keyname as you do when converting between a string and an integer, for instance. It's good coding practice to always do so, however, as many functions will not work properly unless you do.

integer isKey(key in)
{//by: Strife Onizuka
    if(in) return 2;          // key is valid AND not equal NULL_KEY; the distinction is important in some cases (return value of 2 is still evaluated as unary boolean TRUE)
    return (in == NULL_KEY);  // key is valid AND equal to NULL_KEY (return 1 or TRUE), or is not valid (return 0 or FALSE)
}

key forceKey(key in)
{//force a string or key to be a valid key assuming you want invalids to become NULL_KEY
    if(in) return in;
    return NULL_KEY;
}

Note: Some keys change under certain circumstances, while others can be trusted to NEVER change. The following Table illustrates which keys can be trusted and which may change.

Key Type	Changes?	When it changes
Agent	NO	Never Changes
Animation	NO	Never Changes
Notecard	YES	When Edited or Saved
Object	YES	Rezzed
Object (attached)	YES	Avatar object is attached to logs in or teleports
Script	YES	Any time a change or new copy is made
Sound	NO	Never Changes
Texture	NO	Never Changes

Anyone want to contribute to this table, correct mistakes, or add more Types?

Function	Purpose
`llDetectedKey`	returns the key of detected object
`llGetKey`	returns the key of the object the script is in
`llGetInventoryKey`	returns an object inventory item key
`llGetOwnerKey`	returns the key of the owner of the object who's key was passed to the function
`llGetOwner`	returns the key of the script owner
`llKey2Name`	converts a key to a name (in-sim only)

See Client Asset Keys for default assets like textures (GUI, "missing", terrain, etc), animations, sounds, etc.

Types | Client Asset Keys | Memory Usages

Ah... interesting. I see what you're doing. I was wondering if there was a way to do that. Let me try to make that just a bit faster.

**Several minutes later**

You had a few bugs in your function... But I improved upon it a bit, I think.

integer isKey(key test) 
{
    if (llStringLength(test) != 36)
        return FALSE;
        

    // Hyphenation test:
    if  (     (llGetSubString(test, 8, 8) != "-")
          ||  (llGetSubString(test, 13, 13) != "-")
          ||  (llGetSubString(test, 18, 18) != "-")
          ||  (llGetSubString(test, 23, 23) != "-"))
            return FALSE;
            
    // Remove dashes
    test = llDeleteSubString(llDeleteSubString(llDeleteSubString(llDeleteSubString((string)test, 8, 8), 12, 12), 16, 16), 20, 20);
    // Hex test
    integer i;
    for (i = 0; i < 32; i+=4) 
    {
        string char = llGetSubString(test, i, i+3 );
        if ((integer)("0x"+char) == 0 && char != "0000") 
            return FALSE;
    }
    return TRUE; // Passed all tests
}

Now it processes in 64-bit segments.

-- KeknehvPsaltery (2005-08-25 16:21:35)

I thought something like that would be a good way to speed things up, to process the string in 8-char hex strings (max int). However, if the integer typecast parser encounters something like "0xFGD", it returns 15 (I think) - it chokes on the "G" and spits out what it accumulated beforehand. The reason I had all the llGetSubStrings as seperate conditional statements was due to LSL's inability to short-circuit; all four of those llGetSubStrings are executed before the VM makes a decision.

integer i;
for (i = 0; i < 32; i+=4) 
{
    string char = llGetSubString(test, i, i+3 );
    if ((integer)("0x"+char) == 0 && char != "0000") 
        return FALSE;
}

-- ChristopherOmega (2005-08-25 21:39:30)

Oops - what I posted had some compilation errors, here's a revised version:

integer isKey(key test) {
    if (llStringLength(test) != 36)
        return FALSE;
    // Hyphenation tests:
    if (llGetSubString(test, 8, 8) != "-")
        return FALSE;
    if (llGetSubString(test, 13, 13) != "-")
        return FALSE;
    if (llGetSubString(test, 18, 18) != "-")
        return FALSE;
    if (llGetSubString(test, 23, 23) != "-")
        return FALSE;
    // Hex test:
    // Remove dashes (fixed, thanks Kek :-))
    test = llDeleteSubString(llDeleteSubString(llDeleteSubString(llDeleteSubString((string)test, 23, 23), 18, 18), 13, 13), 8, 8);
    integer i;
    for (i = 0; i < 32; ++i) {
        string char = llGetSubString(test, i, i);
        if ((integer)("0x"+char) == 0 && char != "0") {
            return FALSE;
        }
    }
    return TRUE; // Passed all tests:
}

-- ChristopherOmega (2005-11-29 22:03:46)