Public Member Functions¶

Key ()
Constructs an empty, invalid key. Key (ckdb::Key *k)
Constructs a key out of a C key. Key (Key &k)
Takes a reference of another key. Key (Key const &k)
Takes a reference of another key. Key (const char *keyName,...)
A practical way to fully create a Key object in one step. Key (const std::string keyName,...)
A practical way to fully create a Key object in one step. Key (const char *keyName, va_list ap)
A practical way to fully create a Key object in one step. void operator++ (int) const
Increment the viability of a key object. void operator++ () const
Increment the viability of a key object. void operator-- (int) const
Decrement the viability of a key object. void operator-- () const
Decrement the viability of a key object. ssize_t getReferenceCounter () const
Return how many references the key has. Key & operator= (ckdb::Key *k)
Assign a C key. Key & operator= (const Key &k)
Assign a key. void copy (const Key &other)
Copy or Clear a key. void clear ()
Clears/Invalidates a key. Key * operator-> ()
ckdb::Key * getKey () const
Passes out the raw key pointer. ckdb::Key * operator* () const
Is a abbreviation for getKey. ckdb::Key * release ()
Passes out the raw key pointer and resets internal key handle. ckdb::Key * dup () const
Return a duplicate of a key. ~Key ()
Destructs the key. std::string getName () const
Returns a pointer to the abbreviated real internal key name. ssize_t getNameSize () const
Bytes needed to store the key name without owner. std::string getBaseName () const
Returns a pointer to the internal unescaped key name where the basename starts. ssize_t getBaseNameSize () const
Calculates number of bytes needed to store basename of key. void setName (const std::string &newName)
Set a new name to a key. void setBaseName (const std::string &baseName)
Sets a base name for a key. void addBaseName (const std::string &baseName)
Adds a base name for a key. ssize_t getFullNameSize () const
Bytes needed to store the key name including user domain and ending NULL. std::string getFullName () const
Get key full name, including the user domain name. bool operator== (const Key &k) const
Compare the name of two keys. bool operator!= (const Key &k) const
Compare the name of two keys. bool operator< (const Key &other) const
Compare the name of two keys. bool operator<= (const Key &other) const
Compare the name of two keys. bool operator> (const Key &other) const
Compare the name of two keys. bool operator>= (const Key &other) const
Compare the name of two keys. bool isNull () const
Checks if C++ wrapper has an underlying key. operator bool () const
This is for loops and lookups only. bool needSync () const
Test if a key needs to be synced to backend storage. template<class T > T get () const
Get a key value. template<class T > void set (T x)
Set a key value. std::string getString () const
void setString (std::string newString)
Set the value for key as newStringValue. ssize_t getStringSize () const
Returns the number of bytes needed to store the key value, including the NULL terminator. func_t getFunc () const
Elektra can store function pointers as binary. const void * getValue () const
Return a pointer to the real internal key value. std::string getBinary () const
Get the value of a key as a binary. ssize_t getBinarySize () const
Returns the number of bytes needed to store the key value, including the NULL terminator. ssize_t setBinary (const void *newBinary, size_t dataSize)
Set the value of a key as a binary. bool hasMeta (const std::string &metaName) const
template<class T > T getMeta (const std::string &metaName) const
Returns the Value of a Meta-Information given by name. template<class T > void setMeta (const std::string &metaName, T x)
Set metadata for key. void delMeta (const std::string &metaName)
Delete metadata for key. void copyMeta (const Key &other, const std::string &metaName)
Do a shallow copy of meta data from source to dest. void copyAllMeta (const Key &other)
Do a shallow copy of all meta data from source to dest. void rewindMeta () const
Rewind the internal iterator to first meta data. const Key nextMeta ()
Iterate to the next meta information. const Key currentMeta () const
Returns the Value of a Meta-Information which is current. bool isValid () const
std::string getNamespace () const
bool isSystem () const
Name starts with 'system'. bool isUser () const
Name starts with 'user'. bool isString () const
Check if a key is string type. bool isBinary () const
Check if a key is binary type. bool isInactive () const
Check whether a key is inactive. bool isBelow (const Key &k) const
Check if the key check is below the key key or not. bool isBelowOrSame (const Key &k) const
bool isDirectBelow (const Key &k) const
Check if the key check is direct below the key key or not.

kdb::Key::Key () [inline]¶

Constructs an empty, invalid key.

Note:

