/// <summary> /// Instructs the transaction to write the value to the subkey of the key. /// </summary> /// <remarks>The effect of any previous Put() or Delete() calls on the same subkey /// within this transaction will be overwritten by this call. /// When the transaction is applied, the new value will overwrite any previous /// value that this subkey had (or insert it if it was missing).</remarks> public unsafe void Put(KeyRef key, ulong subkey, ReadOnlySpan <byte> value) { fixed(byte *bytes = value) { PInvoke_PutBytes(handle, key.handle, subkey, bytes, value.Length); } }
/// <summary> /// Instructs the transaction to check that the subkey is present before /// applying the transaction. The transaction will fail if the subkey is missing. /// </summary> /// <remarks>The effect of any previous Require* call on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void RequirePresentSubkey(KeyRef key, ulong subkey) { PInvoke_RequirePresentSubkey(handle, key.handle, subkey); }
/// <summary> /// Instructs the transaction to delete all subkeys of the key. /// </summary> /// <remarks>The effect of any previous Put() or Delete() calls on the same key /// within this transaction will be overwritten by this call. /// /// Note that this marks the whole key for deletion, and the exact number /// of affected subkeys is only known only when the transaction is applied. /// /// Use it to safely delete the key instead of calling <see cref="Delete(KeyRef, ulong)"/> /// on individual subkeys when this is the intended effect. /// /// You can call <see cref="Put"/> for the same key after calling <see cref="Delete(KeyRef)"/> /// if you want to insert any subkeys within the same transaction.</remarks> public void Delete(KeyRef key) { PInvoke_DeleteKey(handle, key.handle); }
/// <summary> /// Instructs the transaction to delete the subkey of the key. /// </summary> /// <remarks>The effect of any previous Put() or Delete() calls on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void Delete(KeyRef key, ulong subkey) { PInvoke_DeleteSubkey(handle, key.handle, subkey); }
/// <summary> /// Instructs the transaction to check that the number of subkeys of the key /// is equal to the provided number. /// The transaction will fail if the number of subkeys is different. /// </summary> /// <remarks>Any number is allowed, including 0 (to require that the entire key is missing). /// The effect of any previous Require* call on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void RequireSubkeysCount(KeyRef key, ulong requiredSubkeysCount) { PInvoke_RequireSubkeysCount(handle, key.handle, requiredSubkeysCount); }
/// <summary> /// Instructs the transaction to write the value to the subkey of the key. /// </summary> /// <remarks>The effect of any previous Put() or Delete() calls on the same subkey /// within this transaction will be overwritten by this call. /// When the transaction is applied, the new value will overwrite any previous /// value that this subkey had (or insert it if it was missing).</remarks> public void Put(KeyRef key, ulong subkey, ValueRef value) { PInvoke_Put(handle, key.handle, subkey, value.handle); }
/// <summary> /// Instructs the transaction to check that the subkey has the provided value before /// applying the transaction. /// The transaction will fail if the value is different, or the subkey is missing. /// </summary> /// <remarks>The effect of any previous Require* call on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void RequireValue(KeyRef key, ulong subkey, ValueRef requiredValue) { PInvoke_RequireValue(handle, key.handle, subkey, requiredValue.handle); }
/// <summary> /// Instructs the transaction to check that the subkey has the provided version before /// applying the transaction. /// The transaction will fail if the version is different, or the subkey is missing. /// </summary> /// <remarks>The effect of any previous Require* call on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void RequireVersion(KeyRef key, ulong subkey, ulong requiredVersion) { PInvoke_RequireVersion(handle, key.handle, subkey, requiredVersion); }
/// <summary> /// Indicates whether the current object references the same key as the provided <see cref="KeyRef"/>. /// </summary> /// <param name="other">A <see cref="KeyRef"/> object to compare with this object.</param> /// <returns>true if the current object is equal to the other parameter (references the same key); /// otherwise, false.</returns> public bool Equals(KeyRef other) { return(handle == other.handle); }
/// <summary> /// Instructs the transaction to check that the subkey is missing before /// applying the transaction. The transaction will fail if the subkey is present. /// </summary> /// <remarks>The effect of any previous Require* call on the same subkey /// within this transaction will be overwritten by this call.</remarks> public void RequireMissingSubkey(KeyRef key, ulong subkey) { PInvoke_RequireMissingSubkey(handle, key.handle, subkey); }
/// <summary> /// Returns the snapshot of the <paramref name="subkey"/> associated with the provided <paramref name="key"/>. /// </summary> /// <returns><see cref="SubkeySnapshot"/> object representing the state of the subkey. /// If the subkey doesn't exist in this snapshot, the returned <see cref="SubkeySnapshot"/> will be without a value. /// Use <see cref="SubkeySnapshot.HasValue"/> to check whether the subkey was found.</returns> public SubkeySnapshot TryGetValue(KeyRef key, ulong subkey) { throw new NotImplementedException(); }
/// <summary> /// Returns true if the {key:subkey} pair exists in this snapshot. /// </summary> public bool Contains(KeyRef key, ulong subkey) { return(PInvoke_Contains(handle, key.handle, subkey)); }
/// <summary> /// Returns the number of subkeys associated with the key in this snapshot, or 0 if the key is missing. /// </summary> public ulong GetSubkeysCount(KeyRef key) { return(PInvoke_GetSubkeysCount(handle, key.handle)); }
/// <summary> /// Returns a <see cref="KeySnapshot"/> for the provided key. /// </summary> /// <remarks>The returned snapshot can be empty if the key doesn't exist in this snapshot. /// Use <see cref="KeySnapshot.SubkeysCount"/> to check if the key was found.</remarks> public KeySnapshot GetKey(KeyRef key) { throw new NotImplementedException(); }
/// <summary> /// Sets <paramref name="readOnlySpan"/> to the current binary value of the subkey. /// </summary> /// <returns>True if the subkey was found, and the <paramref name="readOnlySpan"/> now contains its value. /// False otherwise (in this case <paramref name="readOnlySpan"/> will be empty).</returns> /// <remarks>Note that the method can return true while assigning an empty <paramref name="readOnlySpan"/>, /// in case if the subkey exists, but its value is empty. Do not use the emptiness of the span /// as an indication of a successful search.</remarks> public bool TryGetValue(KeyRef key, ulong subkey, out ReadOnlySpan <byte> readOnlySpan) { throw new NotImplementedException(); }