core: flags for keyDup and keyCopy

temporarily replaces keyDup and keyCopy with keyDupOld and keyCopyOld

benchmarks/benchmarks.c

@@ -455,7 +455,7 @@ static void recGenerateKeySet (KeySet * ks, Key * key, KsTreeVertex * vertex)
 	// add if Key
 	if (vertex->isKey)
 	{
-		Key * dupKey = keyDup (key);
+		Key * dupKey = keyDupOld (key);
 		if (!dupKey)
 		{
 			printExit ("recGenerateKeySet: Can not dup Key");
@@ -473,7 +473,7 @@ static void recGenerateKeySet (KeySet * ks, Key * key, KsTreeVertex * vertex)
 	// go to children
 	for (size_t i = 0; i < vertex->numberofChildren; ++i)
 	{
-		Key * dupKey = keyDup (key);
+		Key * dupKey = keyDupOld (key);
 		if (!dupKey)
 		{
 			printExit ("recGenerateKeySet: Can not dup Key");

examples/functional.c

@@ -81,7 +81,7 @@ int ksFilter (KeySet * result, KeySet * input, int (*filter) (Key * k))
 		else if (rc != 0)
 		{
 			++ret;
-			ksAppendKey (result, keyDup (current));
+			ksAppendKey (result, keyDupOld (current));
 		}
 	}
 	ksSetCursor (input, cursor);

examples/keyCopy.c

@@ -16,15 +16,15 @@ Key * copy;
 void h (Key * k)
 {
 	// receive key c
-	keyCopy (k, copy);
+	keyCopyOld (k, copy);
 	// the caller will see the changed key k
 }
 //! [Basic Usage]
 
 //! [Clear]
 void g (Key * k)
 {
-	keyCopy (k, 0);
+	keyCopyOld (k, 0);
 	// k is now an empty and fresh key
 }
 //! [Clear]
@@ -38,7 +38,7 @@ void j (Key * k)
 
 	// receive key c
 	memcpy (value, keyValue (k), size);
-	keyCopy (k, copy);
+	keyCopyOld (k, copy);
 	if (bstring)
 		keySetString (k, value);
 	else

examples/keyset.c

@@ -12,15 +12,15 @@
 
 void f (const Key * source)
 {
-	Key * dup = keyDup (source);
+	Key * dup = keyDupOld (source);
 	printf ("\tin f\n");
 
 	keyDel (dup);
 }
 
 void g (const Key * source, KeySet * ks)
 {
-	Key * dup = keyDup (source);
+	Key * dup = keyDupOld (source);
 	printf ("\tin g\n");
 
 	ksAppendKey (ks, dup);
@@ -31,7 +31,7 @@ void h (Key * k)
 	Key * c = keyNew ("user:/from/h", KEY_END);
 	printf ("\tin h\n");
 
-	keyCopy (k, c);
+	keyCopyOld (k, c);
 	keyDel (c);
 	/* the caller will see the changed key k */
 }
@@ -68,7 +68,7 @@ void dupAppend (void)
 //! [dup append]
 KeySet * ks = ksNew (1, KS_END);
 Key * k = keyNew ("user:/ref/key", KEY_END);
-ksAppendKey (ks, keyDup (k));
+ksAppendKey (ks, keyDupOld (k));
 ksDel (ks);
 // now we still can work with the key k!
 keyDel (k);
@@ -101,7 +101,7 @@ int main (void)
 
 	ksRewind (ks);
 	origKey = ksNext (ks);
-	key = keyDup (origKey);
+	key = keyDupOld (origKey);
 	printf ("A duplication of the key %s with value %s\n", keyName (key), keyString (key));
 
 	keyDel (key);

src/bindings/cpp/include/key.hpp

@@ -114,7 +114,7 @@ class Key
 	inline Key & operator= (ckdb::Key * k);
 	inline Key & operator= (const Key & k);
 
-	inline void copy (const Key & other);
+	inline void copy (const Key & other, int flags = 0);
 	inline void clear ();
 	inline ckdb::Key * operator-> () const;
 
@@ -732,9 +732,9 @@ inline Key & Key::operator= (const Key & k)
 /**
  * @copydoc keyCopy
  */
-inline void Key::copy (const Key & other)
+inline void Key::copy (const Key & other, int flags)
 {
-	ckdb::keyCopy (key, other.key);
+	ckdb::keyCopy (key, other.key, flags);
 }
 
 /**
@@ -815,7 +815,7 @@ ckdb::Key * Key::release ()
  */
 ckdb::Key * Key::dup () const
 {
-	return ckdb::keyDup (getKey ());
+	return ckdb::keyDupOld (getKey ());
 }
 
 /**

src/bindings/glib/gelektra-key.c

@@ -195,7 +195,7 @@ gssize gelektra_key_getref (const GElektraKey * key)
  */
 GElektraKey * gelektra_key_dup (const GElektraKey * key)
 {
-	return gelektra_key_make (keyDup (key->key));
+	return gelektra_key_make (keyDupOld (key->key));
 }
 
 /**
@@ -204,7 +204,8 @@ GElektraKey * gelektra_key_dup (const GElektraKey * key)
  */
 gint gelektra_key_copy (const GElektraKey * key, GElektraKey * dest)
 {
-	return keyCopy (dest->key, key->key);
+	// TODO (kodebach): binding
+	return keyCopyOld (dest->key, key->key);
 }
 
 gint gelektra_key_clear (GElektraKey * key)

src/bindings/intercept/fs/intercept.c

@@ -134,7 +134,7 @@ void init (void)
 		else
 			tmp->value = createAbsolutePath (keyString (key), cwd);
 		tmp->oflags = (unsigned short) -1;
-		Key * lookupKey = keyDup (key);
+		Key * lookupKey = keyDupOld (key);
 		keyAddBaseName (lookupKey, "readonly");
 		Key * found = ksLookup (ks, lookupKey, 0);
 		if (found)

src/bindings/jna/libelektra5j/src/main/java/org/libelektra/Elektra.java

@@ -37,7 +37,7 @@ public interface Elektra extends Library {
 
 	Pointer keyNew (String name, Object... args);
 
-	Pointer keyDup (Pointer source);
+	Pointer keyDupOld (Pointer source);
 
 	int keyCopy (Pointer dest, Pointer source);
 

src/bindings/jna/libelektra5j/src/main/java/org/libelektra/Key.java

@@ -412,7 +412,7 @@ public void addWarning (final String text, final Object... args)
 	 */
 	public Key dup ()
 	{
-		return new Key (Elektra.INSTANCE.keyDup (get ()));
+		return new Key (Elektra.INSTANCE.keyDupOld (get ()));
 	}
 
 	/**

src/bindings/rust/elektra/src/key.rs

@@ -180,7 +180,12 @@ impl<'a> StringKey<'a> {
 
     /// Returns a deep copy of the key.
     pub fn duplicate<'b>(&'a self) -> StringKey<'b> {
-        let dup_ptr = unsafe { elektra_sys::keyDup(self.as_ref()) };
+        // TODO: binding
+        let dup_ptr = unsafe { 
+            let dup = elektra_sys::keyDup(self.as_ref(), 0);
+            elektra_sys::keyCopyAllMeta(dup, self.as_ref());
+            dup
+        };
         unsafe { StringKey::from_ptr(dup_ptr) }
     }
 
@@ -245,7 +250,12 @@ impl<'a> BinaryKey<'a> {
 
     /// Returns a deep copy of the key.
     pub fn duplicate<'b>(&'a self) -> BinaryKey<'b> {
-        let dup_ptr = unsafe { elektra_sys::keyDup(self.as_ref()) };
+        // TODO: binding
+        let dup_ptr = unsafe { 
+            let dup = elektra_sys::keyDup(self.as_ref(), 0);
+            elektra_sys::keyCopyAllMeta(dup, self.as_ref());
+            dup
+        };
         unsafe { BinaryKey::from_ptr(dup_ptr) }
     }
 

src/include/kdb.h.in

@@ -125,8 +125,8 @@ int kdbEnsure (KDB * handle, KeySet * contract, Key * parentKey);
 Key *keyNew(const char *keyname, ...);
 Key *keyVNew(const char *keyname, va_list ap);
 
-Key *keyDup(const Key *source);
-int keyCopy(Key *dest, const Key *source);
+Key *keyDup(const Key *source, elektraKeyFlags flags);
+int keyCopy(Key *dest, const Key *source, elektraKeyFlags flags);
 
 int keyClear(Key *key);
 int keyDel(Key *key);
@@ -195,6 +195,25 @@ ssize_t keySetBinary(Key *key, const void *newBinary, size_t dataSize);
 int keyLock (Key * key, elektraLockFlags what);
 int keyIsLocked (const Key * key, elektraLockFlags what);
 
+// FIXME: remove once migrated
+static inline Key *keyDupOld (const Key *source)
+{
+	Key * dup = keyDup (source, 0);
+	keyCopyAllMeta (dup, source);
+	return dup;
+}
+
+// FIXME: remove once migrated
+static inline int keyCopyOld (Key *dest, const Key *source)
+{
+	int ret = keyCopy (dest, source, 0);
+	if (ret > 0)
+	{
+		keyCopyAllMeta (dest, source);
+	}
+	return ret;
+}
+
 /**************************************
  *
  * KeySet methods

src/libs/ease/array.c

@@ -272,7 +272,7 @@ Key * elektraArrayGetNextKey (KeySet * arrayKeys)
 	if (!last) return 0;
 
 	ksAppendKey (arrayKeys, last);
-	Key * newKey = keyDup (last);
+	Key * newKey = keyDupOld (last);
 	keySetBinary (newKey, 0, 0);
 	int ret = elektraArrayIncName (newKey);
 

src/libs/elektra/backend.c

@@ -72,7 +72,7 @@ static Backend * elektraBackendAllocate (void)
 int elektraBackendSetMountpoint (Backend * backend, KeySet * elektraConfig, Key * errorKey)
 {
 	Key * root = ksCurrent (elektraConfig);
-	Key * searchMountpoint = keyDup (root);
+	Key * searchMountpoint = keyDupOld (root);
 	keyAddBaseName (searchMountpoint, "mountpoint");
 	Key * foundMountpoint = ksLookup (elektraConfig, searchMountpoint, 0);
 	keyDel (searchMountpoint);

src/libs/elektra/kdb.c

@@ -171,7 +171,7 @@ KeySet * ksRenameKeys (KeySet * config, const char * name)
 
 	while ((cur = ksPop (config)) != 0)
 	{
-		Key * dupKey = keyDup (cur);
+		Key * dupKey = keyDupOld (cur);
 		keySetName (dupKey, name);
 		keyAddName (dupKey, keyName (cur) + rootSize - 1);
 		ksAppendKey (newConfig, dupKey);
@@ -260,7 +260,7 @@ KDB * kdbOpen (Key * errorKey)
 
 	int errnosave = errno;
 	KDB * handle = elektraCalloc (sizeof (struct _KDB));
-	Key * initialParent = keyDup (errorKey);
+	Key * initialParent = keyDupOld (errorKey);
 
 	handle->global = ksNew (0, KS_END);
 	handle->modules = ksNew (0, KS_END);
@@ -404,7 +404,7 @@ int kdbClose (KDB * handle, Key * errorKey)
 		return -1;
 	}
 
-	Key * initialParent = keyDup (errorKey);
+	Key * initialParent = keyDupOld (errorKey);
 	int errnosave = errno;
 	splitDel (handle->split);
 
@@ -1006,7 +1006,7 @@ int kdbGet (KDB * handle, KeySet * ks, Key * parentKey)
 	}
 
 	int errnosave = errno;
-	Key * initialParent = keyDup (parentKey);
+	Key * initialParent = keyDupOld (parentKey);
 
 	ELEKTRA_LOG ("now in new kdbGet (%s)", keyName (parentKey));
 
@@ -1038,7 +1038,7 @@ int kdbGet (KDB * handle, KeySet * ks, Key * parentKey)
 	}
 
 	cache = ksNew (0, KS_END);
-	cacheParent = keyDup (mountGetMountpoint (handle, keyName (initialParent)));
+	cacheParent = keyDupOld (mountGetMountpoint (handle, keyName (initialParent)));
 	if (cacheParent == NULL)
 	{
 		cacheParent = keyNew ("default:/", KEY_VALUE, "default", KEY_END);
@@ -1588,7 +1588,7 @@ int kdbSet (KDB * handle, KeySet * ks, Key * parentKey)
 	}
 
 	int errnosave = errno;
-	Key * initialParent = keyDup (parentKey);
+	Key * initialParent = keyDupOld (parentKey);
 
 	ELEKTRA_LOG ("now in new kdbSet (%s) %p %zd", keyName (parentKey), (void *) handle, ksGetSize (ks));