/// <summary> /// ger config function /// </summary> /// <param name="sender"></param> /// <param name="msg"></param> private void getConf(object sender, DataInfo msg) { if (msg.Id == CommandEnum.GetConfigCommand) { string[] arr = JsonConvert.DeserializeObject <string[]>(msg.Args); OutputDir = arr[1]; SourceName = arr[2]; LogName = arr[3]; ThumbnailSize = (string)arr[4]; string hanslersToSplit = arr[0]; string[] temp = hanslersToSplit.Split(';'); Handlers.Clear(); foreach (string item in temp) { Handlers.Add(item); } ifConfUpdate = true; } }
public SpectrumNextPortDevice() { Handlers.Add(new Spectrum48PortHandler(this)); _memoryPortHandler = new SpectrumP3MemoryPagePortHandler(this); _extMemoryPortHandler = new SpectrumP3ExtMemoryPagePortHandler(this); _memoryPortHandler.RomLowSelectionChanged += (sender, args) => _extMemoryPortHandler.SelectRomLow = (byte)sender; _memoryPortHandler.LastSlot3IndexChanged += (sender, args) => _extMemoryPortHandler.LastSlot3Index = (int)sender; Handlers.Add(_memoryPortHandler); _extMemoryPortHandler.RomHighSelectionChanged += (sender, args) => _memoryPortHandler.SelectRomHigh = (byte)sender; Handlers.Add(_extMemoryPortHandler); Handlers.Add(new NextRegisterSelectPortHandler(this)); Handlers.Add(new NextRegisterAccessPortHandler(this)); Handlers.Add(new SoundRegisterIndexPortHandler(this)); Handlers.Add(new SoundRegisterValuePortHandler(this)); Handlers.Add(new DivIdeControlPortHandler(this)); }
public SpectrumP3PortDevice() { Handlers.Add(new Spectrum48PortHandler(this)); _memoryPortHandler = new SpectrumP3MemoryPagePortHandler(this); _extMemoryPortHandler = new SpectrumP3ExtMemoryPagePortHandler(this); _memoryPortHandler.RomLowSelectionChanged += (sender, args) => _extMemoryPortHandler.SelectRomLow = (byte)sender; _memoryPortHandler.LastSlot3IndexChanged += (sender, args) => _extMemoryPortHandler.LastSlot3Index = (int)sender; Handlers.Add(_memoryPortHandler); _extMemoryPortHandler.RomHighSelectionChanged += (sender, args) => _memoryPortHandler.SelectRomHigh = (byte)sender; Handlers.Add(_extMemoryPortHandler); Handlers.Add(new SoundRegisterIndexPortHandler(this)); Handlers.Add(new SoundRegisterValuePortHandler(this)); Handlers.Add(new SpectrumP3FloatingPointBusPortHandler(this)); Handlers.Add(new SpectrumP3FloppyStatusPortHandler(this)); Handlers.Add(new SpectrumP3FloppyCommandPortHandler(this)); }
public bool Handle(byte[] firstPacket, int length, Socket socket, object state) { if (socket.ProtocolType != ProtocolType.Tcp) { return(false); } if (length < 2 || firstPacket[0] != 5) { return(false); } socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); TCPHandler handler = new TCPHandler(this); handler.connection = socket; handler.relay = this; handler.Start(firstPacket, length); IList <TCPHandler> handlersToClose = new List <TCPHandler>(); lock (Handlers) { Handlers.Add(handler); DateTime now = DateTime.Now; if (now - _lastSweepTime > TimeSpan.FromSeconds(1)) { _lastSweepTime = now; foreach (TCPHandler handler1 in Handlers) { if (now - handler1.lastActivity > TimeSpan.FromSeconds(900)) { handlersToClose.Add(handler1); } } } } foreach (TCPHandler handler1 in handlersToClose) { Logging.Debug("Closing timed out TCP connection."); handler1.Close(); } return(true); }
/// <summary> /// receiving a configuration. /// </summary> /// <param name="sender">the sender of the massage</param> /// <param name="msg">the configurations that reseived </param> public void OnConfigRecieved(object sender, MessageEventArgs msg) { // Parsing the message string message = msg.Message; JObject obj = JObject.Parse(message); // Updating the configuration field OutputDir = obj["OutputDir"].ToString(); SourceName = obj["SourceName"].ToString(); LogName = obj["LogName"].ToString(); int.TryParse(obj["ThumbnailSize"].ToString(), out int thumbnailSize); ThumbnailSize = thumbnailSize; // Parsing the handlers Paths string[] handlerPaths = JsonConvert.DeserializeObject <string[]>(obj["HandlersPaths"].ToString()); // Adding each handler to the Handlers list foreach (string path in handlerPaths) { Handlers.Add(path); } }
private static bool DeserializeHandlers(GenericReader reader) { var list = reader.ReadBlockArray(() => reader.ReadTypeCreate <BaseTrashHandler>(reader)); list.ForEach( h => { if (!Handlers.ContainsKey(h.UID)) { Handlers.Add(h.UID, h); } else { Handlers[h.UID] = h; } }); InternalHandlerSort(); return(true); }
public MucRoomMember(MucRoom room, Jid memberJid, Jid realJid, XmppStream stream, XmppHandlerContext context) { if (room == null) { throw new ArgumentNullException("room"); } if (memberJid == null) { throw new ArgumentNullException("memberJid"); } if (realJid == null) { throw new ArgumentNullException("realJid"); } if (context == null) { throw new ArgumentNullException("sender"); } this.room = room; this.stream = stream; this.context = context; this.sender = context.Sender; //Register disconect context.SessionManager.SessionUnavailable += SessionManager_SessionUnavailable; ParentService = room; RealJid = realJid; Jid = memberJid; Name = memberJid.Resource; presenceType = PresenceType.unavailable; //Create handler lock (Handlers) { Handlers.Add(new MucRoomMemberStanzaHandler(this)); Handlers.Add(new MucRoomMemberDiscoHandler(Jid, RealJid)); } DiscoInfo.AddIdentity(new DiscoIdentity("text", Name, "member")); DiscoInfo.AddFeature(new DiscoFeature(Core.protocol.Uri.DISCO_INFO)); DiscoInfo.AddFeature(new DiscoFeature(Core.protocol.Uri.DISCO_ITEMS)); }
/// <summary> /// Recieves command from server. /// </summary> /// <param name="commandRead">The command recieved arguments.</param> private void ServerCommandRecieved(CommandRecievedEventArgs commandRead) { //GetConfigCommand recieved. We set the correct properties and add the handlers to the Handlers ObservableCollection. if (commandRead != null && commandRead.CommandID == (int)CommandEnum.GetConfigCommand) { OutputDir = commandRead.Args[0]; SourceName = commandRead.Args[1]; LogName = commandRead.Args[2]; ThumbnailSize = commandRead.Args[3]; Object thisLock = new Object(); BindingOperations.EnableCollectionSynchronization(Handlers, thisLock); if (commandRead.Args[4] != "") { string[] handlers = commandRead.Args[4].Split(';'); foreach (string handler in handlers) { if (handler != "") { App.Current.Dispatcher.Invoke((Action) delegate { Handlers.Add(handler); }); } } } } //CloseCommand recieved. We remove the given handler from the Handlers ObservableCollection. else if (commandRead != null && commandRead.CommandID == (int)CommandEnum.CloseCommand) { Object thisLock = new Object(); BindingOperations.EnableCollectionSynchronization(Handlers, thisLock); if (Handlers.Contains(commandRead.Args[0])) { App.Current.Dispatcher.Invoke((Action) delegate { Handlers.Remove(commandRead.Args[0]); }); } } }
public void ProcessMessage(object sender, CommandMessageEventArgs e) { //Extract the message from the EventArgs CommandMessage msg = e.Message; switch (msg.Type) { //Checking if the message is interesting to the Settings case CommandEnum.AddHandler: foreach (string handler in msg.Handlers) { Handlers.Add(handler); } NotifyPropertyChanged("Handlers"); break; case CommandEnum.RemoveHandler: foreach (string handler in msg.Handlers) { Handlers.Remove(handler); } NotifyPropertyChanged("Handlers"); break; case CommandEnum.ConfigMessage: OutputDir = msg.OutputDir; SourceName = msg.LogSource; LogName = msg.LogName; ThumSize = msg.ThumbSize.ToString(); foreach (string handler in msg.Handlers) { Handlers.Add(handler); } NotifyPropertyChanged("Handlers"); break; default: break; } }
/// <summary> /// This method initialize the config involves members /// </summary> /// <param name="settings"></param> public void InitializeConfig(string[] settings) { try { Application.Current.Dispatcher.Invoke(new Action(() => { OutputDirectory = settings[0]; SourceName = settings[1]; LogName = settings[2]; ThumbnailSize = int.Parse(settings[3]); for (int i = 4; i < settings.Length; i++) { Handlers.Add(settings[i]); } })); } catch (Exception e) { Console.WriteLine(e.Message); } }
protected void When( Func <Exception, bool> condition, Func <ResilientOperation, Exception, Task> handler) { Handlers.Add(async(op, ex) => { op.Result = HandlerResult.Unhandled; if (condition(ex)) { await handler(op, ex).ConfigureAwait(false); if (op.Result == HandlerResult.Handled) { op.Handler.AttemptsExhausted++; op.Total.AttemptsExhausted++; } } return(op.Result); }); }
/// <summary> /// Updating our settings configuration /// </summary> /// <param name="sender"> Event sender</param> /// <param name="msg"> The message recived from server</param> public void SettingsConfigRecieved(object sender, MessageEventArgs msg) { // Clearing our list each refresh Handlers.Clear(); // Parsing our message string message = msg.Message; JObject obj = JObject.Parse(message); // Updating each configuratoin field Output = obj["Output"].ToString(); SourceName = obj["SourceName"].ToString(); LogName = obj["LogName"].ToString(); int.TryParse(obj["thumbnailSize"].ToString(), out int thumbnailSize); ThumbnailSize = thumbnailSize; // Parsing our handlerPaths string[] handlerPaths = JsonConvert.DeserializeObject <string[]>(obj["handlersPaths"].ToString()); // Adding each one to our observable collection list foreach (string str in handlerPaths) { Handlers.Add(str); } }
public void InitializeConfig(string[] settings) { try { OutputDirectory = settings[0]; SourceName = settings[1]; LogName = settings[2]; ThumbnailSize = int.Parse(settings[3]); for (int i = 4; i < settings.Length; i++) { if (settings[i] != null) { Handlers.Add(settings[i]); } } } catch (Exception e) { Console.WriteLine(e.Message); } }
/// <summary> /// construct a HttpRequestHandler with the path to handle /// </summary> /// <param name="name">the name of the handler</param> /// <param name="type">the type (data type) the handler handles</param> /// <param name="path">the path in url must start with "/"</param> /// <param name="credentials">user credentials in the format user:password and separated by comma</param> protected HttpServiceRequestHandler(string name, string type, string path, string credentials) { Name = name; Type = type; Path = path; if (Handlers.ContainsKey(path)) { Handlers[path] = this; } else { Handlers.Add(path, this); } if (!string.IsNullOrEmpty(credentials)) { _encodedCredentials = new HashSet <string>(); string[] parts = credentials.Split(CommaDelimiter); foreach (string part in parts) { _encodedCredentials.Add("Basic " + EncodeCredential(part.Trim())); } } }
public Receiver() { var type = GetType(); foreach (var method in type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic) .Where(p => p.ReturnType == typeof(void))) { var attribute = method.GetCustomAttribute <MessageHandlerAttribute>(); if (attribute != null) { if (Handlers.ContainsKey(attribute.Name)) { throw new ArgumentException($"Message '{attribute.Name}' already registered."); } var handler = method.CreateDelegate( Expression.GetDelegateType(method.GetParameters() .Select(p => p.ParameterType).Concat(new[] { method.ReturnType }).ToArray() ), this); Handlers.Add(attribute.Name, handler); } } }
public IAsyncEventHandler CreateHandler(Func <TArg, Task> handler, [CallerFilePath] string callerFile = null, [CallerLineNumber] int line = 0) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } lock (Handlers) { RemoveHandler(handler); var result = new AsyncEventTaskHandler <TArg> { Action = handler, Event = this, Caller = Debugger.IsAttached ? $"{callerFile}:{line}" : string.Empty }; Handlers.Add(result); return(result); } }
/// <summary> /// UpdateConfigurations function. /// updates app config params. /// </summary> /// <param name="responseObj">the info came from srv</param> private void UpdateConfigurations(CommandRecievedEventArgs responseObj) { try { OutputDirectory = responseObj.Args[0]; SourceName = responseObj.Args[1]; LogName = responseObj.Args[2]; int num; int.TryParse(responseObj.Args[3], out num); ThumbnailSize = num; string[] handlers = responseObj.Args[4].Split(';'); foreach (string handler in handlers) { if (!Handlers.Contains(handler)) { Handlers.Add(handler); } } } catch (Exception ex) { } }
public override void Configure(IDictionary <string, string> properties) { DiscoInfo.AddIdentity(new DiscoIdentity("server", Name, "im")); Handlers.Add(new ClientNamespaceHandler()); Handlers.Add(new AuthDigestMD5Handler()); Handlers.Add(new AuthTMTokenHandler()); Handlers.Add(new BindSessionHandler()); Handlers.Add(new RosterHandler()); Handlers.Add(new VCardHandler()); Handlers.Add(new VerTimePingHandler()); Handlers.Add(new PrivateHandler()); Handlers.Add(new PresenceHandler()); Handlers.Add(new MessageHandler()); Handlers.Add(new MessageArchiveHandler()); Handlers.Add(new LastHandler()); Handlers.Add(new RegisterHandler()); Handlers.Add(new TransferHandler()); Handlers.Add(new CommandHandler()); Handlers.Add(new OfflineProvider(Jid)); Handlers.Add(new DiscoHandler(Jid)); messageAnnounceHandler = new MessageAnnounceHandler(); }
public override bool Handle(byte[] firstPacket, int length, SocketProxy socket, object state) { if (NotCompatible(firstPacket, length, socket)) { return(false); } socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); var handler = TCPHandlerFactory(_controller, _config, this, socket); var handlersToClose = Enumerable.Empty <ITCPHandler>(); lock (Handlers) { Handlers.Add(handler); var now = DateTime.Now; if (NeedSweepTimeoutHandlers(now)) { _lastSweepTime = now; handlersToClose = GetTimeoutHandlersList(now); } } foreach (var timeoutHandler in handlersToClose) { Logging.Debug("Closing timed out TCP connection."); timeoutHandler.Close(); } /* * Start after we put it into Handlers set. Otherwise if it failed in handler.Start() * then it will call handler.Close() before we add it into the set. * Then the handler will never release until the next Handle call. Sometimes it will * cause odd problems (especially during memory profiling). */ handler.Start(firstPacket, length); return(true); }
/// <summary> /// Contains features, properties and events regarding the charging bays and the devices inserted into the bays. /// </summary> public Chg4NBaysHandler(SscCommon common) : base(common) { for (int i = 0; i < _bays.Length; i++) { _bays[i] = new Chg4NBay(); } Handlers.Add("active", HandleActive); Handlers.Add("serial", HandleSerial); Handlers.Add("charging", HandleCharging); Handlers.Add("bat_gauge", HandleBatteryGauge); Handlers.Add("bat_health", HandleBatteryHealth); Handlers.Add("bat_timetofull", HandleBatteryTimeToFull); Handlers.Add("device_type", HandleDeviceType); Subscribe(BaseProperty, "active"); Subscribe(BaseProperty, "serial"); Subscribe(BaseProperty, "charging"); Subscribe(BaseProperty, "bat_gauge"); Subscribe(BaseProperty, "bat_timetofull"); Subscribe(BaseProperty, "bat_health"); Subscribe(BaseProperty, "device_type"); }
public virtual void WireDefaultHandlers() { // Insert pre-handlers in the reverse order. Handlers.Insert(0, new RequestFormatHandler()); Handlers.Insert(0, new RouteResolutionHandler()); Handlers.Insert(0, new HttpStatusHandler()); Handlers.Insert(0, new ResponseFormatHandler()); #if DEBUG Handlers.Insert(0, new TraceHandler()); #endif Handlers.Insert(0, new ErrorHandler()); // Buffered stream handler has to be after error handling so that buffered streams can be copied back. if (UseBufferedResponse || UseBufferedRequest) { Handlers.Insert(0, new BufferedStreamHandler()); } Handlers.Insert(0, new ThrottleHandler()); // Add the final handlers after the user handlers. Handlers.Add(new RouteInvocationHandler()); isDefaultHandlerListWired = true; }
public void Add <TEvent, TEventHandler>() where TEvent : Event where TEventHandler : IEventHandler <TEvent> { var eventType = typeof(TEvent); EventTypes.Add(eventType); var handlerType = typeof(TEventHandler); var eventName = eventType.Name; if (Handlers.ContainsKey(eventName)) { var handler = Handlers[eventName]; var isRegistered = handler.Types.Any(s => s.GetType() == handlerType); Ensure.That <ArgumentException>(isRegistered, $"Handler Type {handlerType.Name} already is registered for '{eventName}'"); } var newType = EventTypes.New(); newType.Add(handlerType); Handlers.Add(eventName, newType); }
public void LoadHandlerFromType(Type type) { try { if (!typeof(AttributeHandler).IsAssignableFrom(type)) { return; } if (type.IsAbstract) { return; } var handlerobject = Activator.CreateInstance(type); if (!(handlerobject is AttributeHandler handler)) { return; } if (string.IsNullOrWhiteSpace(handler.Name)) { return; } if (Handlers.Any(x => x.Name.ToLower() == handler.Name.ToLower())) { return; } Handlers.Add(handler); handler.Init(); } catch (Exception ex) { Logger.Get.Debug($"Synapse-Objects: Type {type?.Name} could not be loaded as AttributeHandler\n{ex}"); } }
/// <summary> /// Contains features, properties and events regarding meters, such as azimuth, elevation and input peak level. /// </summary> public Tcc2MeterHandler(SscCommon common) : base(common) { Handlers.Add("beam", HandleBeam); Handlers.Add("in1", HandleIn); }
protected void given_handler <T>() { Handlers = Handlers ?? new List <IType>(); Handlers.Add(TypeSystem.FromClr <T>()); }
public Spectrum48PortDevice() { IPortHandler handler = new Spectrum48PortHandler(this); Handlers.Add(handler); }
public Spectrum48PortDevice() { Handlers.Add(new Spectrum48PortHandler(this)); Handlers.Add(new KempstonJoystickPortHandler(this)); }
public void RegisterHandler(RightHandler <RightOption> handler) { Handlers.Add(handler); }
/// <summary> /// add handler to the list. /// </summary> /// <param name="handler">handler</param> public void addHandler(string handler) { Handlers.Add(handler); }
static InstrumentDetector() { Handlers.Add(InstrumentTypeEnum.Guitar, Guitar); Handlers.Add(InstrumentTypeEnum.PureSound, PureSound); }