///<inheritdoc/>
public void AddTableListenerEx(Action <ITable, string, Value, NotifyFlags> listenerDelegate, NotifyFlags flags)
{
List <int> adapters;
if (!m_actionListenerMap.TryGetValue(listenerDelegate, out adapters))
{
adapters = new List <int>();
m_actionListenerMap.Add(listenerDelegate, adapters);
}
// ReSharper disable once InconsistentNaming
EntryListenerCallback func = (uid, key, value, flags_) =>
{
string relativeKey = key.Substring(m_path.Length + 1);
if (relativeKey.IndexOf(PathSeperatorChar) != -1)
{
return;
}
listenerDelegate(this, relativeKey, value, flags_);
};
int id = m_ntCore.AddEntryListener(m_path + PathSeperatorChar, func, flags);
adapters.Add(id);
}
///<inheritdoc/>
public void AddTableListenerEx(string key, Action <ITable, string, Value, NotifyFlags> listenerDelegate, NotifyFlags flags)
{
lock (m_actionListenerMap)
{
if (!m_actionListenerMap.TryGetValue(listenerDelegate, out List <int> adapters))
{
adapters = new List <int>();
m_actionListenerMap.Add(listenerDelegate, adapters);
}
string fullKey = m_pathWithSeperator + key;
// ReSharper disable once InconsistentNaming
EntryListenerCallback func = (uid, funcKey, value, flags_) =>
{
if (!funcKey.Equals(fullKey))
{
return;
}
listenerDelegate(this, key, value, flags_);
};
int id = NtCore.AddEntryListener(fullKey, func, flags);
adapters.Add(id);
}
}
///<inheritdoc/>
public void AddTableListenerEx(ITableListener listener, NotifyFlags flags)
{
lock (m_listenerMap)
{
if (!m_listenerMap.TryGetValue(listener, out List <int> adapters))
{
adapters = new List <int>();
m_listenerMap.Add(listener, adapters);
}
// ReSharper disable once InconsistentNaming
EntryListenerCallback func = (uid, key, value, flags_) =>
{
string relativeKey = key.Substring(m_path.Length + 1);
if (relativeKey.IndexOf(PathSeperatorChar) != -1)
{
return;
}
listener.ValueChanged(this, relativeKey, value, flags_);
};
int id = NtCore.AddEntryListener(m_pathWithSeperator, func, flags);
adapters.Add(id);
}
}
///<inheritdoc/>
public void AddSubTableListener(Action <ITable, string, Value, NotifyFlags> listenerDelegate, bool localNotify)
{
if (!m_actionListenerMap.TryGetValue(listenerDelegate, out List <int> adapters))
{
adapters = new List <int>();
m_actionListenerMap.Add(listenerDelegate, adapters);
}
HashSet <string> notifiedTables = new HashSet <string>();
// ReSharper disable once InconsistentNaming
EntryListenerCallback func = (uid, key, value, flags_) =>
{
string relativeKey = key.Substring(m_path.Length + 1);
int endSubTable = relativeKey.IndexOf(PathSeperatorChar);
if (endSubTable == -1)
{
return;
}
string subTableKey = relativeKey.Substring(0, endSubTable);
if (notifiedTables.Contains(subTableKey))
{
return;
}
notifiedTables.Add(subTableKey);
listenerDelegate(this, subTableKey, null, flags_);
};
NotifyFlags flags = NotifyFlags.NotifyNew | NotifyFlags.NotifyUpdate;
if (localNotify)
{
flags |= NotifyFlags.NotifyLocal;
}
int id = m_ntCore.AddEntryListener(m_pathWithSeperator, func, flags);
adapters.Add(id);
}
public EntryNotification(string name, Value value, NotifyFlags flags,
EntryListenerCallback only)
{
Name = name;
Value = value;
Flags = flags;
Only = only;
}
public int AddEntryListener(string prefix, EntryListenerCallback callback, NotifyFlags flags)
{
lock (m_mutex)
{
if ((flags & NotifyFlags.NotifyLocal) != 0)
{
m_localNotifiers = true;
}
return(m_entryListeners.Add(prefix, callback, flags));
}
}
/// <inheritdoc cref="NtCore.AddEntryListener"/>
public int AddEntryListener(string prefix, EntryListenerCallback callback, NotifyFlags flags)
{
Notifier notifier = m_notifier;
int uid = notifier.AddEntryListener(prefix, callback, flags);
notifier.Start();
if ((flags & NotifyFlags.NotifyImmediate) != 0)
{
m_storage.NotifyEntries(prefix, callback);
}
return(uid);
}
public void NotifyEntries(string prefix, EntryListenerCallback only = null)
{
using (m_monitor.Enter())
{
foreach (var i in m_entries)
{
if (!i.Key.StartsWith(prefix))
{
continue;
}
m_notifier.NotifyEntry(i.Key, i.Value.Value, NotifyFlags.NotifyImmediate, only);
}
}
}
/// <summary>
/// Adds a listener for a specified prefix in the table
/// </summary>
/// <param name="prefix">The prefix to listen for in the table</param>
/// <param name="callback">The callback to call when any entry with the specified prefix is updated</param>
/// <param name="flags">The flags to use for notifying</param>
/// <returns>The id of the entry listener</returns>
public static int AddEntryListener(string prefix, EntryListenerCallback callback, NotifyFlags flags)
{
#if CORE
return(CoreMethods.AddEntryListener(prefix, callback, flags));
#else
Notifier notifier = Notifier.Instance;
int uid = notifier.AddEntryListener(prefix, callback, flags);
notifier.Start();
if ((flags & NotifyFlags.NotifyImmediate) != 0)
{
Storage.Instance.NotifyEntries(prefix, callback);
}
return(uid);
#endif
}
public int Add(string prefix, EntryListenerCallback callback, NotifyFlags flags)
{
int uid;
var listener = new EntryListener(prefix, callback, flags);
if (m_free.Count == 0)
{
uid = m_list.Count;
m_list.Add(listener);
}
else
{
uid = m_free.Dequeue();
m_list[uid] = listener;
}
return(uid + 1);
}
public void NotifyEntry(string name, Value value, NotifyFlags flags, EntryListenerCallback only = null)
{
if (!m_active)
{
return;
}
// optimization: don't generate needless local queue entries if we have
// no local listeners (as this is a common case on the server side)
if ((flags & NotifyFlags.NotifyLocal) != 0 && !m_localNotifiers)
{
return;
}
lock (m_mutex)
{
m_entryNotifications.Enqueue(new EntryNotification(name, value, flags, only));
}
m_cond.Set();
}
///<inheritdoc/>
public void AddTableListenerEx(string key, ITableListener listener, NotifyFlags flags)
{
if (!m_listenerMap.TryGetValue(listener, out List <int> adapters))
{
adapters = new List <int>();
m_listenerMap.Add(listener, adapters);
}
string fullKey = m_pathWithSeperator + key;
// ReSharper disable once InconsistentNaming
EntryListenerCallback func = (uid, funcKey, value, flags_) =>
{
if (!funcKey.Equals(fullKey))
{
return;
}
listener.ValueChanged(this, key, value, flags_);
};
int id = m_ntCore.AddEntryListener(fullKey, func, flags);
adapters.Add(id);
}
internal static int AddEntryListener(string prefix, EntryListenerCallback listener, NotifyFlags flags)
{
// ReSharper disable once InconsistentNaming
Interop.NT_EntryListenerCallback modCallback = (uid, data, name, len, value, flags_) =>
{
NtType type = Interop.NT_GetValueType(value);
Value obj;
ulong lastChange = 0;
UIntPtr size = UIntPtr.Zero;
IntPtr ptr;
switch (type)
{
case NtType.Unassigned:
obj = null;
break;
case NtType.Boolean:
int boolean = 0;
Interop.NT_GetValueBoolean(value, ref lastChange, ref boolean);
obj = Value.MakeBoolean(boolean != 0);
break;
case NtType.Double:
double val = 0;
Interop.NT_GetValueDouble(value, ref lastChange, ref val);
obj = Value.MakeDouble(val);
break;
case NtType.String:
ptr = Interop.NT_GetValueString(value, ref lastChange, ref size);
obj = Value.MakeString(ReadUTF8String(ptr, size));
break;
case NtType.Raw:
ptr = Interop.NT_GetValueRaw(value, ref lastChange, ref size);
obj = Value.MakeRaw(GetRawDataFromPtr(ptr, size));
break;
case NtType.BooleanArray:
ptr = Interop.NT_GetValueBooleanArray(value, ref lastChange, ref size);
obj = Value.MakeBooleanArray(GetBooleanArrayFromPtr(ptr, size));
break;
case NtType.DoubleArray:
ptr = Interop.NT_GetValueDoubleArray(value, ref lastChange, ref size);
obj = Value.MakeDoubleArray(GetDoubleArrayFromPtr(ptr, size));
break;
case NtType.StringArray:
ptr = Interop.NT_GetValueStringArray(value, ref lastChange, ref size);
obj = Value.MakeStringArray(GetStringArrayFromPtr(ptr, size));
break;
case NtType.Rpc:
ptr = Interop.NT_GetValueRaw(value, ref lastChange, ref size);
obj = Value.MakeRpc(GetRawDataFromPtr(ptr, size));
break;
default:
obj = null;
break;
}
string key = ReadUTF8String(name, len);
listener((int)uid, key, obj, (NotifyFlags)flags_);
};
UIntPtr prefixSize;
byte[] prefixStr = CreateUTF8String(prefix, out prefixSize);
int retVal = (int)Interop.NT_AddEntryListener(prefixStr, prefixSize, IntPtr.Zero, modCallback, (uint)flags);
s_entryCallbacks.Add(retVal, modCallback);
return(retVal);
}
public EntryListener(string prefix, EntryListenerCallback callback, NotifyFlags flags)
{
Prefix = prefix;
Callback = callback;
Flags = flags;
}
