public static IMessageReceiver removeReciever(IMessageReceiver group, IMessageReceiver remove) { if (group == null) throw new Exception("Receiver not found!"); if (remove == group) return null; else if (group is DoubleReceiver) { DoubleReceiver dual = (DoubleReceiver)group; IMessageReceiver newone = removeReciever(dual.one, remove); IMessageReceiver newtwo = removeReciever(dual.two, remove); if (newone != null && newtwo != null) { dual.one = newone; dual.two = newtwo; return dual; } else if (newone != null) return newone; else if (newtwo != null) return newtwo; else return null; } else return group; }
public ServiceBusCollector(IMessageReceiver messageReceiver) { receiverCancellationTokenSource = new CancellationTokenSource(); receiveWaitTime = TimeSpan.FromMinutes(1); receiver = messageReceiver; stopped = new ManualResetEventSlim(false); }
public static IMessageReceiver addReceiver(IMessageReceiver group, IMessageReceiver add) { if (group == null) return add; return new DoubleReceiver(add, group); }
/// <param name="instanceId">The unique name of this worker.</param> /// <param name="messageReceiver">The receiver set up to listen for incoming trigger update notifications.</param> /// <param name="notificationBuffer">The buffer to which the worker will write all received trigger update notifications.</param> public TriggerNotificationQueueMonitor(string instanceId, IMessageReceiver messageReceiver, BlockingCollection<TriggerUpdateNotification> notificationBuffer) : base(instanceId, messageReceiver) { if (notificationBuffer == null) throw new ArgumentNullException("notificationBuffer"); _notificationBuffer = notificationBuffer; }
public void CreateBus() { m_Sender = Substitute.For<IMessageSender>(); m_Receiver = Substitute.For<IMessageReceiver>(); m_Bus = new MessageBus(m_Sender, m_Receiver); }
internal void RemoveReceiver(IMessageReceiver r) { lock (inbox) { inbox.Remove(r); } }
/// <summary> /// Parameterized Constructor. /// </summary> public MessageProcessor(IMessageReceiver receiver, IMessageExecutor executor) { this.receiver = receiver; this.executor = executor; this.broker = MessageBrokerFactory.Instance.GetOrCreate("message"); }
public static void RegisterReceiver(IMessageReceiver Receiver) { if (!Receivers.Contains(Receiver)) { Receivers.Add(Receiver); Debug.Log("Added new Message Receiver"); } }
/// <summary> /// Create a new coderack /// </summary> public Coderack(IMessageReceiver receiver) { codelets = new SalienceTree<Codelet>(); isEvaluating = new DescriptorCodelet(this, "evaluating"); isCompleting = new DescriptorCodelet(this, "completing"); watching = false; this.receiver = receiver; }
/// <summary> /// Initializes a new instance of the <see cref="NmqMessageServer"/> class. /// </summary> /// <param name="messageReceiver">The message receiver.</param> /// <param name="port">The port.</param> internal NmqMessageServer(IMessageReceiver messageReceiver, int port) { tokenSource = new CancellationTokenSource(); this.port = port; this.messageReceiver = messageReceiver; context = NetMQContext.Create(); responseQueue = new NmqResponseQueue(context, port); }
// Add the plugins actions and data source public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { env.SetDataSource(PartTypeSourceName, new Sentence(new List<KeyValuePair<string, string>>())); env.AddAction(new StringParseHandler(env)); env.AddAction(new EnumerableParseHandler()); env.AddAction(new ParaphraseHandler(env)); return InitializeResult.Success(); }
public CommandProcessor( IMessageReceiver messageReceiver, ICommandRouter commandRouter, ITextSerializer serializer) { _messageReceiver = messageReceiver; _commandRouter = commandRouter; _serializer = serializer; }
public TransactionMonitorWorker(string instanceId, IMessageReceiver messageReceiver, IAuditRepository repository) : base(instanceId, messageReceiver) { if(repository == null) throw new ArgumentNullException("repository"); _repository = repository; _deserializer = new TransactionEventConverter(); }
public WorkloadQueueMonitor(string instanceId, IMessageReceiver messageReceiver, IMessagePublisher statusPublisher, int httpWorkerCount) : base(instanceId, messageReceiver) { if(statusPublisher == null) throw new ArgumentNullException("statusPublisher"); _batchQueue = new ConcurrentQueue<WorkloadBatchMessage>(); _httpWorkerCount = httpWorkerCount; _statusPublisher = statusPublisher; }
protected QueueMonitorWorker(string instanceId, IMessageReceiver messageReceiver) { if (instanceId == null) throw new ArgumentNullException("instanceId"); if (messageReceiver == null) throw new ArgumentNullException("messageReceiver"); InstanceId = instanceId; Receiver = messageReceiver; }
public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // Data files contained in [datadrectory]/wordnet string basedir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "morpho" + Path.DirectorySeparatorChar; InitializeNouns(env, basedir); InitializeVerbs(env, basedir); return InitializeResult.Success(); }
public WndProcRouter (Control control, IMessageReceiver receiver) { if (control == null) throw new ArgumentNullException ("control"); if (receiver == null) throw new ArgumentNullException ("receiver"); _oldTarget = control.WindowTarget; _control = control; _receiver = receiver; }
// Add the plugins actions and data source public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // Data files contained in [datadrectory]/parser string parserdir = env.GetConfigDirectory("datadirectory") + Path.DirectorySeparatorChar + "parser" + Path.DirectorySeparatorChar; POSTagger tagger = new POSTagger(parserdir + "lexicon_all", parserdir + "ruleset", assembly, null); env.SetDataSource<string, string[]>(LanguageNet.Grammarian.POSTagger.PartsSourceName, tagger); env.AddAction(new EnumerableTagHandler(tagger)); env.AddAction(new PhraseResolveHandler(tagger)); env.AddAction(new StringTagHandler(tagger)); return InitializeResult.Success(); }
public ChangeZoneMsg( IMessageSender sender, IMessageReceiver receiver, Entity entity, string destZone, Point destPosition, int sendTime) : base(MessageType.ChangeZone, sender, receiver, sendTime) { Entity = entity; DestZone = destZone; DestPosition = destPosition; }
public void CreateBus() { m_Sender = Substitute.For<IMessageSender>(); m_Receiver = Substitute.For<IMessageReceiver>(); m_MessageList = Substitute.For<IMessageRegistrationList>(); m_MessageList.Messages.Returns(new List<Type> { typeof(TestMessage) }); m_Bus = new MessageBus(m_Sender, m_Receiver, m_MessageList); }
public InitializeResult Initialize(PluginEnvironment env, Assembly assembly, IMessageReceiver receiver) { // register data sources for WordNet env.SetDataSource<string, long[]>(WordNetAccess.NounIndexSourceName, nounSynonyms); env.SetDataSource<string, long[]>(WordNetAccess.VerbIndexSourceName, verbSynonyms); env.SetDataSource<string, long[]>(WordNetAccess.AdjIndexSourceName, adjSynonyms); env.SetDataSource<string, long[]>(WordNetAccess.AdvIndexSourceName, advSynonyms); env.SetDataSource<long, WordNetDefinition>(WordNetAccess.NounDefinitionSourceName, nounSynonyms); env.SetDataSource<long, WordNetDefinition>(WordNetAccess.VerbDefinitionSourceName, verbSynonyms); env.SetDataSource<long, WordNetDefinition>(WordNetAccess.AdjDefinitionSourceName, adjSynonyms); env.SetDataSource<long, WordNetDefinition>(WordNetAccess.AdvDefinitionSourceName, advSynonyms); return InitializeResult.Success(); }
public void Play(IMessageReceiver receiver, PlaybackOptions options) { // this.dyoW602sJA = receiver; // this.NC2WHwLVfD = options != null ? new twdoksMNpxZIumpxuq(options) : new twdoksMNpxZIumpxuq(new PlaybackOptions()); // if (Environment.Is64BitProcess) // { // this.xJaWIK04pm = 0; // q5MvANBnPa6CFYed7NI.Vh1gSi0InU(this.path, (string) null, 0U, 0U, new DVPVC6BSxkKNJHTPTfU(this.pRAW3TVs6Y)); // } // else // { // this.xJaWIK04pm = 0; // nmD5uEBtLJoqZgMkfld.hvoPYknI3d(this.path, (string) null, 0U, 0U, new TEOWwGRGb1uR7wafRG(this.ak2WwU46ee)); // } }
public MessagePump( IClock clock, IDispatchContextManager dispatchContextManager, ILogger logger, IMessageDispatcher messageDispatcher, IMessageReceiver receiver, ITaskFactory taskFactory) { _clock = clock; _dispatchContextManager = dispatchContextManager; _logger = logger; _messageDispatcher = messageDispatcher; _receiver = receiver; _taskFactory = taskFactory; }
internal void EnqueueMessage(IMessageReceiver target, Message msg) { List<Message> mailbox; lock (inbox) { if (!inbox.TryGetValue(target, out mailbox)) { mailbox = new List<Message>(); inbox[target] = mailbox; } } lock (mailbox) { mailbox.Add(msg); } }
public StreamingGateway(IMessageReceiver receiver) { _receiver = receiver; _parsers = new Dictionary<MessageTypes, IParser>() { {MessageTypes.BoatLocation, new BoatLocation()}, {MessageTypes.Heartbeat, new Heartbeat()}, {MessageTypes.DisplayTextMessage, new DisplayTextMessage()}, {MessageTypes.XmlMessage, new XmlMessage()}, {MessageTypes.RaceStartStatus, new RaceStartStatus()}, {MessageTypes.YachtEventCode, new YachtEventCode()}, {MessageTypes.RaceStatus, new RaceStatusMessage()}, {MessageTypes.YachtActionCode, new YachtActionCode()}, {MessageTypes.ChatterText, new ChatterText()}, {MessageTypes.MarkRounding, new MarkRounding()} }; }
public MainViewModel(IMessageSender messageSender, IMessageReceiver messageReceiver) { mDungeonCrawlMessageSender = new DungeonCrawlMessageSender(messageSender); mMessageReceiver = messageReceiver; RegAccountCommand = new RelayCommand(() => { mDungeonCrawlMessageSender.RegAccount(Name, Pass, Email); mDungeonCrawlMessageSender.SetCookie(); }); SendChatMessageCommand = new RelayCommand(() => mDungeonCrawlMessageSender.SendChatMessage(ChatMessage)); LoginAccountCommand = new RelayCommand(() => { mDungeonCrawlMessageSender.LoginAccount(Name, Pass); mDungeonCrawlMessageSender.SetCookie(); }); EnterGameCommand = new RelayCommand(() => mDungeonCrawlMessageSender.EnterGame(PlayerName)); GoLobbyCommand = new RelayCommand(() => mDungeonCrawlMessageSender.GoLobby()); }
public ToolArguments(string[] args, string docsUrl, IMessageReceiver receiver) : base(args) { if (Parameters["h"] != null || Parameters["help"] != null) Console.WriteLine("The documentation is currently at \n" + docsUrl); if (Parameters["c"] == null && Parameters["conf"] == null) { Console.WriteLine("The -c/-conf argument is required. See\n" + docsUrl); return; } plugenv = new PluginEnvironment(receiver); string config = Parameters["c"] == null ? Parameters["conf"] : Parameters["c"]; if (!File.Exists(config)) { Console.WriteLine("Cannot find configuration file at " + config); return; } plugenv.Initialize(config, null); if (Parameters["i"] != null) input = new StringReader(Parameters["i"]); else if (Parameters["if"] != null) input = new StreamReader(Parameters["if"]); }
public static (NetworkPlayer serverPlayer, NetworkPlayer clientPlayer) PipedConnections(IMessageReceiver clientMessages, IMessageReceiver serverMessages) { // we can re-use networkclient's handlers here as it just needs connection and player var clientHandler = new NetworkClient.DataHandler(clientMessages); var serverHandler = new NetworkClient.DataHandler(serverMessages); (var clientConn, var serverConn) = PipePeerConnection.Create(clientHandler, serverHandler, null, null); var clientPlayer = new NetworkPlayer(clientConn); var serverPlayer = new NetworkPlayer(serverConn); // give connections to each other so they can invoke handlers clientHandler.SetConnection(clientConn, clientPlayer); serverHandler.SetConnection(serverConn, serverPlayer); return(serverPlayer, clientPlayer); }
public void setReceiver(IMessageReceiver receiver) { this.receiver = receiver; }
public ServiceBusOperationsReceiverTelemetryDecorator(ServiceBusOperationsReceiver receiver, ITelemetryPublisher telemetryPublisher) { _receiver = receiver; _telemetryPublisher = telemetryPublisher; }
/// <summary> /// Thread safe. Automatically subscribe to all channels specified in class attributes. /// </summary> /// <remarks>If an object is subscribed to a channel, it MUST be unsubscribed on destruction.</remarks> /// <see cref="Sharplike.Core.Game.Unsubscribe"/> /// <seealso cref="Sharplike.Core.Messaging.ChannelSubscriberAttribute"/> /// <param name="subscriber">The object to create subscriptions for.</param> public static void SubscribeToChannels(IMessageReceiver subscriber) { foreach (ChannelSubscriberAttribute attr in Attribute.GetCustomAttributes(subscriber.GetType())) { SubscribeToChannel(attr.Channel, subscriber); } }
public Switcher(IMessageReceiver receiver) { receiver.MessageReceivedEvent += Receiver_MessageReceivedEvent; }
public ShootoutTest(IMessageReceiver <byte[]> messageReceiver, IMessageSender <byte[]> messageSender) { this.messageReceiver = messageReceiver; this.messageSender = messageSender; }
public CommandProcessor(IMessageReceiver receiver, ITextSerialiser serialiser, ICommandHandlerRegistry registry) : base(receiver, serialiser) { this._registry = registry; }
protected CommandProcessor(IMessageReceiver receiver, ITextSerializer serializer) { this.receiver = receiver; this.serializer = serializer; }
public DequeueStrategy(SubscriptionsManager subscriptionsManager, IMessageReceiver messageReceiver) { this.subscriptionsManager = subscriptionsManager; this.messageReceiver = messageReceiver; }
public MessageService(IUserRepository userRepository, IMessageSender messageSender, IMessageReceiver messageReceiver) { this.userRepository = userRepository; this.messageSender = messageSender; this.messageReceiver = messageReceiver; }
public Task ReleaseAsync(IMessageReceiver receiver) { return(Task.CompletedTask); }
public DataWarehouseController(IMessageReceiver receiver) { this.receiver = receiver; }
internal static async Task CompleteMessagesAsync(IMessageReceiver messageReceiver, IList <Message> messages) { await messageReceiver.CompleteAsync(messages.Select(message => message.SystemProperties.LockToken)); Log($"Completed {messages.Count} messages"); }
internal ZyanMessageServer(IMessageReceiver messageReceiver, int port) { receiver = (MessageReceiver)messageReceiver; host = new ZyanComponentHost("OrderService", port); }
public void Initialize(IMessageReceiver receiver) { var _ = new ImageQualitySettingReceiver(receiver, "High"); }
/// <summary> /// Initializes a new instance of the <see cref="CommandProcessor"/> class. /// </summary> /// <param name="receiver">The receiver to use. If the receiver is <see cref="IDisposable"/>, it will be disposed when the processor is /// disposed.</param> /// <param name="serializer">The serializer to use for the message body.</param> public CommandProcessor(IMessageReceiver receiver, ITextSerializer serializer) : base(receiver, serializer) { this.commandDispatcher = new CommandDispatcher(); }
public CommandProcessor(IMessageReceiver receiver, ITextSerializer serializer, ICommandDispatcher dispatcher) : this(receiver, serializer) { this.dispatcher = dispatcher; }
public void AddReceiver(IMessageReceiver <Messages> receiver) { m_State = receiver; }
public LargeMessageContentMessageReceiver(IMessageReceiver parentReceiver, IBlobStorage offloadStorage) { _parentReceiver = parentReceiver; _offloadStorage = offloadStorage; }
public ServiceBusRetryWrapperBuilder WithReceiver(IMessageReceiver messageReceiver) { _messageReceiver = messageReceiver; return(this); }
public IServer GetServer(IMessageReceiver messageReceiver, int port) { return(new RemotingOrderServer(port)); }
public abstract void Deregister(IMessageReceiver receiver);
public BatchingServiceBusMessageReceiverTelemetryDecorator(ServiceBusMessageReceiver receiver, TReceiverActionReporter publisher) { _receiver = receiver; _publisher = publisher; }
/// <summary> /// Thread safe. Unsubscribes an object from the whole post system. This object will no longer receive messages. /// </summary> /// <param name="subscriber">The object to unsubscribe.</param> public static void Unsubscribe(IMessageReceiver subscriber) { post.RemoveReceiver(subscriber); lock (subscriptions) { foreach (KeyValuePair<String, List<IMessageReceiver>> kvp in subscriptions) { kvp.Value.Remove(subscriber); } } }
/// <summary> /// Wraps message receiver so that if it has message property <see cref="QueueMessage.LargeMessageContentHeaderName"/> set, /// uses <paramref name="offloadStorage"/> to download the message content, inject into the message, and remove the property. /// </summary> /// <param name="messageReceiver">Message receiver to wrap</param> /// <param name="offloadStorage">Storage used to find large content</param> /// <returns></returns> public static IMessageReceiver HandleLargeContent(this IMessageReceiver messageReceiver, IBlobStorage offloadStorage) { return(new LargeMessageContentMessageReceiver(messageReceiver, offloadStorage)); }
public Request(IMessageReceiver messageReceiver) { MessageReceiver = messageReceiver; }
public MidiNoteReceiver(IMessageReceiver receiver) { _receiver = receiver; }
/// <summary> /// 移除消息接收器,移除以后该接收器将无法接收消息 /// </summary> /// <param name="receiver">要移除的消息接收器</param> public static void RemoveMessageReceiver(IMessageReceiver receiver) { MessageReceiverManager.GetMessageReceiver().RemoveMessageReceiver(receiver); }
public FakeProcessor(ManualResetEventSlim waiter, IMessageReceiver receiver, ISerializer serializer) : base(receiver, serializer) { this.waiter = waiter; }
/// <summary> /// Initializes a new instance of the <see cref="CommandProcessor" /> class. /// </summary> /// <param name="receiver"> /// The receiver to use. If the receiver is <see cref="IDisposable" />, it will be disposed when the processor is /// disposed. /// </param> /// <param name="serializer">The serializer to use for the message body.</param> public CommandProcessor(IMessageReceiver receiver, ITextSerializer serializer) : base(receiver, serializer) { }
public RecoverabilityContext(IMessageReceiver receiver, IEndpoint endpoint, Message message) { Receiver = receiver; Endpoint = endpoint; Message = message; }
public void Deregister <TMessage>(IMessageReceiver <TMessage> messageReviever) where TMessage : EventMessage { _logger.Debug("Deregister message reciever {0}", messageReviever); GetOrCreate <TMessage>().Derigster(messageReviever); }
public void AddListener(IMessageReceiver listener) { MessageListeners[listener.GetType()] = listener; }