See also:

kdb::Key::Key (ckdb::Key * k) [inline]¶

Constructs a key out of a C key.

Note:

Parameters:

See also:

kdb::Key::Key (Key & k) [inline]¶

Takes a reference of another key. The key will not be copied, but the reference counter will be increased.

Parameters:

kdb::Key::Key (Key const & k) [inline]¶

Takes a reference of another key. The key will not be copied, but the reference counter will be increased.

Parameters:

kdb::Key::Key (const char * keyName, ...) [inline], [explicit]¶

A practical way to fully create a Key object in one step. To just get a key object, simple do:

Key *k = keyNew(0);
// work with it
keyDel (k);

If you want the key object to contain a name, value, comment and other meta info read on.

Note:

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:

Key *k =keyNew("", KEY_END); // Has the same effect as above
// work with it
keyDel (k);

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:

•

KEY_VALUE
Next parameter is a pointer to the value that will be used. If no KEY_BINARY was used before, a string is assumed.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex0",


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_SIZE
Define a maximum length of the value. This is only used when setting a binary key.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex1",


        KEY_SIZE, 4,               // has no effect on strings


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_META
Next two parameter is a meta name and a meta value. See keySetMeta().

Key *k=keyNew("user/tmp/ex3",


        KEY_META, "comment", "a comment",  // with a commet


        KEY_META, "owner", "root",         // and an owner


        KEY_META, "special", "yes",        // and any other meta data


        KEY_END);                  // end of args

• KEY_END
  Must be the last parameter passed to keyNew(). It is always required, unless the keyName is 0.
• ::KEY_FLAGS
  Bitwise disjunction of flags, which don't require one or more values. recommended way to set multiple flags. overrides previously defined flags.

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

•

KEY_BINARY
Allows one to change the key to a binary key. Make sure that you also pass KEY_SIZE before you set the value. Otherwise it will be cut off with first \0 in the string. So this flag toggle from keySetString() to keySetBinary(). If no value (nor size) is given, it will be a NULL key.

// 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_CASCADING_NAME allow the name to start with / useful for ksLookup() and kdbGet() parent/lookup keys
• ::KEY_META_NAME allow the name to start with arbitrary namespaces useful to compare with meta keys

Deprecated

