public Eve(IMessageHandler messager)
{
pMessager = messager;
pTimeOut.AutoReset = false;
pTimeOut.Interval = pCommonTimeout;
pTimeOut.Elapsed += PTimeOutElapsed;
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler)
: this(new MessageIdCache(),
framedClient, packetSerializer, messageHandler)
{
}
public RedisMessageHandlerWorker(
IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
Action<IMessageHandlerBackgroundWorker, Exception> errorHandler)
: base(messageHandler, queueName, errorHandler)
{
this.clientsManager = clientsManager;
}
public BlockUserTask(IMessageHandler consumeHandler, IMessageHandler publishHandler, string publishRoutingKey, IFeedBackDataManager feedBackManager, IAccountManager accountManager, IBlackListDataManager blackListDataManager)
: base(consumeHandler, publishHandler, publishRoutingKey)
{
_feedBackManager = feedBackManager;
_accountManager = accountManager;
_blackListDataManager = blackListDataManager;
}
// 1. List<pos + DateTime (class)> // högre och högre tid på olika pos
// 2. bild i ps, rita cirklar dra streck mellan dom..
// 3. bygga på med vinklar (sist, till att börja med kör vi med position)
public override void Initialize(GameContext context)
{
base.Initialize(context);
snapShots = new List<Snapshot>();
snapShots.Add(new Snapshot(TimeSpan.FromSeconds(0), new Vector2(487.0f, 585.0f)));
snapShots.Add(new Snapshot(TimeSpan.FromSeconds(3), new Vector2(510.0f, 200.0f)));
snapShots.Add(new Snapshot(TimeSpan.FromSeconds(7), new Vector2(775.0f, 326.0f)));
snapShots.Add(new Snapshot(TimeSpan.FromSeconds(10), new Vector2(1142.0f, 103.0f)));
this.spriteBatch = spriteBatch ?? new SpriteBatch(Context.Graphics.Device);
time = "";
interpolate = new Vector2();
gameServer = ServiceLocator.Get<IGameServer>();
gameClient = ServiceLocator.Get<IGameClient>();
messageHandler = ServiceLocator.Get<IMessageHandler>();
// Create the connection between the client and server
gameServer.Start();
gameClient.Connect();
//sendTimer = new GameTimer(TimeSpan.FromMilliseconds(1000 / 20), SendClientSpatial);
Context.Input.Keyboard.ClearMappings();
Context.Input.Keyboard.AddMapping(Keys.F1);
Context.Input.Keyboard.AddMapping(Keys.F2);
Context.Input.Keyboard.AddMapping(Keys.F3);
}
public EventDrivenConsumer(ISubscribableChannel inputChannel, IMessageHandler handler)
{
AssertUtils.ArgumentNotNull(inputChannel, "inputChannel must not be null");
AssertUtils.ArgumentNotNull(handler, "handler must not be null");
_inputChannel = inputChannel;
_handler = handler;
}
public NotificationConsumer(IMessageHandler messageHandler, IChannelWrapper channelWrapper)
{
_messageHandler = messageHandler;
_channelWrapper = channelWrapper;
Listen();
}
public PipedRoute(IMessageHandler handler, MethodInfo endpoint, string commandName, string[] parameterNames)
{
_commandName = commandName;
_parameterNames = parameterNames;
Handler = handler;
EndPoint = endpoint;
}
public PollingConsumer(IPollableChannel inputChannel, IMessageHandler handler)
{
AssertUtils.ArgumentNotNull(inputChannel, "inputChannel");
AssertUtils.ArgumentNotNull(handler, "handler");
_inputChannel = inputChannel;
_handler = handler;
}
public PriorityBurrowConsumer(IModel channel, IMessageHandler messageHandler, IRabbitWatcher watcher, bool autoAck, int batchSize)
: base(channel)
{
if (channel == null)
{
throw new ArgumentNullException("channel");
}
if (messageHandler == null)
{
throw new ArgumentNullException("messageHandler");
}
if (watcher == null)
{
throw new ArgumentNullException("watcher");
}
if (batchSize < 1)
{
throw new ArgumentException("batchSize must be greater than or equal 1", "batchSize");
}
Model.ModelShutdown += WhenChannelShutdown;
Model.BasicRecoverAsync(true);
_messageHandler = messageHandler;
_messageHandler.HandlingComplete += MessageHandlerHandlingComplete;
_watcher = watcher;
_autoAck = autoAck;
_batchSize = batchSize;
}
public static void RegisterHandler(Type type, IMessageHandler handlerObject)
{
lock (syncObj)
{
if (handlers.ContainsKey(type))
{
//Console.WriteLine("Type found - checking handlers list");
LinkedList<IMessageHandler> typeHandlers = handlers[type];
if (typeHandlers == null) // для этого типа раньше не регистрировались подписчики
{
typeHandlers = new LinkedList<IMessageHandler>();
}
// WARNING: linear search
if (!typeHandlers.Contains(handlerObject)) // для этого типа и этого объекта не назначен этот же объект-обработчик
typeHandlers.AddLast(handlerObject);
}
else
{
//Console.WriteLine("Type not found - creating handlers list");
handlers.Add(type, new LinkedList<IMessageHandler>());
handlers[type].AddLast(handlerObject);
}
}
}
/// <summary>
/// Creates this controller
/// </summary>
/// <param name="user">Command user that this controller listens to</param>
/// <param name="actionTarget">Entity actions are sent to this object</param>
public UserRtsController( CommandUser user, IMessageHandler actionTarget )
{
m_Target = actionTarget;
CommandList entityCommandList = CommandListManager.Instance.FindOrCreateFromEnum( typeof( EntityCommands ) );
user.AddActiveListener( entityCommandList, OnCommandActive );
}
public override void Invoke(Type msgType, IMessage message, IMessageHandler handler)
{
// PERF: cache or create compiled Lambda to invoke this
var method = handler.GetType().GetMethod("Handle", new[] { msgType });
method.Invoke(handler, new object[] { message });
}
public HandlerMapping(string version, string command, IMessageHandler handler)
{
if (version == null)
{
throw new ArgumentNullException("version");
}
if (command == null)
{
throw new ArgumentNullException("command");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
_catchAll = version == "*";
_version = _catchAll ?
new string[0] :
#if CF
version.Split(new[] { ',' })
#else
version.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
#endif
;
_command = command;
_handler = handler;
}
/// <summary>
/// Initializes a new instance of the <see cref="MessageProcessingContext"/> class.
/// </summary>
/// <param name="message">The Message.</param>
/// <param name="handler">The handler.</param>
public MessageProcessingContext(IMessage message, IMessageHandler handler)
{
Contract.Requires(message != null);
Contract.Requires(handler != null);
this.Message = message;
this.Handler = handler;
}
public MessageClient(IFramedClient framedClient,
IStacksSerializer packetSerializer,
IMessageHandler messageHandler,
Func<MessageIdRegistration, MessageIdRegistration> registration)
: this(registration(new MessageIdRegistration()).CreateCache(),
framedClient, packetSerializer, messageHandler)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="QueueCreationDecorator" /> class.
/// </summary>
/// <param name="metrics">The metrics factory.</param>
/// <param name="handler">The handler.</param>
/// <param name="connectionInformation">The connection information.</param>
public MessageHandlerDecorator(IMetrics metrics,
IMessageHandler handler,
IConnectionInformation connectionInformation)
{
var name = handler.GetType().Name;
_runCodeTimer = metrics.Timer($"{connectionInformation.QueueName}.{name}.HandleTimer", Units.Calls);
_handler = handler;
}
protected MessageItemProcessor(IMessageHandler consumeHandler, IMessageHandler publishHandler,
string publishRoutingKey)
{
ConsumeHandler = consumeHandler;
PublishHandler = publishHandler;
IsActive = true;
PublishRoutingKey = publishRoutingKey;
}
/// <summary>
/// Initialize an object of <see cref="BurrowConsumer"/>
/// </summary>
/// <param name="channel">RabbitMQ.Client channel</param>
/// <param name="messageHandler">An instance of message handler to handle the message from queue</param>
/// <param name="watcher"></param>
/// <param name="autoAck">If set to true, the msg will be acked after processed</param>
/// <param name="batchSize"></param>
public BurrowConsumer(IModel channel,
IMessageHandler messageHandler,
IRabbitWatcher watcher,
bool autoAck,
int batchSize) : this(channel, messageHandler, watcher, autoAck, batchSize, true)
{
// This is the public constructor to start the consuming thread straight away
}
public virtual void Dispose()
{
if (_isDisposed)
return;
RemoveHandlerFromDevices();
Impl = null;
_isDisposed = true;
}
private static bool HandleMessage(Task<Message> task, IMessageHandler handler, IMessage message)
{
if (message != null)
{
message.Headers[SystemHeaders.MessageID] = task.Result.Id;
}
return handler.Handle(message);
}
public RegexRoute(IMessageHandler handler, MethodInfo endPoint, string pattern)
{
string parameterizedPattern = Regex.Replace(pattern, RegexParameterPattern, match => "(?<" + match.Groups["name"].Value + ">.*)");
_regex = new Regex(parameterizedPattern, RegexOptions.IgnoreCase);
Handler = handler;
EndPoint = endPoint;
}
public MsmqMessageReceiver(string messageQueuePath, IMessageHandler messageHandler)
{
_messageHandler = messageHandler;
_messageQueue = new MessageQueue(messageQueuePath)
{
Formatter = new BinaryMessageFormatter()
};
_messageQueue.ReceiveCompleted += MessageQueueReceiveCompleted;
}
/// <summary>
/// Initializes a new <see cref="HandlingRule"/> with the supplied message
/// <paramref name="specification"/>, <see cref="MessageHandler"/>, and
/// <paramref name="queueName"/>.
/// </summary>
/// <param name="specification">The message specification that selects messages
/// to which the handling rule applies</param>
/// <param name="messageHandler">The handler to which messages matching the
/// specification will be routed</param>
/// <param name="queueName">(Optional) The name of the queue in which matching
/// messages will be placed while they await handling</param>
/// <remarks>
/// If the <paramref name="queueName"/> is ommitted, a default queue name will
/// be generated based on the MD5 hash of the full type name of the supplied
/// <paramref name="messageHandler"/>
/// </remarks>
/// <seealso cref="GenerateQueueName"/>
public HandlingRule(IMessageSpecification specification, IMessageHandler messageHandler,
QueueName queueName = null)
{
if (specification == null) throw new ArgumentNullException("specification");
if (messageHandler == null) throw new ArgumentNullException("messageHandler");
_specification = specification;
_messageHandler = messageHandler;
_queueName = queueName ?? GenerateQueueName(messageHandler);
}
public MessageHandlerWorker(
IRedisClientsManager clientsManager, IMessageHandler messageHandler, string queueName,
Action<MessageHandlerWorker, Exception> errorHandler)
{
this.clientsManager = clientsManager;
this.messageHandler = messageHandler;
this.QueueName = queueName;
this.errorHandler = errorHandler;
}
public TradeHandler(IPixelBasedVariables pbv, IWindowManager windowManager, IMessageHandler messageHandler, IApplicationSettings applicationSettings)
{
CardsYouGet = new Dictionary<int, MagicCard>();
CardsYouGive = new Dictionary<int, MagicCard>();
_pbv = pbv;
_windowManager = windowManager;
_messageHandler = messageHandler;
_applicationSettings = applicationSettings;
_deckFileLocation = _applicationSettings.DeckFileLocation;
}
public MessageHandlerFactory(IClientRepository clientRepository, IClientIDGenerator clientIDGenerator, IClientFactory clientFactory, IClientWorkflowManager clientWorkflowManager)
{
this.metaConnectHandler = new MetaConnectHandler(clientRepository);
this.metaDisconnectHandler = new MetaDisconnectHandler(clientRepository);
this.metaHandshakeHandler = new MetaHandshakeHandler(clientIDGenerator, clientFactory, clientWorkflowManager);
this.metaSubscribeHandler = new MetaSubscribeHandler(clientRepository);
this.metaUnsubscribeHandler = new MetaUnsubscribeHandler(clientRepository);
this.swallowHandler = new SwallowHandler();
this.forwardingHandler = new ForwardingHandler(clientRepository);
}
public Tunnel(IMessageHandler messageHandler, string friendlyName="Cactus Fantastico", int port=14804)
{
MessageHandler = messageHandler;
FriendlyName = friendlyName;
_socket = SockLib.UdpConnect(port);
_messageQueue = new ConcurrentQueue<Message>();
_hbMutex = new SimpleMutex();
_id = _tunnelCounter++;
}
public void RemoveHandlerFromDevices()
{
if (IsDisposed)
throw new ObjectDisposedException("IMessageHandler");
if (Impl != null)
{
Impl.Dispose();
Impl = null;
}
}
public PerformanceNotificationModel(IMessageHandler messageHandler)
: base()
{
if (messageHandler == null)
{
throw new ArgumentException("Message handler must not be null");
}
this.messageHandler = messageHandler;
performanceService = ServiceFactory.CreatePerformanceService();
SendCommand = new RelayCommand(p => Send(p), p => IsViewModelValid);
}
void IMessageSubscriptionManager.Subscribe <TMessage>(IMessageHandler <TMessage> handler, string?exchange, string?topic)
{
Subscribe <TMessage>(handler, exchange, topic);
}
public AdminUserService(IAdminUserRepository adminUserRepo, IJwtFactory jwtFactory, IMessageHandler messageHandler, ILoggerManager logger, IMapper mapper) : base(messageHandler, mapper, logger, jwtFactory)
{
_adminUserRepo = adminUserRepo;
}
/// <summary>
/// Adds a listener.
/// </summary>
/// <param name="listener">Listener.</param>
/// <param name="message">Message to listen for.</param>
/// <param name="parameter">Message parameter to listen for, or blank for any parameter with the message.</param>
public static void AddListener(IMessageHandler listener, StringField message, StringField parameter)
{
AddListener(listener, StringField.GetStringValue(message), StringField.GetStringValue(parameter));
}
private static bool ShouldLogReceiver(IMessageHandler receiver)
{
return(receiver is Component && (receiver as Component) != null && s_listenersToLog.Contains((receiver as Component).gameObject));
}
/// <summary>
/// Removes a listener from listening to a specific message and parameter.
/// </summary>
/// <param name="listener">Listener.</param>
/// <param name="message">Message to no longer listen for.</param>
/// <param name="parameter">Messaeg parameter, or blank for all parameters.</param>
public static void RemoveListener(IMessageHandler listener, string message, StringField parameter)
{
RemoveListener(listener, message, StringField.GetStringValue(parameter));
}
protected ProxyBase(IMessageHandler handler, ICommonSerializer serializer, string hubName)
{
_handler = handler;
_hubName = hubName;
_serializer = serializer;
}
public abstract Task SubscribeAsync <TMessage>(
IMessageHandler <TMessage> handler,
CancellationToken cancellationToken = default(CancellationToken));
protected override void DoHandleBy(IMessageHandler handler)
{
handler.HandleMessage(this);
}
public Client_MessageReciever(ClientConnection connection, IMessageHandler messageHandler)
{
this.messageHandler = messageHandler;
this.connection = connection;
}
public WaterService(IAuthorization authorization, IWaterRepository waterRepository, IMessageHandler messageHandler)
{
this._authorizationService = authorization;
this._waterRepository = waterRepository;
this.FeedbackHandler = messageHandler;
}
public CharacterService(IMessageHandler MessageHandler)
{
messageHandler = MessageHandler;
}
public InvoiceManager(IMessageHandler messageHandler, IInvoiceRepository repo, IEmailCommunicator emailCommunicator)
{
_messageHandler = messageHandler;
_repo = repo;
_emailCommunicator = emailCommunicator;
}
protected async void ParseMessage(byte[] bytes)
{
byte code = bytes[0];
if (code == Protocol.JOIN_ROOM)
{
var offset = 1;
SerializerId = System.Text.Encoding.UTF8.GetString(bytes, offset + 1, bytes[offset]);
offset += SerializerId.Length + 1;
if (SerializerId == "schema")
{
try
{
serializer = new SchemaSerializer <T>();
}
catch (Exception e)
{
DisplaySerializerErrorHelp(e, "Consider using the \"schema-codegen\" and providing the same room state for matchmaking instead of \"" + typeof(T).Name + "\"");
}
}
else if (SerializerId == "fossil-delta")
{
try
{
serializer = (ISerializer <T>) new FossilDeltaSerializer();
} catch (Exception e)
{
DisplaySerializerErrorHelp(e, "Consider using \"IndexedDictionary<string, object>\" instead of \"" + typeof(T).Name + "\" for matchmaking.");
}
}
else
{
try
{
serializer = (ISerializer <T>) new NoneSerializer();
}
catch (Exception e)
{
DisplaySerializerErrorHelp(e, "Consider setting state in the server-side using \"this.setState(new " + typeof(T).Name + "())\"");
}
}
if (bytes.Length > offset)
{
serializer.Handshake(bytes, offset);
}
OnJoin?.Invoke();
// Acknowledge JOIN_ROOM
await Connection.Send(new byte[] { Protocol.JOIN_ROOM });
}
else if (code == Protocol.ERROR)
{
Schema.Iterator it = new Schema.Iterator {
Offset = 1
};
var errorCode = Decode.DecodeNumber(bytes, it);
var errorMessage = Decode.DecodeString(bytes, it);
OnError?.Invoke((int)errorCode, errorMessage);
}
else if (code == Protocol.ROOM_DATA_SCHEMA)
{
Schema.Iterator it = new Schema.Iterator {
Offset = 1
};
var typeId = Decode.DecodeNumber(bytes, it);
Type messageType = Schema.Context.GetInstance().Get(typeId);
var message = (Schema.Schema)Activator.CreateInstance(messageType);
message.Decode(bytes, it);
IMessageHandler handler = null;
OnMessageHandlers.TryGetValue("s" + message.GetType(), out handler);
if (handler != null)
{
handler.Invoke(message);
}
else
{
Debug.LogWarning("room.OnMessage not registered for Schema of type: '" + message.GetType() + "'");
}
}
else if (code == Protocol.LEAVE_ROOM)
{
await Leave();
}
else if (code == Protocol.ROOM_STATE)
{
Debug.Log("ROOM_STATE");
SetState(bytes, 1);
}
else if (code == Protocol.ROOM_STATE_PATCH)
{
Debug.Log("ROOM_STATE_PATCH");
Patch(bytes, 1);
}
else if (code == Protocol.ROOM_DATA)
{
IMessageHandler handler = null;
object type;
Schema.Iterator it = new Schema.Iterator {
Offset = 1
};
if (Decode.NumberCheck(bytes, it))
{
type = Decode.DecodeNumber(bytes, it);
OnMessageHandlers.TryGetValue("i" + type, out handler);
}
else
{
type = Decode.DecodeString(bytes, it);
OnMessageHandlers.TryGetValue(type.ToString(), out handler);
}
if (handler != null)
{
//
// MsgPack deserialization can be optimized:
// https://github.com/deniszykov/msgpack-unity3d/issues/23
//
var message = (bytes.Length > it.Offset)
? MsgPack.Deserialize(handler.Type, new MemoryStream(bytes, it.Offset, bytes.Length - it.Offset, false))
: null;
handler.Invoke(message);
}
else
{
Debug.LogWarning("room.OnMessage not registered for: '" + type + "'");
}
}
}
public RedisMessageHandler(IMessageHandler <T> handler, IRedisMessageSerializer messageSerializer)
{
_handler = handler;
_messageSerializer = messageSerializer;
}
public ConfigurationService(IConfigurationRepository configurationRepo, IJwtFactory jwtFactory, IMessageHandler messageHandler, ILoggerManager logger, IMapper mapper) : base(messageHandler, mapper, logger, jwtFactory)
{
_configurationRepo = configurationRepo;
}
public JfdPositionsStateMachine(RequestForPositions positionsRequest, CancellationToken cancellationToken, IMessageHandler messageHandler, ILog log) : base(positionsRequest, cancellationToken, messageHandler, log)
{
positionsRequest.PosReqID = new PosReqID(Id);
}
public FilteredMessageHandler <TSession> AddHandler(IMessageHandler handler)
{
_messageHandlers.Add(handler);
return(this);
}
public IDisposable Subscribe(IMessageHandler <TMessage> handler, params MessageHandlerFilter <TMessage>[] filters)
{
return(core.Subscribe(handlerFactory.CreateMessageHandler(handler, filters)));
}
/// <summary>
/// Removes a listener from listening to all messages.
/// </summary>
public static void RemoveListener(IMessageHandler listener)
{
RemoveListener(listener, string.Empty, string.Empty);
}
public OrderStateMachine(NewOrderSingle newOrderSingle, CancellationToken cancellationToken, IMessageHandler messageHandler, ILog log) : base(newOrderSingle, cancellationToken, messageHandler, log)
{
newOrderSingle.ClOrdID = new ClOrdID(Id);
}
/// <summary>
/// Removes a listener from listening to a specific message and parameter.
/// </summary>
/// <param name="listener">Listener.</param>
/// <param name="message">Message to no longer listen for.</param>
/// <param name="parameter">Messaeg parameter, or blank for all parameters.</param>
public static void RemoveListener(IMessageHandler listener, StringField message, string parameter)
{
RemoveListener(listener, StringField.GetStringValue(message), parameter);
}
/// <summary>
/// 注册消息处理程序。当收到消息是后执行相应的方法。
/// </summary>
/// <param name="handler"></param>
public static void ResisterHandler(IMessageHandler handler)
{
_messageHandler = handler;
}
void AddHandler(IMessageHandler handler)
{
Handlers.Add(handler.MessageCode, handler);
}
public NotificationManager(IMessageHandler messageHandler, INotificationRepository repo, IEmailNotifier emailNotifier)
{
_messageHandler = messageHandler;
_repo = repo;
_emailNotifier = emailNotifier;
}
public void AcceptHandler(IMessageHandler handler, object o = null)
{
handler.HandleMessage(this, o);
}
public OnlineVideoRefreshManager(ICurrent current, IVideoListContainer container, INetworkVideoHandler netVideoHandler, IRemotePlaylistHandler remotePlaylistHandler, IMessageHandler message, IVideosUnchecker unchecker)
{
this._current = current;
this._container = container;
this._netVideoHandler = netVideoHandler;
this._remotePlaylistHandler = remotePlaylistHandler;
this._message = message;
this._unchcecker = unchecker;
}
protected virtual void MessageHandler_OnReceiveMessage(IMessageHandler sender, ReceiveMessageEventArgs e)
{
throw new NotImplementedException();
}
public void Setup()
{
handler = new CalculateAverageHandler();
}
public MessageController(IMessageHandler messageHandler)
{
_messageHandler = messageHandler;
}
public Dispatcher(IMessageHandler handler)
{
_handler = handler;
}
