public static Configuration AddEventListener(this Configuration config, ListenerType listenerType, string typeName)
{
var type = Type.GetType(typeName);
var o = Activator.CreateInstance(type);
return(config.AddEventListener(listenerType, o));
}
virtual protected void InternalAdd(Delegate listener, ListenerType listenerType)
{
this.listeners.Add(new SignalListenerItem()
{
SignalDelegate = (SignalDelegate)listener, ListenerType = listenerType
});
}
/// <summary>
/// Initializes a new instance of the <see cref="EventConfiguration"/> class.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="type">The type.</param>
public EventConfiguration(ListenerConfiguration listener, ListenerType type)
{
if (listener == null)
throw new ArgumentNullException("listener");
this.type = type;
listeners.Add(listener);
}
/// <summary>
/// Compares the instance with another one for equality.
/// </summary>
/// <param name="obj">The config to compare with</param>
/// <returns>true if the obj is for the same <see cref="ListenerType"/></returns>
public override bool Equals(object obj)
{
return
((obj != null) &&
(obj is EventListenerConfig) &&
(ListenerType.Equals(((EventListenerConfig)obj).ListenerType)));
}
public void AddListener(UnityAction listener, ListenerType listenerType)
{
switch (listenerType)
{
case ListenerType.PreStart:
_onPreStart.AddListener(listener);
break;
case ListenerType.PostStart:
_onPostStart.AddListener(listener);
break;
case ListenerType.PreDraw:
_onPreDraw.AddListener(listener);
break;
case ListenerType.PostDraw:
_onPostDraw.AddListener(listener);
break;
case ListenerType.PreFinish:
_onPreFinish.AddListener(listener);
break;
case ListenerType.PostFinish:
_onPostFinish.AddListener(listener);
break;
}
}
public void InvokeListener(ListenerType listenerType)
{
switch (listenerType)
{
case ListenerType.PreStart:
_onPreStart.Invoke();
break;
case ListenerType.PostStart:
_onPostStart.Invoke();
break;
case ListenerType.PreDraw:
_onPreDraw.Invoke();
break;
case ListenerType.PostDraw:
_onPostDraw.Invoke();
break;
case ListenerType.PreFinish:
_onPreFinish.Invoke();
break;
case ListenerType.PostFinish:
_onPostFinish.Invoke();
break;
}
}
public static void OnBroadcasting(string eventType, ListenerType mode)
{
if (mode == ListenerType.RequireListener && !eventTable.ContainsKey(eventType))
{
throw new ListenerInternal.BroadcastException(string.Format("Broadcasting message {0} but no listener found.", eventType));
}
}
public void StopListen(ListenerType listenerType, GameObject gameObject) {
ArrayList list = Listeners[listenerType] as ArrayList;
if (list != null) {
list.Remove(gameObject);
}
}
/// <summary>
/// Registers the listeners.
/// </summary>
/// <param name="cfg">The CFG.</param>
/// <param name="facilityConfig">The facility config.</param>
protected void RegisterListeners(Configuration cfg, IConfiguration facilityConfig)
{
if (facilityConfig == null)
{
return;
}
foreach (IConfiguration item in facilityConfig.Children)
{
String eventName = item.Attributes["event"];
String typeName = item.Attributes["type"];
if (!Enum.IsDefined(typeof(ListenerType), eventName))
{
throw new ConfigurationErrorsException("An invalid listener type was specified.");
}
Type classType = Type.GetType(typeName);
//if (classType == null)
// throw new ConfigurationErrorsException("The full type name of the listener class must be specified.");
ListenerType listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), eventName);
object listenerInstance = Activator.CreateInstance(classType);
cfg.SetListener(listenerType, listenerInstance);
}
}
public bool HasErrors()
{
bool result = false;
if (string.IsNullOrEmpty(ListenerType))
{
Console.WriteLine("Please define the Service Type to run:");
Console.WriteLine("Type '-serviceType M' (Default) for connecting as a Mock");
Console.WriteLine("Type '-serviceType S' for connecting to a camera via a Socket");
Console.WriteLine("Type '-serviceType D' for connecting to files on a Disk");
result = true;
}
if (ListenerType.ToUpper() == "S")
{
if (string.IsNullOrEmpty(IpAndPortA))
{
Console.WriteLine("Selecting a Service Type of Socket (S) you must enter the IP Address and Port to Connect to Point A:");
Console.WriteLine("Type '-ipA 127.0.0.1:80' for connecting to a camera with IP Address 127.0.0.1 and Port 80");
result = true;
}
if (string.IsNullOrEmpty(IpAndPortB))
{
Console.WriteLine("Selecting a Service Type of Socket (S) you must enter the IP Address and Port to Connect to Point B:");
Console.WriteLine("Type '-ipB 127.0.0.1:80' for connecting to a camera with IP Address 127.0.0.1 and Port 80");
result = true;
}
}
if (ListenerType.ToUpper() == "D")
{
if (string.IsNullOrEmpty(Helper.PathPointA))
{
Console.WriteLine("Selecting a Listener Type of Disk (D) you must enter the Path Connect to Files stored for Point A:");
Console.WriteLine("Update the Application.Configuration file to e.g. 'C:\\Temp' for connecting to a files stored in the Temp Folder");
result = true;
}
if (string.IsNullOrEmpty(Helper.PathPointB))
{
Console.WriteLine("Selecting a Listener Type of Disk (D) you must enter the Path Connect to Files stored for Point B:");
Console.WriteLine("Update the Application.Configuration file to e.g. 'C:\\Temp' for connecting to a files stored in the Temp Folder");
result = true;
}
if (string.IsNullOrEmpty(Helper.PathFilter))
{
Console.WriteLine("Selecting a Listener Type of Disk (D) you must enter the Path Filter to find Files stored for Point A and B:");
Console.WriteLine("Update the Application.Configuration file to e.g. *.enc' for finding all files with enc extension stored in the indicative folders for Points A and B respectively");
result = true;
}
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventConfiguration"/> class.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="type">The type.</param>
public EventConfiguration(ListenerConfiguration listener, ListenerType type)
{
if (listener == null)
{
throw new ArgumentNullException("listener");
}
this.type = type;
listeners.Add(listener);
}
public void StopListen(ListenerType listenerType, GameObject gameObject)
{
ArrayList list = Listeners[listenerType] as ArrayList;
if (list != null)
{
list.Remove(gameObject);
}
}
public override void Command(MenuItem menuItem, string UserInput)
{
try
{
menuItem.Refresh();
Listener listener = ((ListenerInteractMenuItem)menuItem).Listener;
ListenerType listenerType = ((ListenerInteractMenuItem)menuItem).ListenerType;
EliteConsoleMenu menu = new EliteConsoleMenu(EliteConsoleMenu.EliteConsoleMenuType.Parameter, listenerType.Name + " Listener: " + listener.Name);
switch (listenerType.Name)
{
case "HTTP":
HttpListener httpListener = ((ListenerInteractMenuItem)menuItem).HttpListener;
HttpProfile httpProfile = ((ListenerInteractMenuItem)menuItem).HttpProfile;
menu.Rows.Add(new List <string> {
"Name:", httpListener.Name
});
menu.Rows.Add(new List <string> {
"Status:", httpListener.Status.ToString()
});
menu.Rows.Add(new List <string> {
"StartTime:", httpListener.StartTime.ToString()
});
menu.Rows.Add(new List <string> {
"Description:", httpListener.Description
});
menu.Rows.Add(new List <string> {
"URL:", httpListener.Url
});
menu.Rows.Add(new List <string> {
" ConnectAddress:", httpListener.ConnectAddress
});
menu.Rows.Add(new List <string> {
" BindAddress:", httpListener.BindAddress
});
menu.Rows.Add(new List <string> {
" BindPort:", httpListener.BindPort.ToString()
});
menu.Rows.Add(new List <string> {
" UseSSL:", (httpListener.UseSSL ?? default) ? "True" : "False"
});
menu.Rows.Add(new List <string> {
"SSLCertPath:", ((ListenerInteractMenuItem)menuItem).SSLCertPath
});
menu.Rows.Add(new List <string> {
"SSLCertPassword:"******"SSLCertHash:", httpListener.SslCertHash
});
menu.Rows.Add(new List <string> {
"HttpProfile:", httpProfile.Name
});
break;
}
menu.Print();
}
public ActionResult <ListenerType> GetListenerType(int id)
{
ListenerType type = _context.ListenerTypes.FirstOrDefault(LT => LT.Id == id);
if (type == null)
{
return(NotFound($"NotFound - ListenerType with id: {id}"));
}
return(type);
}
public static Configuration AddListener <T>(
this Configuration configuration,
ListenerType type,
T listener)
where T : class
{
configuration.AppendListeners(type, new [] { listener });
return(configuration);
}
public System.Type GetListenerClassFor(ListenerType type)
{
System.Type result;
if (!eventInterfaceFromType.TryGetValue(type, out result))
{
throw new MappingException("Unrecognized listener type [" + type + "]");
}
return(result);
}
public void AddListener(Delegate listener, ListenerType listenerType = ListenerType.Every)
{
foreach (var listenerItem in this.listeners)
{
if (listenerItem.SignalDelegate.Target == listener.Target && listenerItem.SignalDelegate.Method == listener.Method)
{
throw new Exception($"Attempted to add a duplicate { listener.Method.Name } listener for { listener.Target }");
}
}
InternalAdd(listener, listenerType);
}
public static Configuration AddListener <T>(
this Configuration configuration,
ListenerType type,
T listener)
where T : class
{
// ReSharper disable once CoVariantArrayConversion
configuration.AppendListeners(type, new [] { listener });
return(configuration);
}
public void Listen(ListenerType listenerType, GameObject gameObject) {
if (Listeners[listenerType] == null) {
Listeners[listenerType] = new ArrayList();
}
ArrayList list = Listeners[listenerType] as ArrayList;
if (!list.Contains(gameObject)) {
list.Add(gameObject);
}
}
private static IListener CreateListener(ListenerType type, string host, int port)
{
switch (type)
{
case ListenerType.Http:
return new HttpListener(host, port);
case ListenerType.Sock:
return null;
default:
return new HttpListener(host, port);
}
}
public ISession findSession(ListenerType type, object orgSessionID)
{
IListener l = _listeners[(int)type];
if (l == null)
{
Debug.logger.log(LogType.LOG_ERR, "Finding session with not exist listener type [" + type + "]");
return(null);
}
return(l.getSession(orgSessionID));
}
public void RegisterListener(IReceiver receiver, ListenerType listenerType)
{
switch (listenerType)
{
case ListenerType.Request:
_requestReceivers.Add(receiver);
break;
case ListenerType.Response:
_responseReceivers.Add(receiver);
break;
}
}
public void Send <TSender, TMessage>(TSender sender, TMessage message)
where TSender : class
{
List <Listener> ls;
if (listeners.TryGetValue(ListenerType.Create <TSender, TMessage>(), out ls))
{
foreach (var l in ls)
{
(l as Listener <TSender, TMessage>).Invoke(sender, message);
}
}
}
/// <summary>
/// Adds the listeners to the interal store for application to the Configuration
/// </summary>
/// <param name="type"></param>
/// <param name="listeners"></param>
/// <returns></returns>
internal CustomListenerConfiguration AddListeners(ListenerType type, IEnumerable <object> listeners)
{
if (!this.listeners.ContainsKey(type))
{
this.listeners.Add(type, new List <object>());
}
foreach (var listener in listeners)
{
this.listeners[type].Add(listener);
}
return(this);
}
public void Listen(ListenerType listenerType, GameObject gameObject)
{
if (Listeners[listenerType] == null)
{
Listeners[listenerType] = new ArrayList();
}
ArrayList list = Listeners[listenerType] as ArrayList;
if (!list.Contains(gameObject))
{
list.Add(gameObject);
}
}
public ListenTo(Type signalType, ListenerType listenerType = ListenerType.Every)
{
if (signalType == null)
{
throw new InvalidOperationException("Cannont bind [ListenTo(null)] attribute, you must provide a valid Signal Type to listen to. For example [ListenTo(typeof(MySignal))].");
}
this.SignalType = signalType;
this.ListenerType = listenerType;
if (typeof(ISignal).IsAssignableFrom(this.SignalType) == false)
{
throw new InvalidOperationException($"Attempted to ListenTo a type that doesn't derive from Signal. Did you mean to [ListenTo(typeof({ this.SignalType.Name })] ?");
}
}
internal static IAnimalListener CreateListener(ListenerType t)
{
switch (t)
{
case ListenerType.Child:
return(CreateChild());
case ListenerType.ZooKeper:
return(CreateZooKeeper());
default:
throw new ArgumentOutOfRangeException(nameof(t), t, null);
}
}
private static IListener CreateListener(ListenerType type, string host, int port)
{
switch (type)
{
case ListenerType.Http:
return(new HttpListener(host, port));
case ListenerType.Sock:
return(null);
default:
return(new HttpListener(host, port));
}
}
public void RemoveListener <TSender, TMessage>(Action <TSender, TMessage> listener)
where TSender : class
{
List <Listener> ls;
if (listeners.TryGetValue(ListenerType.Create <TSender, TMessage>(), out ls))
{
var index = IndexOfListener(ls, listener);
if (index != -1)
{
ls.RemoveAt(index);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Listener"/> class.
/// </summary>
/// <param name="socket">The socket.</param>
internal Listener(SocketBase _base, System.Net.Sockets.Socket socket, ListenerType type)
{
parent = _base;
byte[] gb = Helpers.Md5(type == ListenerType.Server ? socket.RemoteEndPoint.ToString() : socket.LocalEndPoint.ToString());
this.Guid = new Guid(gb);
this.Socket = socket;
RemoteEndPoint = this.Socket.RemoteEndPoint;
LocalEndPoint = this.Socket.LocalEndPoint;
Sender = new Sender(this, parent.Encoding);
}
public bool StopListener(string listenerId, ListenerType type, string user)
{
var success = false;
if (type == ListenerType.HTTP)
{
success = HttpListenerController.StopHttpListener(listenerId, user);
}
else if (type == ListenerType.TCP)
{
success = TcpListenerController.StopTcpListener(listenerId, user);
}
return(success);
}
protected static void CloneAgentStagerSourceCode(ListenerType listenerType, string tempPath)
{
var srcPath = default(string);
switch (listenerType)
{
case ListenerType.HTTP:
srcPath = Path.Combine(AgentDirectory, "HTTPStager");
break;
case ListenerType.TCP:
srcPath = Path.Combine(AgentDirectory, "TCPStager");
break;
case ListenerType.SMB:
srcPath = Path.Combine(AgentDirectory, "SMBStager");
break;
default:
break;
}
// AgentType
var srcFiles = Directory.GetFiles(srcPath, "*.cs", SearchOption.AllDirectories);
foreach (var filePath in srcFiles)
{
if (filePath.Contains("AssemblyInfo.cs", StringComparison.OrdinalIgnoreCase) ||
filePath.Contains("AssemblyAttributes.cs", StringComparison.OrdinalIgnoreCase)) { continue; }
var fileName = Path.GetFileName(filePath);
var finalPath = tempPath + Path.DirectorySeparatorChar + fileName;
File.Copy(filePath, finalPath, true);
}
// Stager Core
srcPath = Path.Combine(AgentDirectory, "StagerCore");
foreach (var filePath in Directory.GetFiles(srcPath, "*.cs", SearchOption.AllDirectories))
{
var fileName = Path.GetFileName(filePath);
var finalPath = tempPath + Path.DirectorySeparatorChar + fileName;
if (File.Exists(finalPath))
{
fileName = fileName.Insert(fileName.Length - 3, Helpers.GeneratePseudoRandomString(6));
finalPath = tempPath + Path.DirectorySeparatorChar + fileName;
}
File.Copy(filePath, finalPath, true);
}
}
public ActionResult <HttpListener> GetActiveHttpListener(int id)
{
Listener listener = _context.Listeners.FirstOrDefault(L => L.Id == id);
if (listener == null)
{
return(NotFound($"NotFound - Listener with id: {id}"));
}
ListenerType listenerType = _context.ListenerTypes.FirstOrDefault(L => L.Id == listener.ListenerTypeId);
if (listenerType == null || listenerType.Name != "HTTP")
{
return(NotFound($"NotFound - ListenerType with id: {listener.ListenerTypeId}"));
}
return((HttpListener)listener);
}
/// <summary>
/// Sets the singleton instance. If the instance is already set, the method does not replace it.
/// </summary>
/// <param name="instance">the instance to set</param>
public void SetSingletonInstance(object instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
if (!ListenerType.IsAssignableFrom(instance.GetType()))
{
throw new ArgumentException(string.Format("Singleton instance must be of type {0}, but is of type {1}, which cannnot be assigned to {0}", ListenerType.FullName, instance.GetType().FullName));
}
if (ListenerInstance != null)
{
return;
}
ListenerInstance = instance;
}
private const int ReadTimeout = 500; //ms
public DBWinListener(ListenerType type)
{
mListenerType = type;
switch (mListenerType)
{
case ListenerType.DbWin32:
mBufferReadyName = "DBWIN_BUFFER_READY";
mDataReadyName = "DBWIN_DATA_READY";
mBufferName = "DBWIN_BUFFER";
break;
case ListenerType.GlobalDbWin32:
mBufferReadyName = "Global\\DBWIN_BUFFER_READY";
mDataReadyName = "Global\\DBWIN_DATA_READY";
mBufferName = "Global\\DBWIN_BUFFER";
break;
default:
throw new Exception("Not implemented");
}
}
private ListenerSettingsUDPPort m_UDPPortSettings; // Settings for the 'LogListenerForUDPPort' instance of listener
#endregion Fields
#region Constructors
public ListenerInstanceSettings()
{
this.m_StationId = "default";
this.m_ListenerType = ListenerType.UNDEFINED; // Set the default settings to be for unknown yet listiner
// Fill with default settings of 'LogListenerForSerialPort' object
this.m_SerialPortSettings.PortName = "COM1";
this.m_SerialPortSettings.BaudRate = 9600;
this.m_SerialPortSettings.DataBits = 8;
this.m_SerialPortSettings.Parity = System.IO.Ports.Parity.None;
this.m_SerialPortSettings.StopBits = System.IO.Ports.StopBits.One;
// Fill with default settings of 'LogListenerForTCPPort' object
this.m_TCPPortSettings.Address = System.Net.IPAddress.Parse("0.0.0.0");
this.m_TCPPortSettings.Port = 2020;
// Fill with default settings of 'LogListenerForUDPPort' object
this.m_UDPPortSettings.Address = System.Net.IPAddress.Parse("0.0.0.0");
this.m_UDPPortSettings.Port = 2020;
}
public System.Type GetListenerClassFor(ListenerType type)
{
System.Type result;
if (!eventInterfaceFromType.TryGetValue(type, out result))
throw new MappingException("Unrecognized listener type [" + type + "]");
return result;
}
public void Listen(ListenerType listenerType, Component component) {
Listen(listenerType, component.gameObject);
}
public void SetListeners(ListenerType type, object[] listeners);
/// <summary>
/// Adds the listeners to the interal store for application to the Configuration
/// </summary>
/// <param name="type"></param>
/// <param name="listeners"></param>
/// <returns></returns>
internal CustomListenerConfiguration AddListeners(ListenerType type, IEnumerable<object> listeners)
{
if (!this.listeners.ContainsKey(type))
this.listeners.Add(type, new List<object>());
foreach (var listener in listeners)
this.listeners[type].Add(listener);
return this;
}
public void SetListeners(ListenerType type, string[] listenerClasses);
/// <summary>
/// Initializes a new instance of the <see cref="ListenerConfiguration"/> class.
/// </summary>
/// <param name="clazz">The class full name.</param>
/// <param name="type">The listener type.</param>
/// <exception cref="ArgumentException">When <paramref name="clazz"/> is null or empty.</exception>
public ListenerConfiguration(string clazz, ListenerType type)
: this(clazz)
{
this.type = type;
}
public ListenerDisabler(ISession session, ListenerType type, object listener)
{
_session = session;
_type = type;
EventListeners eventListeners = _session.GetSessionImplementation().Listeners;
switch (type)
{
case ListenerType.Autoflush:
_autoFlushEventListeners = eventListeners.AutoFlushEventListeners;
eventListeners.AutoFlushEventListeners =
_autoFlushEventListeners.Where(eventListener => eventListeners != listener).ToArray();
break;
case ListenerType.Merge:
_mergeEventListeners = eventListeners.MergeEventListeners;
eventListeners.MergeEventListeners =
_mergeEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Create:
_persistEventListeners = eventListeners.PersistEventListeners;
eventListeners.PersistEventListeners =
_persistEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.CreateOnFlush:
_persistOnFlushEventListeners = eventListeners.PersistOnFlushEventListeners;
eventListeners.PersistOnFlushEventListeners =
_persistOnFlushEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Delete:
_deleteEventListeners = eventListeners.DeleteEventListeners;
eventListeners.DeleteEventListeners =
_deleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.DirtyCheck:
_dirtyCheckEventListeners = eventListeners.DirtyCheckEventListeners;
eventListeners.DirtyCheckEventListeners =
_dirtyCheckEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Evict:
_evictEventListeners = eventListeners.EvictEventListeners;
eventListeners.EvictEventListeners =
_evictEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Flush:
_flushEventListeners = eventListeners.FlushEventListeners;
eventListeners.FlushEventListeners =
_flushEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.FlushEntity:
_flushEntityEventListeners = eventListeners.FlushEntityEventListeners;
eventListeners.FlushEntityEventListeners =
_flushEntityEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Load:
_loadEventListeners = eventListeners.LoadEventListeners;
eventListeners.LoadEventListeners =
_loadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.LoadCollection:
_initializeCollectionEventListeners = eventListeners.InitializeCollectionEventListeners;
eventListeners.InitializeCollectionEventListeners =
_initializeCollectionEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Lock:
_lockEventListeners = eventListeners.LockEventListeners;
eventListeners.LockEventListeners =
_lockEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Refresh:
_refreshEventListeners = eventListeners.RefreshEventListeners;
eventListeners.RefreshEventListeners =
_refreshEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Replicate:
_replicateEventListeners = eventListeners.ReplicateEventListeners;
eventListeners.ReplicateEventListeners =
_replicateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.SaveUpdate:
_saveOrUpdateEventListeners = eventListeners.SaveOrUpdateEventListeners;
eventListeners.SaveOrUpdateEventListeners =
_saveOrUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Save:
_saveEventListeners = eventListeners.SaveEventListeners;
eventListeners.SaveEventListeners =
_saveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreUpdate:
_preUpdateEventListeners = eventListeners.PreUpdateEventListeners;
eventListeners.PreUpdateEventListeners =
_preUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.Update:
_updateEventListeners = eventListeners.UpdateEventListeners;
eventListeners.UpdateEventListeners =
_updateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreLoad:
_preLoadEventListeners = eventListeners.PreLoadEventListeners;
eventListeners.PreLoadEventListeners =
_preLoadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreDelete:
_preDeleteEventListeners = eventListeners.PreDeleteEventListeners;
eventListeners.PreDeleteEventListeners =
_preDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreInsert:
_preInsertEventListeners = eventListeners.PreInsertEventListeners;
eventListeners.PreInsertEventListeners =
_preInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostLoad:
_postLoadEventListeners = eventListeners.PostLoadEventListeners;
eventListeners.PostLoadEventListeners =
_postLoadEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostInsert:
_postInsertEventListeners = eventListeners.PostInsertEventListeners;
eventListeners.PostInsertEventListeners =
_postInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostUpdate:
_postUpdateEventListeners = eventListeners.PostUpdateEventListeners;
eventListeners.PostUpdateEventListeners =
_postUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostDelete:
_postDeleteEventListeners = eventListeners.PostDeleteEventListeners;
eventListeners.PostDeleteEventListeners =
_postDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitUpdate:
_postCommitUpdateEventListeners = eventListeners.PostCommitUpdateEventListeners;
eventListeners.PostCommitUpdateEventListeners =
_postCommitUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitInsert:
_postCommitInsertEventListeners = eventListeners.PostCommitInsertEventListeners;
eventListeners.PostCommitInsertEventListeners =
_postCommitInsertEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCommitDelete:
_postCommitDeleteEventListeners = eventListeners.PostCommitDeleteEventListeners;
eventListeners.PostCommitDeleteEventListeners =
_postCommitDeleteEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionRecreate:
_preCollectionRecreateEventListeners = eventListeners.PreCollectionRecreateEventListeners;
eventListeners.PreCollectionRecreateEventListeners =
_preCollectionRecreateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionRemove:
_preCollectionRemoveEventListeners = eventListeners.PreCollectionRemoveEventListeners;
eventListeners.PreCollectionRemoveEventListeners =
_preCollectionRemoveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PreCollectionUpdate:
_preCollectionUpdateEventListeners = eventListeners.PreCollectionUpdateEventListeners;
eventListeners.PreCollectionUpdateEventListeners =
_preCollectionUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionRecreate:
_postCollectionRecreateEventListeners = eventListeners.PostCollectionRecreateEventListeners;
eventListeners.PostCollectionRecreateEventListeners =
_postCollectionRecreateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionRemove:
_postCollectionRemoveEventListeners = eventListeners.PostCollectionRemoveEventListeners;
eventListeners.PostCollectionRemoveEventListeners =
_postCollectionRemoveEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
case ListenerType.PostCollectionUpdate:
_postCollectionUpdateEventListeners = eventListeners.PostCollectionUpdateEventListeners;
eventListeners.PostCollectionUpdateEventListeners =
_postCollectionUpdateEventListeners.Where(eventListener => eventListener != listener).ToArray();
break;
}
}
/// <summary>
/// Set or clear listeners for a given <see cref="ListenerType"/>.
/// </summary>
/// <param name="type">The <see cref="ListenerType"/>.</param>
/// <param name="listeners">The listener for <paramref name="type"/> or null to clear.</param>
/// <remarks>Listeners of <paramref name="listeners"/> must implements one of the interface of event listenesr.</remarks>
/// <seealso cref="NHibernate.Event"/>
public void SetListeners(ListenerType type, object[] listeners)
{
if (listeners == null)
ClearListeners(type);
switch (type)
{
case ListenerType.Autoflush:
eventListeners.AutoFlushEventListeners = (IAutoFlushEventListener[]) listeners;
break;
case ListenerType.Merge:
eventListeners.MergeEventListeners = (IMergeEventListener[])listeners;
break;
case ListenerType.Create:
eventListeners.PersistEventListeners = (IPersistEventListener[])listeners;
break;
case ListenerType.CreateOnFlush:
eventListeners.PersistOnFlushEventListeners = (IPersistEventListener[])listeners;
break;
case ListenerType.Delete:
eventListeners.DeleteEventListeners = (IDeleteEventListener[])listeners;
break;
case ListenerType.DirtyCheck:
eventListeners.DirtyCheckEventListeners = (IDirtyCheckEventListener[])listeners;
break;
case ListenerType.Evict:
eventListeners.EvictEventListeners = (IEvictEventListener[])listeners;
break;
case ListenerType.Flush:
eventListeners.FlushEventListeners = (IFlushEventListener[])listeners;
break;
case ListenerType.FlushEntity:
eventListeners.FlushEntityEventListeners = (IFlushEntityEventListener[])listeners;
break;
case ListenerType.Load:
eventListeners.LoadEventListeners = (ILoadEventListener[])listeners;
break;
case ListenerType.LoadCollection:
eventListeners.InitializeCollectionEventListeners = (IInitializeCollectionEventListener[])listeners;
break;
case ListenerType.Lock:
eventListeners.LockEventListeners = (ILockEventListener[])listeners;
break;
case ListenerType.Refresh:
eventListeners.RefreshEventListeners = (IRefreshEventListener[])listeners;
break;
case ListenerType.Replicate:
eventListeners.ReplicateEventListeners = (IReplicateEventListener[])listeners;
break;
case ListenerType.SaveUpdate:
eventListeners.SaveOrUpdateEventListeners = (ISaveOrUpdateEventListener[])listeners;
break;
case ListenerType.Save:
eventListeners.SaveEventListeners = (ISaveOrUpdateEventListener[])listeners;
break;
case ListenerType.PreUpdate:
eventListeners.PreUpdateEventListeners = (IPreUpdateEventListener[])listeners;
break;
case ListenerType.Update:
eventListeners.UpdateEventListeners = (ISaveOrUpdateEventListener[])listeners;
break;
case ListenerType.PreLoad:
eventListeners.PreLoadEventListeners = (IPreLoadEventListener[])listeners;
break;
case ListenerType.PreDelete:
eventListeners.PreDeleteEventListeners = (IPreDeleteEventListener[])listeners;
break;
case ListenerType.PreInsert:
eventListeners.PreInsertEventListeners = (IPreInsertEventListener[])listeners;
break;
case ListenerType.PostLoad:
eventListeners.PostLoadEventListeners = (IPostLoadEventListener[])listeners;
break;
case ListenerType.PostInsert:
eventListeners.PostInsertEventListeners = (IPostInsertEventListener[])listeners;
break;
case ListenerType.PostUpdate:
eventListeners.PostUpdateEventListeners = (IPostUpdateEventListener[])listeners;
break;
case ListenerType.PostDelete:
eventListeners.PostDeleteEventListeners = (IPostDeleteEventListener[])listeners;
break;
case ListenerType.PostCommitUpdate:
eventListeners.PostCommitUpdateEventListeners = (IPostUpdateEventListener[])listeners;
break;
case ListenerType.PostCommitInsert:
eventListeners.PostCommitInsertEventListeners = (IPostInsertEventListener[])listeners;
break;
case ListenerType.PostCommitDelete:
eventListeners.PostCommitDeleteEventListeners = (IPostDeleteEventListener[])listeners;
break;
default:
log.Warn("Unrecognized listener type [" + type + "]");
break;
}
}
/// <summary>
/// Set or clear listener for a given <see cref="ListenerType"/>.
/// </summary>
/// <param name="type">The <see cref="ListenerType"/>.</param>
/// <param name="listenerClasses">The array of AssemblyQualifiedName of each listener for <paramref name="type"/>.</param>
/// <remarks>
/// <paramref name="listenerClasses"/> must implements the interface related with <paramref name="type"/>.
/// All listeners of the given <see cref="ListenerType"/> will be cleared if the <paramref name="listenerClasses"/>
/// is null or empty.
/// </remarks>
/// <exception cref="MappingException">
/// when an element of <paramref name="listenerClasses"/> have an invalid value or cant be instantiated.
/// </exception>
public void SetListeners(ListenerType type, string[] listenerClasses)
{
if (listenerClasses == null || listenerClasses.Length == 0)
{
ClearListeners(type);
}
else
{
object[] listeners =
(object[]) System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), listenerClasses.Length);
for (int i = 0; i < listeners.Length; i++)
{
try
{
listeners[i] = Activator.CreateInstance(ReflectHelper.ClassForName(listenerClasses[i]));
}
catch (Exception e)
{
throw new MappingException(
"Unable to instantiate specified event (" + type + ") listener class: " + listenerClasses[i], e);
}
}
SetListeners(type, listeners);
}
}
/// <summary>
/// Set or clear listener for a given <see cref="ListenerType"/>.
/// </summary>
/// <param name="type">The <see cref="ListenerType"/>.</param>
/// <param name="listener">The listener for <paramref name="type"/> or null to clear.</param>
/// <remarks><paramref name="listener"/> must implements the interface related with <paramref name="type"/>.</remarks>
/// <seealso cref="NHibernate.Event"/>
public void SetListener(ListenerType type, object listener)
{
if (listener == null)
{
ClearListeners(type);
}
else
{
object[] listeners = (object[])System.Array.CreateInstance(eventListeners.GetListenerClassFor(type), 1);
listeners[0] = listener;
SetListeners(type, listeners);
}
}
public Message(ListenerType type) {
ListenerType = type;
FunctionName = "_" + GetType().Name.Substring(7);
}
public void SetListener(ListenerType type, object listener);
internal static string ListenerTypeConvertToString(ListenerType listenerType)
{
switch (listenerType)
{
case ListenerType.Autoflush:
return "auto-flush";
case ListenerType.Merge:
return "merge";
case ListenerType.Create:
return "create";
case ListenerType.CreateOnFlush:
return "create-onflush";
case ListenerType.Delete:
return "delete";
case ListenerType.DirtyCheck:
return "dirty-check";
case ListenerType.Evict:
return "evict";
case ListenerType.Flush:
return "flush";
case ListenerType.FlushEntity:
return "flush-entity";
case ListenerType.Load:
return "load";
case ListenerType.LoadCollection:
return "load-collection";
case ListenerType.Lock:
return "lock";
case ListenerType.Refresh:
return "refresh";
case ListenerType.Replicate:
return "replicate";
case ListenerType.SaveUpdate:
return "save-update";
case ListenerType.Save:
return "save";
case ListenerType.PreUpdate:
return "pre-update";
case ListenerType.Update:
return "update";
case ListenerType.PreLoad:
return "pre-load";
case ListenerType.PreDelete:
return "pre-delete";
case ListenerType.PreInsert:
return "pre-insert";
case ListenerType.PostLoad:
return "post-load";
case ListenerType.PostInsert:
return "post-insert";
case ListenerType.PostUpdate:
return "post-update";
case ListenerType.PostDelete:
return "post-delete";
case ListenerType.PostCommitUpdate:
return "post-commit-update";
case ListenerType.PostCommitInsert:
return "post-commit-insert";
case ListenerType.PostCommitDelete:
return "post-commit-delete";
case ListenerType.PreCollectionRecreate:
return "pre-collection-recreate";
case ListenerType.PreCollectionRemove:
return "pre-collection-remove";
case ListenerType.PreCollectionUpdate:
return "pre-collection-update";
case ListenerType.PostCollectionRecreate:
return "post-collection-recreate";
case ListenerType.PostCollectionRemove:
return "post-collection-remove";
case ListenerType.PostCollectionUpdate:
return "post-collection-update";
default:
return string.Empty;
}
}
private void ClearListeners(ListenerType type)
{
switch (type)
{
case ListenerType.Autoflush:
eventListeners.AutoFlushEventListeners = new IAutoFlushEventListener[] { };
break;
case ListenerType.Merge:
eventListeners.MergeEventListeners = new IMergeEventListener[] { };
break;
case ListenerType.Create:
eventListeners.PersistEventListeners = new IPersistEventListener[] { };
break;
case ListenerType.CreateOnFlush:
eventListeners.PersistOnFlushEventListeners = new IPersistEventListener[] { };
break;
case ListenerType.Delete:
eventListeners.DeleteEventListeners = new IDeleteEventListener[] { };
break;
case ListenerType.DirtyCheck:
eventListeners.DirtyCheckEventListeners = new IDirtyCheckEventListener[] { };
break;
case ListenerType.Evict:
eventListeners.EvictEventListeners = new IEvictEventListener[] { };
break;
case ListenerType.Flush:
eventListeners.FlushEventListeners = new IFlushEventListener[] { };
break;
case ListenerType.FlushEntity:
eventListeners.FlushEntityEventListeners = new IFlushEntityEventListener[] { };
break;
case ListenerType.Load:
eventListeners.LoadEventListeners = new ILoadEventListener[] { };
break;
case ListenerType.LoadCollection:
eventListeners.InitializeCollectionEventListeners = new IInitializeCollectionEventListener[] { };
break;
case ListenerType.Lock:
eventListeners.LockEventListeners = new ILockEventListener[] { };
break;
case ListenerType.Refresh:
eventListeners.RefreshEventListeners = new IRefreshEventListener[] { };
break;
case ListenerType.Replicate:
eventListeners.ReplicateEventListeners = new IReplicateEventListener[] { };
break;
case ListenerType.SaveUpdate:
eventListeners.SaveOrUpdateEventListeners = new ISaveOrUpdateEventListener[] { };
break;
case ListenerType.Save:
eventListeners.SaveEventListeners = new ISaveOrUpdateEventListener[] { };
break;
case ListenerType.PreUpdate:
eventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { };
break;
case ListenerType.Update:
eventListeners.UpdateEventListeners = new ISaveOrUpdateEventListener[] { };
break;
case ListenerType.PreLoad:
eventListeners.PreLoadEventListeners = new IPreLoadEventListener[] { };
break;
case ListenerType.PreDelete:
eventListeners.PreDeleteEventListeners = new IPreDeleteEventListener[] { };
break;
case ListenerType.PreInsert:
eventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { };
break;
case ListenerType.PostLoad:
eventListeners.PostLoadEventListeners = new IPostLoadEventListener[] { };
break;
case ListenerType.PostInsert:
eventListeners.PostInsertEventListeners = new IPostInsertEventListener[] { };
break;
case ListenerType.PostUpdate:
eventListeners.PostUpdateEventListeners = new IPostUpdateEventListener[] { };
break;
case ListenerType.PostDelete:
eventListeners.PostDeleteEventListeners = new IPostDeleteEventListener[] { };
break;
case ListenerType.PostCommitUpdate:
eventListeners.PostCommitUpdateEventListeners = new IPostUpdateEventListener[] { };
break;
case ListenerType.PostCommitInsert:
eventListeners.PostCommitInsertEventListeners = new IPostInsertEventListener[] { };
break;
case ListenerType.PostCommitDelete:
eventListeners.PostCommitDeleteEventListeners = new IPostDeleteEventListener[] { };
break;
default:
log.Warn("Unrecognized listener type [" + type + "]");
break;
}
}
public void AppendListeners(ListenerType type, object[] listeners);
internal ListenerConfiguration(XPathNavigator listenerElement, ListenerType defaultType)
{
type = defaultType;
Parse(listenerElement);
}
