Elektra
0.8.12
|
Key is an essential class that encapsulates key name , value and metainfo . More...
Modules | |
Meta Info Manipulation Methods | |
Methods to do various operations on Key metainfo. | |
Name Manipulation Methods | |
Methods to do various operations on Key names. | |
Methods for Making Tests | |
Methods to do various tests on Keys. | |
Value Manipulation Methods | |
Methods to do various operations on Key values. | |
Enumerations | |
enum | keyswitch_t { KEY_NAME = 1, KEY_VALUE = 1<<1, KEY_OWNER = 1<<2, KEY_COMMENT = 1<<3, KEY_BINARY = 1<<4, KEY_UID = 1<<5, KEY_GID = 1<<6, KEY_MODE = 1<<7, KEY_ATIME = 1<<8, KEY_MTIME = 1<<9, KEY_CTIME = 1<<10, KEY_SIZE = 1<<11, KEY_DIR = 1<<14, KEY_META = 1<<15, KEY_END = 0 } |
Allows keyNew() to determine which information comes next. More... | |
Functions | |
Key * | keyNew (const char *name,...) |
A practical way to fully create a Key object in one step. | |
Key * | keyDup (const Key *source) |
Return a duplicate of a key. | |
int | keyCopy (Key *dest, const Key *source) |
Copy or Clear a key. | |
int | keyDel (Key *key) |
A destructor for Key objects. | |
int | keyClear (Key *key) |
Key Object Cleaner. | |
ssize_t | keyIncRef (Key *key) |
Increment the viability of a key object. | |
ssize_t | keyDecRef (Key *key) |
Decrement the viability of a key object. | |
ssize_t | keyGetRef (const Key *key) |
Return how many references the key has. |
Key is an essential class that encapsulates key name , value and metainfo .
To use it include:
#include <kdb.h>
Key properties are:
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.enum keyswitch_t |
Allows keyNew() to determine which information comes next.
KEY_NAME |
Flag for the key name |
KEY_VALUE |
Flag for the key data |
KEY_OWNER |
Flag for the key user domain |
KEY_COMMENT |
Flag for the key comment |
KEY_BINARY |
Flag if the key is binary |
KEY_UID |
Flag for the key UID
|
KEY_GID |
Flag for the key GID
|
KEY_MODE |
Flag for the key permissions
|
KEY_ATIME |
Flag for the key access time
|
KEY_MTIME |
Flag for the key change time
|
KEY_CTIME |
Flag for the key status change time
|
KEY_SIZE |
Flag for maximum size to limit value |
KEY_DIR |
Flag for the key directories
|
KEY_META |
Flag for meta data |
KEY_END |
Used as a parameter terminator to keyNew() |
int keyClear | ( | Key * | key | ) |
Key Object Cleaner.
Will reset all internal data.
After this call you will receive a fresh key.
The reference counter will stay unmodified.
int f (Key *k) { keyClear (k); // you have a fresh key k here keySetString (k, "value"); // the caller will get an empty key k with an value }
key | the key object to work with |
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:
void h (Key *k) { // receive key c keyCopy (k, c); // the caller will see the changed key k }
The reference counter will not be changed for both keys. Affiliation to keysets are also not affected.
The meta data will be duplicated for the destination key. So it will not take much additional space, even with lots of metadata.
When you pass a NULL-pointer as source the data of dest will be cleaned completely (except reference counter, see keyClear()) and you get a fresh dest key:
void g (Key *k) { keyCopy (k, 0); // k is now an empty and fresh key }
If you want to copy everything, except e.g. the value you can use keyCopy() too:
void j (Key *k) { size_t size = keyGetValueSize (k); char *value = malloc (size); int bstring = keyIsString (k); // receive key c memcpy (value, keyValue(k), size); keyCopy (k, c); if (bstring) keySetString (k, value); else keySetBinary (k, value, size); free (value); // the caller will see the changed key k // with the name and metadata from c (except // metadata "binary", which stayed the same) }
Restrain from coping everything yourself, because it will lead to wrong metadata and is not able to copy empty or cascading names:
void i (Key *k) { keySetName(k, keyName(c)); keySetString(k, keyString(c)); keyCopyAllMeta(k, c); // k is not a copy of c even if everything was successfully, // because it still contains meta data from k }
dest | the key which will be written to |
source | the key which should be copied or NULL to clean the destination key |
-1 | on failure when a NULL pointer was passed for dest or a dynamic property could not be written. The content will be unmodified then. |
0 | when dest was cleaned |
1 | when source was successfully copied |
ssize_t keyDecRef | ( | Key * | key | ) |
Decrement the viability of a key object.
The references will be decremented for ksPop() or successful calls of ksLookup() with the option KDB_O_POP. It will also be decremented with an following keyDel() in the case that an old key is replaced with another key with the same name.
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.
It is also save to delete a multiple referenced key, nothing will happen then and the reference counter will be returned.
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.
int f (const Key * source) { Key * dup = keyDup (source); // work with duplicate keyDel (dup); // everything related to dup is freed // and source is unchanged }
Like for a new key after keyNew() a subsequent ksAppend() makes a KeySet to take care of the lifecycle of the key.
int g (const Key * source, KeySet * ks) { Key * dup = keyDup (source); // work with duplicate ksAppendKey (ks, dup); // ksDel(ks) will also free the duplicate // source remains unchanged. }
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 initialized source Key |
ssize_t keyGetRef | ( | const Key * | key | ) |
Return how many references the key has.
The reference counting is the essential property of keys to make sure that they can be put safely into data structures. E.g. if you put a Key into a KeySet:
Key *k = keyNew("user/proper_name", KEY_END); // ref counter = 0 KeySet *ks = ksNew (1, k, KS_END); keyDel(k); // key will not be deleted, because its in the keyset ksDel(ks); // now the key will be deleted
You can even add the key to more KeySets:
Key *k = keyNew("user/proper_name", KEY_END); // ref counter 0 KeySet *ks1 = ksNew(1, k, KS_END); // ref counter of k 1 KeySet *ks2 = ksNew(1, k, KS_END); // ref counter of k 2 ksDel(ks1); // ref counter of k 1 ksDel(ks2); // k is now deleted
If you increment only by one with keyIncRef() the same as said above is valid:
Key *k = keyNew(0); // ref counter = 0 keyIncRef(k); // ref counter = 1 keyDel(k); // key will not be deleted keyDecRef(k); keyDel(k);
or use keyIncRef() more than once:
Key *k = keyNew(0); // ref counter 0 keyIncRef(k); // ref counter of key 1 keyDel (k); // has no effect keyIncRef(k); // ref counter of key 2 keyDel (k); // has no effect keyDecRef(k); // ref counter of key 1 keyDel (k); // has no effect keyDecRef(k); // ref counter is now 0 keyDel (k); // k is now deleted
The key won't be deleted by a keyDel() as long refcounter is not 0.
The references will be incremented on successful calls to ksAppendKey() or ksAppend().
For your own applications you can use keyIncRef() and keyDecRef() for reference counting, too.
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 * | name, |
... | |||
) |
A practical way to fully create a Key object in one step.
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.
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.
We can also give an empty key name and a KEY_END tag with the same effect as before:
But we can also give the key a proper name right from the start:
// Create and initialize a key with a name and nothing else Key *k=keyNew("user/some/example", KEY_END); // work with it keyDel (k);
So, keyNew() allocates memory for a key object and keyDel() cleans everything up.
keyNew() processes the given argument list even further. The Key attribute tags are the following:
keyName
is 0.Key *k=keyNew("user/tmp/ex3", KEY_FLAGS, KEY_BINARY | KEY_CASCADING_NAME, // flags KEY_SIZE, 7, // assume binary length 7 KEY_VALUE, "some data", // value that will be truncated in 7 bytes KEY_END); // end of args
// Create and initialize a key with a name and nothing else Key *k=keyNew("user/tmp/ex2", KEY_BINARY, KEY_SIZE, 4, // now the size is important KEY_VALUE, "some data", // sets the binary value ("some") KEY_END); // end of args
Key *k=keyNew("user/tmp/ex4", KEY_BINARY, // key type KEY_SIZE, 7, // assume binary length 7 KEY_VALUE, "some data", // value that will be truncated in 7 bytes KEY_COMMENT, "value is truncated", KEY_OWNER, "root", // owner (not uid) is root KEY_UID, 0, // root uid KEY_END); // end of args
name | a valid name to the key, or NULL to get a simple initialized, but really empty, object |
NULL | on malloc error or if an invalid name was passed (see keySetName()). |