Key *k=keyNew("user/tmp/ex3",


        KEY_VALUE, "some data",    // with a simple value


        KEY_MODE, 0777,            // permissions


        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

Parameters:

See also:

Returns:

Return values:

Exceptions:

Parameters:

kdb::Key::Key (const std::string keyName, ...) [inline], [explicit]¶

A practical way to fully create a Key object in one step. To just get a key object, simple do:

Key *k = keyNew(0);
// work with it
keyDel (k);

If you want the key object to contain a name, value, comment and other meta info read on.

Note:

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:

Key *k =keyNew("", KEY_END); // Has the same effect as above
// work with it
keyDel (k);

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:

•

KEY_VALUE
Next parameter is a pointer to the value that will be used. If no KEY_BINARY was used before, a string is assumed.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex0",


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_SIZE
Define a maximum length of the value. This is only used when setting a binary key.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex1",


        KEY_SIZE, 4,               // has no effect on strings


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_META
Next two parameter is a meta name and a meta value. See keySetMeta().

Key *k=keyNew("user/tmp/ex3",


        KEY_META, "comment", "a comment",  // with a commet


        KEY_META, "owner", "root",         // and an owner


        KEY_META, "special", "yes",        // and any other meta data


        KEY_END);                  // end of args

• KEY_END
  Must be the last parameter passed to keyNew(). It is always required, unless the keyName is 0.
• ::KEY_FLAGS
  Bitwise disjunction of flags, which don't require one or more values. recommended way to set multiple flags. overrides previously defined flags.

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

•

KEY_BINARY
Allows one to change the key to a binary key. Make sure that you also pass KEY_SIZE before you set the value. Otherwise it will be cut off with first \0 in the string. So this flag toggle from keySetString() to keySetBinary(). If no value (nor size) is given, it will be a NULL key.

// 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_CASCADING_NAME allow the name to start with / useful for ksLookup() and kdbGet() parent/lookup keys
• ::KEY_META_NAME allow the name to start with arbitrary namespaces useful to compare with meta keys

Deprecated

Key *k=keyNew("user/tmp/ex3",


        KEY_VALUE, "some data",    // with a simple value


        KEY_MODE, 0777,            // permissions


        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

Parameters:

See also:

Returns:

Return values:

Exceptions:

Warning:

Parameters:

kdb::Key::Key (const char * keyName, va_list ap) [inline], [explicit]¶

A practical way to fully create a Key object in one step. To just get a key object, simple do:

Key *k = keyNew(0);
// work with it
keyDel (k);

If you want the key object to contain a name, value, comment and other meta info read on.

Note:

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:

Key *k =keyNew("", KEY_END); // Has the same effect as above
// work with it
keyDel (k);

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:

•

KEY_VALUE
Next parameter is a pointer to the value that will be used. If no KEY_BINARY was used before, a string is assumed.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex0",


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_SIZE
Define a maximum length of the value. This is only used when setting a binary key.

// Create and initialize a key with a name and nothing else
Key *k=keyNew("user/tmp/ex1",


        KEY_SIZE, 4,               // has no effect on strings


        KEY_VALUE, "some data",    // set a string value


        KEY_END);                  // end of args

•

KEY_META
Next two parameter is a meta name and a meta value. See keySetMeta().

Key *k=keyNew("user/tmp/ex3",


        KEY_META, "comment", "a comment",  // with a commet


        KEY_META, "owner", "root",         // and an owner


        KEY_META, "special", "yes",        // and any other meta data


        KEY_END);                  // end of args

• KEY_END
  Must be the last parameter passed to keyNew(). It is always required, unless the keyName is 0.
• ::KEY_FLAGS
  Bitwise disjunction of flags, which don't require one or more values. recommended way to set multiple flags. overrides previously defined flags.

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

•

KEY_BINARY
Allows one to change the key to a binary key. Make sure that you also pass KEY_SIZE before you set the value. Otherwise it will be cut off with first \0 in the string. So this flag toggle from keySetString() to keySetBinary(). If no value (nor size) is given, it will be a NULL key.

// 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_CASCADING_NAME allow the name to start with / useful for ksLookup() and kdbGet() parent/lookup keys
• ::KEY_META_NAME allow the name to start with arbitrary namespaces useful to compare with meta keys

Deprecated

Key *k=keyNew("user/tmp/ex3",


        KEY_VALUE, "some data",    // with a simple value


        KEY_MODE, 0777,            // permissions


        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

Parameters:

See also:

Returns:

Return values:

Exceptions:

Parameters:

kdb::Key::~Key () [inline]¶

Destructs the key.

See also:

void kdb::Key::addBaseName (const std::string & baseName) [inline]¶

Adds a base name for a key. Adds baseName (that will be escaped) to the current key name. A new baseName will be added, no other part of the key name will be affected.

Assumes that key is a directory and will append baseName to it. The function adds the path separator for concatenating.

So if key has name 'system/dir1/dir2' and this method is called with baseName 'mykey', the resulting key will have the name 'system/dir1/dir2/mykey'.

When baseName is 0 nothing will happen and the size of the name is returned.

The escaping rules apply as in above .

A simple example is:

Key * k = keyNew("user/my/long", KEY_END);
keyAddBaseName(k, "myname");
printf ("%s0, keyName(k)); // will print user/my/long/myname
keyDel(k);

E.g. if you add . it will be escaped:

keySetName (k, "system/valid");
succeed_if (keyAddBaseName (k, ".") >= 0, "could not add a base name");
succeed_if_same_string(keyName(k), "system/valid/\.");
succeed_if_same_string(keyBaseName(k), ".");

See also:

Parameters:

Returns:

Return values:

Exceptions:

void kdb::Key::clear () [inline]¶

Clears/Invalidates a key. Afterwards the object is empty again.

Note:

See also:

Key Object Cleaner. Will reset all internal data.

After this call you will receive a fresh key.

The reference counter will stay unmodified.

Note:

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
}

Return values:

Parameters:

void kdb::Key::copy (const Key & other) [inline]¶

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
}

Parameters:

Return values:

See also:

void kdb::Key::copyAllMeta (const Key & other) [inline]¶

Do a shallow copy of all meta data from source to dest. The key dest will additionally have all meta data the source had. Meta data not present in source will not be changed. Meta data which was present in source and dest will be overwritten.

For example the meta data type is copied into the Key k:

void l(Key *k)
{


        // receive c


        keyCopyAllMeta(k, c);


        // the caller will see the changed key k


        // with all the metadata from c
}

The main purpose of this function is for plugins or applications which want to add the same meta data to n keys. When you do that with keySetMeta() it will take n times the memory for the key. This can be considerable amount of memory for many keys with some meta data for each.

To avoid that problem you can use keyCopyAllMeta() or keyCopyMeta():

void o(KeySet *ks)
{


        Key *current;


        Key *shared = keyNew (0);


        keySetMeta(shared, "shared1", "this meta data should be shared among many keys");


        keySetMeta(shared, "shared2", "this meta data should be shared among many keys also");


        keySetMeta(shared, "shared3", "this meta data should be shared among many keys too");


        ksRewind(ks);


        while ((current = ksNext(ks)) != 0)


        {


                if (needsSharedData(current)) keyCopyAllMeta(current, shared);


        }


        keyDel(shared);
}

Postcondition:

Return values:

Parameters:

See also:

void kdb::Key::copyMeta (const Key & other, const std::string & metaName) [inline]¶

Do a shallow copy of meta data from source to dest. The key dest will have the same meta data referred with metaName afterwards then source.

For example the meta data type is copied into the Key k.

void l(Key *k)
{


        // receive c


        keyCopyMeta(k, c, "type");


        // the caller will see the changed key k


        // with the metadata "type" from c
}

The main purpose of this function is for plugins or applications which want to add the same meta data to n keys. When you do that with keySetMeta() it will take n times the memory for the key. This can be considerable amount of memory for many keys with some meta data for each.

To avoid that problem you can use keyCopyAllMeta() or keyCopyMeta().

void o(KeySet *ks)
{


        Key *current;


        Key *shared = keyNew (0);


        keySetMeta(shared, "shared", "this meta data should be shared among many keys");


        ksRewind(ks);


        while ((current = ksNext(ks)) != 0)


        {


                if (needs_shared_data(current)) keyCopyMeta(current, shared, "shared");


        }
}

Postcondition:

Return values:

Parameters:

See also:

const Key kdb::Key::currentMeta () const [inline]¶

Returns the Value of a Meta-Information which is current. The pointer is NULL if you reached the end or after ksRewind().

Note:

Parameters:

Returns:

Return values:

See also:

Note:

k.rewindMeta();
while (meta = k.nextMeta())
{


        cout << meta.getName() << " " << meta.getString() << endl;
}

See also:

void kdb::Key::delMeta (const std::string & metaName) [inline]¶

Delete metadata for key.

See also:

ckdb::Key * kdb::Key::dup () const [inline]¶

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.

Parameters:

Return values:

Returns:

See also:

template<class T > T kdb::Key::get () const [inline]¶

Get a key value. You can write your own template specialication, e.g.:

template <>
inline QColor Key::get() const
{


        if (getStringSize() < 1)


        {


                throw KeyTypeConversion();


        }


        std::string str = getString();


        QColor c(str.c_str());


        return c;
}

Returns:

It should be the same as get().

Returns:

Exceptions:

Note:

See also:

This method tries to serialise the string to the given type.

std::string kdb::Key::getBaseName () const [inline]¶

Returns a pointer to the internal unescaped key name where the basename starts. This is a much more efficient version of keyGetBaseName() and you should use it if you are responsible enough to not mess up things. The name might change or even point to a wrong place after a keySetName(). So make sure to copy the memory before the name changes.

keyBaseName() returns '' when there is no keyBaseName. The reason is

keySetName(k,"");
succeed_if_same_string(keyBaseName(k), "");
keySetName(k,"user");
succeed_if_same_string(keyBaseName(k), "");

And there is also support for really empty basenames:

keySetName (k, "system/valid");
succeed_if (keyAddBaseName (k, "") >= 0, "could not add a base name");
succeed_if_same_string(keyName(k), "system/valid/%");
succeed_if_same_string(keyBaseName(k), "");

Note:

Parameters:

Returns:

Return values:

See also:

ssize_t kdb::Key::getBaseNameSize () const [inline]¶

Calculates number of bytes needed to store basename of key. Key names that have only root names (e.g. 'system' or 'user' or 'user:domain' ) does not have basenames, thus the function will return 1 bytes to store ''.

Basenames are denoted as:

• system/some/thing/basename -> basename
• user:domain/some/thing/base\/name > base\/name

Parameters:

Returns:

See also:

std::string kdb::Key::getBinary () const [inline]¶

Get the value of a key as a binary.

Returns:

Return values:

Note:

Exceptions:

If the type is not binary -1 will be returned.

When the binary data is empty (this is not the same as ''!) 0 will be returned and the returnedBinary will not be changed.

For string values see keyGetString() and keyIsString().

When the returnedBinary is to small to hold the data (its maximum size is given by maxSize), the returnedBinary will not be changed and -1 is returned.

Example:

Key *key = keyNew ("user/keyname", KEY_TYPE, KEY_TYPE_BINARY, KEY_END);
char buffer[300];
if (keyGetBinary(key,buffer,sizeof(buffer)) == -1)
{


        // handle error
}

Parameters:

Returns:

Return values:

See also:

ssize_t kdb::Key::getBinarySize () const [inline]¶

Returns the number of bytes needed to store the key value, including the NULL terminator. It returns the correct size, independent of the Key Type. If it is a binary there might be '\0' values in it.

For an empty string you need one byte to store the ending NULL. For that reason 1 is returned. This is not true for binary data, so there might be returned 0 too.

A binary key has no '\0' termination. String types have it, so to there length will be added 1 to have enough space to store it.

This method can be used with malloc() before keyGetString() or keyGetBinary() is called.

char *buffer;
buffer = malloc (keyGetValueSize (key));
// use this buffer to store the value (binary or string)
// pass keyGetValueSize (key) for maxSize

Parameters:

Returns:

Return values:

See also:

std::string kdb::Key::getFullName () const [inline]¶

Get key full name, including the user domain name.

Returns:

Return values:

Parameters:

Exceptions:

ssize_t kdb::Key::getFullNameSize () const [inline]¶

Bytes needed to store the key name including user domain and ending NULL.

Parameters:

Returns:

Return values:

See also:

Key::func_t kdb::Key::getFunc () const [inline]¶

Elektra can store function pointers as binary. This function returns such a function pointer.

Exceptions:

Returns:

ckdb::Key * kdb::Key::getKey () const [inline]¶

Passes out the raw key pointer. This pointer can be used to directly change the underlying key object.

Note:

template<class T > T kdb::Key::getMeta (const std::string & metaName) const [inline]¶

Returns the Value of a Meta-Information given by name. This is a much more efficient version of keyGetMeta(). But unlike with keyGetMeta you are not allowed to modify the resulting string.

int f(Key *k)
{


        if (!strcmp(keyValue(keyGetMeta(k, "type")), "boolean"))


        {


                // the type of the key is boolean


        }
}

Note:

Parameters:

Return values:

Returns:

See also:

You can specify your own template specialisation:

template<>
inline yourtype Key::getMeta(const std::string &name) const
{


        yourtype x;


        std::string str;


        str = std::string(


                static_cast<const char*>(


                        ckdb::keyValue(


                                ckdb::keyGetMeta(key, name.c_str())


                                )


                        )


                );


        return yourconversion(str);
}

Exceptions:

Note:

If no meta is available:

• char* is null (evaluates to 0)
• const Key is null (evaluate to false)
• otherwise the default constructed type will be returned

See also:

std::string kdb::Key::getName () const [inline]¶

Returns a pointer to the abbreviated real internal key name. This is a much more efficient version of keyGetName() and can use it if you are responsible enough to not mess up things. You are not allowed to change anything in the returned array. The content of that string may change after keySetName() and similar functions. If you need a copy of the name, consider using keyGetName().

The name will be without owner, see keyGetFullName() if you need the name with its owner.

Return values:

key=keyNew(0);
keySetName(key,"");
keyName(key); // you would expect "" here
keyDel(key);

Valid key names are:

• spec/something for specification of other keys.
• proc/something for in-memory keys, e.g. commandline.
• dir/something for dir keys in current working directory
• system/something for system keys in /etc or /
• user/something for user keys in home directory
• user:username/something for other users (deprecated: kdbGet() + kdbSet() currently unsupported)
• /something for cascading keys (actually refers to one of the above, see also ksLookup())

Note:

Parameters:

Returns:

Return values:

See also:

Exceptions:

Note:

ssize_t kdb::Key::getNameSize () const [inline]¶

Bytes needed to store the key name without owner. For an empty key name you need one byte to store the ending NULL. For that reason 1 is returned.

Parameters:

Returns:

Return values:

See also:

std::string kdb::Key::getNamespace () const [inline]¶

Returns:

Will return slash for cascading names.

See also:

ssize_t kdb::Key::getReferenceCounter () const [inline]¶

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().

Note:

For your own applications you can use keyIncRef() and keyDecRef() for reference counting, too.

Parameters:

Returns:

Return values:

See also:

std::string kdb::Key::getString () const [inline]¶

Returns:

It should be the same as get().

Returns:

Exceptions:

Note:

See also:

ssize_t kdb::Key::getStringSize () const [inline]¶

Returns the number of bytes needed to store the key value, including the NULL terminator. It returns the correct size, independent of the Key Type. If it is a binary there might be '\0' values in it.

For an empty string you need one byte to store the ending NULL. For that reason 1 is returned. This is not true for binary data, so there might be returned 0 too.

A binary key has no '\0' termination. String types have it, so to there length will be added 1 to have enough space to store it.

This method can be used with malloc() before keyGetString() or keyGetBinary() is called.

char *buffer;
buffer = malloc (keyGetValueSize (key));
// use this buffer to store the value (binary or string)
// pass keyGetValueSize (key) for maxSize

Parameters:

Returns:

Return values:

See also:

const void * kdb::Key::getValue () const [inline]¶

Return a pointer to the real internal key value. This is a much more efficient version of keyGetString() keyGetBinary(), and you should use it if you are responsible enough to not mess up things. You are not allowed to modify anything in the returned string. If you need a copy of the Value, consider to use keyGetString() or keyGetBinary() instead.

bool kdb::Key::hasMeta (const std::string & metaName) const [inline]¶

Return values:

See also:

bool kdb::Key::isBelow (const Key & k) const [inline]¶

Check if the key check is below the key key or not.

Parameters:

Returns:

Example:

key user/sw/app
check user/sw/app/key

returns true because check is below key

Example:

key user/sw/app
check user/sw/app/folder/key

returns also true because check is indirect below key

Obviously, there is no key above a namespace (e.g. user, system, /):

key *
check user

Parameters:

Return values:

See also:

bool kdb::Key::isBelowOrSame (const Key & k) const [inline]¶

Parameters:

Returns:

bool kdb::Key::isBinary () const [inline]¶

Check if a key is binary type. The function checks if the key is a binary. Opposed to string values binary values can have '\0' inside the value and may not be terminated by a null character. Their disadvantage is that you need to pass their size.

Make sure to use this function and don't test the binary type another way to ensure compatibility and to write less error prone programs.

Return values:

See also:

Parameters:

bool kdb::Key::isDirectBelow (const Key & k) const [inline]¶

Check if the key check is direct below the key key or not.

Parameters:

Returns:

Example:
key user/sw/app
check user/sw/app/key
returns true because check is below key
Example:
key user/sw/app
check user/sw/app/folder/key
does not return true, because there is only a indirect relation

Parameters:

Return values:

See also:

bool kdb::Key::isInactive () const [inline]¶

Check whether a key is inactive. In Elektra terminology a hierarchy of keys is inactive if the rootkey's basename starts with '.'. So a key is also inactive if it is below an inactive key. For example, user/key/.hidden is inactive and so is user/.hidden/below.

Inactive keys should not have any meaning to applications, they are only a convention reserved for users and administrators. To automatically remove all inactive keys for an application, consider to use the hidden plugin.

Parameters:

Return values:

bool kdb::Key::isNull () const [inline]¶

Checks if C++ wrapper has an underlying key.

See also:

Returns:

bool kdb::Key::isString () const [inline]¶

Check if a key is string type. String values are null terminated and are not allowed to have any '\0' characters inside the string.

Make sure to use this function and don't test the string type another way to ensure compatibility and to write less error prone programs.

Return values:

See also:

Parameters:

bool kdb::Key::isSystem () const [inline]¶

Name starts with 'system'.

Return values:

bool kdb::Key::isUser () const [inline]¶

Name starts with 'user'.

Return values:

bool kdb::Key::isValid () const [inline]¶

Returns:

An invalid key has no name. The name of valid keys either start with user or system.

Return values:

See also:

bool kdb::Key::needSync () const [inline]¶

Test if a key needs to be synced to backend storage. If any key modification took place the key will be flagged so that kdbSet() knows which keys were modified and which not.

After keyNew() the flag will normally be set, but after kdbGet() and kdbSet() the flag will be removed. When you modify the key the flag will be set again.

In your application you can make use of that flag to know if you changed something in a key after a kdbGet() or kdbSet().

Note:

Deprecated

See also:

Parameters:

Return values:

const Key kdb::Key::nextMeta () [inline]¶

Iterate to the next meta information. Keys have an internal cursor that can be reset with keyRewindMeta(). Every time keyNextMeta() is called the cursor is incremented and the new current Name of Meta Information is returned.

You'll get a NULL pointer if the meta information after the end of the Key was reached. On subsequent calls of keyNextMeta() it will still return the NULL pointer.

The key internal cursor will be changed, so it is not const.

Note:

Parameters:

Returns:

Return values:

See also:

kdb::Key::operator bool () const [inline]¶

This is for loops and lookups only. Opposite of isNull()

For loops it checks if there are still more keys. For lookups it checks if a key could be found.

Warning:

See also:

Returns:

bool kdb::Key::operator!= (const Key & k) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

ckdb::Key * kdb::Key::operator* () const [inline]¶

Is a abbreviation for getKey. Passes out the raw key pointer. This pointer can be used to directly change the underlying key object.

Note:

See also:

void kdb::Key::operator++ (int) const [inline]¶

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.

Note:

Returns:

Return values:

Parameters:

See also:

void kdb::Key::operator++ () const [inline]¶

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.

Note:

Returns:

Return values:

Parameters:

See also:

void kdb::Key::operator-- (int) const [inline]¶

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.

Note:

Returns:

Return values:

Parameters:

See also:

void kdb::Key::operator-- () const [inline]¶

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.

Note:

Returns:

Return values:

Parameters:

See also:

Key * kdb::Key::operator-> () [inline]¶

Returns:

Needed for KeySet iterators.

See also:

bool kdb::Key::operator< (const Key & other) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

bool kdb::Key::operator<= (const Key & other) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

Key & kdb::Key::operator= (ckdb::Key * k) [inline]¶

Assign a C key. Will call del() on the old key.

Key & kdb::Key::operator= (const Key & k) [inline]¶

Assign a key. Will call del() on the old key.

bool kdb::Key::operator== (const Key & k) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

bool kdb::Key::operator> (const Key & other) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

bool kdb::Key::operator>= (const Key & other) const [inline]¶

Compare the name of two keys.

Returns:

The comparison is based on a strcmp of the keynames, and iff they match a strcmp of the owner will be used to distuingish. If even this matches the keys are found to be exactly the same and 0 is returned. These two keys can't be used in the same KeySet.

keyCmp() defines the sorting order for a KeySet.

The following 3 points are the rules for null values:

• A null pointer will be found to be smaller than every other key. If both are null pointers, 0 is returned.
• A null name will be found to be smaller than every other name. If both are null names, 0 is returned.

If the name is equal then:

•

No owner will be found to be smaller then every other owner. If both don't have a owner, 0 is returned.

Note:

Often is enough to know if the other key is less then or greater then the other one. But Sometimes you need more precise information, see keyRel().

Given any Keys k1 and k2 constructed with keyNew(), following equation hold true:

Here are some more examples:

Key *k1 = keyNew("user/a", KEY_END);
Key *k2 = keyNew("user/b", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

And even more:

Key *k1 = keyNew("user/a", KEY_OWNER, "markus", KEY_END);
Key *k2 = keyNew("user/a", KEY_OWNER, "max", KEY_END);
// keyCmp(k1,k2) < 0
// keyCmp(k2,k1) > 0

Do not strcmp the keyName() yourself because the result differs from simple ascii comparison.

Parameters:

See also:

Return values:

ckdb::Key * kdb::Key::release () [inline]¶

Passes out the raw key pointer and resets internal key handle.

Note:

Return values:

void kdb::Key::rewindMeta () const [inline]¶

Rewind the internal iterator to first meta data. Use it to set the cursor to the beginning of the Key Meta Infos. keyCurrentMeta() will then always return NULL afterwards. So you want to keyNextMeta() first.

Key *key;
const Key *meta;
keyRewindMeta (key);
while ((meta = keyNextMeta (key))!=0)
{


        printf ("name: %s, value: %s", keyName(meta), (const char*)keyValue(meta));
}

Parameters:

Return values:

See also:

template<class T > void kdb::Key::set (T x) [inline]¶

Set a key value. Set the value for key as newStringValue. The function will allocate and save a private copy of newStringValue, so the parameter can be freed after the call.

String values will be saved in backend storage, when kdbSetKey() will be called, in UTF-8 universal encoding, regardless of the program's current encoding, when iconv plugin is present.

Note:

Parameters:

Returns:

Return values:

See also:

This method tries to deserialise the string to the given type.

void kdb::Key::setBaseName (const std::string & baseName) [inline]¶

Sets a base name for a key. Sets baseName as the new basename for key. Only the baseName will be affected and no other part of the key.

All text after the last '/' in the key keyname is erased and baseName is appended.

So let us suppose key has name 'system/dir1/dir2/key1'. If baseName is 'key2', the resulting key name will be 'system/dir1/dir2/key2'. If baseName is empty or NULL, the resulting key name will be 'system/dir1/dir2'.

This function does proper escaping on the supplied name argument.

You can use all names to set as basename (e.g. . (dot), .. (dot-dot), % and '' (empty)). They will be properly escaped.

A simple example is:

Key * k = keyNew("user/my/long/name", KEY_END);
keySetBaseName(k, "myname");
printf ("%s0, keyName(k)); // will print user/my/long/myname
keyDel(k);

If you want to add and not change the basename, use keyAddBaseName() instead. If you do not want escaping, use keyAddName() instead.

To add an inactive key name, use:

        keySetName (k, "system/valid");


        keySetBaseName(k, ".hiddenkey");


        succeed_if_same_string(keyName(k), "system/.hiddenkey");


        succeed_if_same_string(keyBaseName(k), ".hiddenkey");

When you want to add an array item, use:

        keySetName (k, "system/valid");


        keySetBaseName(k, "");


        succeed_if_same_string(keyName(k), "system/%");


        succeed_if_same_string(keyBaseName(k), "");

See also:

Parameters:

Returns:

Return values:

See also:

Exceptions:

ssize_t kdb::Key::setBinary (const void * newBinary, size_t dataSize) [inline]¶

Set the value of a key as a binary. A private copy of newBinary will allocated and saved inside key, so the parameter can be deallocated after the call.

Binary values might be encoded in another way then string values depending on the plugin. Typically character encodings should not take place on binary data. Consider using a string key instead.

When newBinary is a NULL pointer the binary will be freed and 0 will be returned.

Note:

Parameters:

Returns:

Return values:

See also:

template<class T > void kdb::Key::setMeta (const std::string & metaName, T x) [inline]¶

Set metadata for key. Set a new Meta-Information. Will set a new Meta-Information pair consisting of metaName and newMetaString.

Will add a new Pair for Meta-Information if metaName was not added up to now.

It will modify a existing Pair of Meta-Information if the the metaName was inserted already.

It will remove a meta information if newMetaString is 0.

Parameters:

Return values:

Returns:

See also:

Warning:

Use delMeta() to avoid these issues.

See also:

void kdb::Key::setName (const std::string & newName) [inline]¶

Set a new name to a key. A valid name is one of the forms:

• spec/something for specification of other keys.
• proc/something for in-memory keys, e.g. commandline.
• dir/something for dir keys in current working directory
• system/something for system keys in /etc or /
• user/something for user keys in home directory
• user:username/something for other users (deprecated: kdbGet() + kdbSet() currently unsupported)
• /something for cascading keys (actually refers to one of the above, see also ksLookup())

An invalid name either has an invalid namespace or a wrongly escaped \ at the end of the name.

See key names for the exact rules.

The last form has explicitly set the owner, to let the library know in which user folder to save the key. A owner is a user name. If it is not defined (the second form) current user is used.

You should always follow the guidelines for key tree structure creation.

A private copy of the key name will be stored, and the newName parameter can be freed after this call.

.., . and / will be handled as in filesystem pathes. A valid name will be build out of the (valid) name what you pass, e.g. user///sw/../sw//././MyApp -> user/sw/MyApp

On invalid names, NULL or '' the name will be '' afterwards.

Return values:

Parameters:

See also:

Exceptions:

void kdb::Key::setString (std::string newString) [inline]¶

Set the value for key as newStringValue. The function will allocate and save a private copy of newStringValue, so the parameter can be freed after the call.

String values will be saved in backend storage, when kdbSetKey() will be called, in UTF-8 universal encoding, regardless of the program's current encoding, when iconv plugin is present.

Note:

Parameters:

Returns:

Return values:

See also: