Elektra Projekt
|
Key construction and initialization methods. More...
Functions | |
Key * | keyNew (const char *keyName,...) |
Key * | keyDup (const Key *source) |
int | keyCopy (Key *dest, const Key *source) |
int | keyDel (Key *key) |
ssize_t | keyIncRef (Key *key) |
ssize_t | keyDecRef (Key *key) |
ssize_t | keyGetRef (const Key *key) |
Key construction and initialization methods.
To use them:
A Key is the essential class that encapsulates key name , value and metainfo . Key properties are:
Described here the methods to allocate and free the key.
int keyCopy | ( | Key * | dest, |
const Key * | source | ||
) |
Copy or Clear a key.
Most often you may prefer keyDup() which allocates a new key and returns a duplication of another key.
But when you need to copy into an existing key, e.g. because it was passed by a pointer in a function you can do so:
The reference counter will not change for the destination key. Affiliation to keysets are also not affected.
When you pass a NULL-pointer as source the data of dest will be cleaned completely and you get a fresh dest key.
dest | the key which will be written to |
source | the key which should be copied or NULL to clean the destination key |
ssize_t keyDecRef | ( | Key * | key) |
Decrement the viability of a key object.
The reference counter can't be decremented once it reached 0. In that situation nothing will happen and 0 will be returned.
key | the key object to work with |
int keyDel | ( | Key * | key) |
A destructor for Key objects.
Every key created by keyNew() must be deleted with keyDel().
It is save to delete keys which are in a keyset, the number of references will be returned then.
It is save to delete a nullpointer, -1 will be returned then.
key | the key object to delete |
Key* keyDup | ( | const Key * | source) |
Return a duplicate of a key.
Memory will be allocated as needed for dynamic properties.
The new key will not be member of any KeySet and will start with a new reference counter at 0. A subsequent keyDel() will delete the key.
Like for a new key after keyNew() a subsequent ksAppend() makes a KeySet to take care of the lifecycle of the key.
Duplication of keys should be preferred to keyNew(), because data like owner can be filled with a copy of the key instead of asking the environment. It can also be optimized in the checks, because the keyname is known to be valid.
source | has to be an initializised source Key |
ssize_t keyGetRef | ( | const Key * | key) |
Return how many references the key has.
The references will be incremented when ksAppendKey() or ksAppend() uses the key and will be decremented when ksPop() is used.
keyDup() will reset the references for dupped key.
For your own applications you can use keyIncRef() and keyDelRef() for reference counting. Keys with zero references will be deleted when using keyDel().
key | the key object to work with |
ssize_t keyIncRef | ( | Key * | key) |
Increment the viability of a key object.
This function is intended for applications using their own reference counter for key objects. With it you can increment the reference and thus avoid destruction of the object in a subsequent keyDel().
The reference counter can't be incremented once it reached SSIZE_MAX. In that situation nothing will happen and SSIZE_MAX will be returned.
key | the key object to work with |
Key* keyNew | ( | const char * | keyName, |
... | |||
) |
A practical way to fully create a Key object in one step.
This function tries to mimic the C++ way for constructors.
To just get a key object, simple do:
If you want the key object to contain a name, value, comment and other meta info read on.
Due to ABI compatibility, the Key
structure is not defined in kdb.h, only declared. So you can only declare pointers
to Keys
in your program, and allocate and free memory for them with keyNew() and keyDel() respectively. See http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html#AEN135
You can call it in many different ways depending on the attribute tags you pass as parameters. Tags are represented as the #keyswitch_t values, and tell keyNew() which Key attribute comes next.
The simplest and minimum way to use it is with no tags, only a key name:
keyNew() allocates memory for a key object and cleans everything up. After that, it processes the given argument list.
The Key attribute tags are the following:
keyswitch_t::KEY_GID
keyName
is 0.The reference counter (see keyGetRef()) will be initialized with 0, that means a subsequent call of keyDel() will delete the key. If you append the key to a keyset the reference counter will be incremented by one (see keyInc()) and the key can't be be deleted by a keyDel().
If you increment only by one with keyInc() the same as said above is valid:
If you add the key to more keySets:
or use keyInc() more than once:
they key won't be deleted by a keyDel() as long refcounter is not 0.
The key's sync bit will always be set for any call, except:
keyName | a valid name to the key, or NULL to get a simple initialized, but really empty, object |
keyName
was passed (see keySetName()).