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;
}
