public static void Handle(IClientMessage clientMessage, HandleIMapInvalidation handleIMapInvalidation,
HandleIMapBatchInvalidation handleIMapBatchInvalidation)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
handleIMapInvalidation(key);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
IList <IData> keys = null;
var keys_size = clientMessage.GetInt();
keys = new List <IData>();
for (var keys_index = 0; keys_index < keys_size; keys_index++)
{
IData keys_item;
keys_item = clientMessage.GetData();
keys.Add(keys_item);
}
handleIMapBatchInvalidation(keys);
return;
}
Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleDistributedObject handleDistributedObject)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventDistributedObject)
{
var name = clientMessage.GetStringUtf8();
var serviceName = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetStringUtf8();
handleDistributedObject(name, serviceName, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleTopic handleTopic)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventTopic)
{
var item = clientMessage.GetData();
var publishTime = clientMessage.GetLong();
var uuid = clientMessage.GetStringUtf8();
handleTopic(item, publishTime, uuid);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleMember handleMember,
HandleMemberSet handleMemberSet, HandleMemberAttributeChange handleMemberAttributeChange)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
IMember member = null;
member = MemberCodec.Decode(clientMessage);
int eventType;
eventType = clientMessage.GetInt();
handleMember(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberSet)
{
IList <IMember> members = null;
var members_size = clientMessage.GetInt();
members = new List <IMember>();
for (var members_index = 0; members_index < members_size; members_index++)
{
IMember members_item;
members_item = MemberCodec.Decode(clientMessage);
members.Add(members_item);
}
handleMemberSet(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
string uuid = null;
uuid = clientMessage.GetStringUtf8();
string key = null;
key = clientMessage.GetStringUtf8();
int operationType;
operationType = clientMessage.GetInt();
string value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChange(uuid, key, operationType, value);
return;
}
Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleEntry handleEntry)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
IData value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValue_isNull = clientMessage.GetBoolean();
if (!oldValue_isNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValue_isNull = clientMessage.GetBoolean();
if (!mergingValue_isNull)
{
mergingValue = clientMessage.GetData();
}
int eventType;
eventType = clientMessage.GetInt();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int numberOfAffectedEntries;
numberOfAffectedEntries = clientMessage.GetInt();
handleEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
var itemIsNull = clientMessage.GetBoolean();
if (!itemIsNull)
{
item = clientMessage.GetData();
}
var uuid = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleMember handleMember,
HandleMemberList handleMemberList, HandleMemberAttributeChange handleMemberAttributeChange)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
var member = MemberCodec.Decode(clientMessage);
var eventType = clientMessage.GetInt();
handleMember(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberList)
{
var members = new List <Core.IMember>();
var membersSize = clientMessage.GetInt();
for (var membersIndex = 0; membersIndex < membersSize; membersIndex++)
{
var membersItem = MemberCodec.Decode(clientMessage);
members.Add(membersItem);
}
handleMemberList(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
var uuid = clientMessage.GetStringUtf8();
var key = clientMessage.GetStringUtf8();
var operationType = clientMessage.GetInt();
string value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChange(uuid, key, operationType, value);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
internal static void HandleEvent(IClientMessage clientMessage, HandleTopicEventV10 handleTopicEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventTopic)
{
var item = clientMessage.GetData();
var publishTime = clientMessage.GetLong();
var uuid = clientMessage.GetStringUtf8();
handleTopicEventV10(item, publishTime, uuid);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
internal static void HandleEvent(IClientMessage clientMessage,
HandleDistributedObjectEventV10 handleDistributedObjectEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventDistributedObject)
{
var name = clientMessage.GetStringUtf8();
var serviceName = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetStringUtf8();
handleDistributedObjectEventV10(name, serviceName, eventType);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
public static void Handle(IClientMessage clientMessage, HandleDistributedObject handleDistributedObject)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventDistributedObject)
{
string name = null;
name = clientMessage.GetStringUtf8();
string serviceName = null;
serviceName = clientMessage.GetStringUtf8();
string eventType = null;
eventType = clientMessage.GetStringUtf8();
handleDistributedObject(name, serviceName, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler)).Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleMember handleMember,
HandleMemberSet handleMemberSet, HandleMemberAttributeChange handleMemberAttributeChange)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
IMember member = null;
member = MemberCodec.Decode(clientMessage);
int eventType;
eventType = clientMessage.GetInt();
handleMember(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberSet)
{
IList<IMember> members = null;
var members_size = clientMessage.GetInt();
members = new List<IMember>();
for (var members_index = 0; members_index < members_size; members_index++)
{
IMember members_item;
members_item = MemberCodec.Decode(clientMessage);
members.Add(members_item);
}
handleMemberSet(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
string uuid = null;
uuid = clientMessage.GetStringUtf8();
string key = null;
key = clientMessage.GetStringUtf8();
int operationType;
operationType = clientMessage.GetInt();
string value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChange(uuid, key, operationType, value);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleTopic handleTopic)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventTopic)
{
IData item = null;
item = clientMessage.GetData();
long publishTime;
publishTime = clientMessage.GetLong();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
handleTopic(item, publishTime, uuid);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
private void HandleResponseMessage(IClientMessage response)
{
var correlationId = response.GetCorrelationId();
ClientInvocation invocation;
if (_invocations.TryRemove(correlationId, out invocation))
{
if (response.GetMessageType() == Error.Type)
{
var error = Error.Decode(response);
if (Logger.IsFinestEnabled())
{
Logger.Finest("Error received from server: " + error);
}
var exception = ExceptionUtil.ToException(error);
// retry only specific exceptions
HandleInvocationException(invocation, exception);
}
// if this was a re-registration operation, then we will throw away the response and just store the alias
else if ((invocation is ClientListenerInvocation) &&
(invocation.Future.IsComplete && invocation.Future.Result != null))
{
var listenerInvocation = (ClientListenerInvocation)invocation;
var originalRegistrationId = GetRegistrationIdFromResponse(listenerInvocation);
var newRegistrationId = listenerInvocation.ResponseDecoder(response);
_client.GetListenerService()
.ReregisterListener(originalRegistrationId, newRegistrationId,
invocation.Message.GetCorrelationId());
if (Logger.IsFinestEnabled())
{
Logger.Finest(string.Format("Re-registered listener for {0} of type {1:X}",
originalRegistrationId,
listenerInvocation.Message.GetMessageType()));
}
}
else
{
invocation.Future.Result = response;
}
}
else
{
Logger.Warning("No call for correlationId: " + correlationId + ", response: " + response);
}
}
internal static void HandleEvent(IClientMessage clientMessage, HandleItemEventV10 handleItemEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
var itemIsNull = clientMessage.GetBoolean();
if (!itemIsNull)
{
item = clientMessage.GetData();
}
var uuid = clientMessage.GetStringUtf8();
var eventType = clientMessage.GetInt();
handleItemEventV10(item, uuid, eventType);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
public static void Handle(IClientMessage clientMessage, HandleItem handleItem)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventItem)
{
IData item = null;
bool item_isNull = clientMessage.GetBoolean();
if (!item_isNull)
{
item = clientMessage.GetData();
}
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int eventType;
eventType = clientMessage.GetInt();
handleItem(item, uuid, eventType);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler)).Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
internal static void HandleEvent(IClientMessage clientMessage, HandleMemberEventV10 handleMemberEventV10,
HandleMemberListEventV10 handleMemberListEventV10,
HandleMemberAttributeChangeEventV10 handleMemberAttributeChangeEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventMember)
{
var member = MemberCodec.Decode(clientMessage);
var eventType = clientMessage.GetInt();
handleMemberEventV10(member, eventType);
return;
}
if (messageType == EventMessageConst.EventMemberList)
{
var membersSize = clientMessage.GetInt();
var members = new List <IMember>(membersSize);
for (var membersIndex = 0; membersIndex < membersSize; membersIndex++)
{
var membersItem = MemberCodec.Decode(clientMessage);
members.Add(membersItem);
}
handleMemberListEventV10(members);
return;
}
if (messageType == EventMessageConst.EventMemberAttributeChange)
{
var uuid = clientMessage.GetStringUtf8();
var key = clientMessage.GetStringUtf8();
var operationType = clientMessage.GetInt();
string value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetStringUtf8();
}
handleMemberAttributeChangeEventV10(uuid, key, operationType, value);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
public static void Handle(IClientMessage clientMessage, HandleEntry handleEntry)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
IData value = null;
var value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValue_isNull = clientMessage.GetBoolean();
if (!oldValue_isNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValue_isNull = clientMessage.GetBoolean();
if (!mergingValue_isNull)
{
mergingValue = clientMessage.GetData();
}
int eventType;
eventType = clientMessage.GetInt();
string uuid = null;
uuid = clientMessage.GetStringUtf8();
int numberOfAffectedEntries;
numberOfAffectedEntries = clientMessage.GetInt();
handleEntry(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
private void HandleResponseMessage(IClientMessage response)
{
var correlationId = response.GetCorrelationId();
ClientInvocation invocation;
if (_invocations.TryRemove(correlationId, out invocation))
{
if (response.GetMessageType() == Error.Type)
{
var error = Error.Decode(response);
if (Logger.IsFinestEnabled())
{
Logger.Finest("Error received from server: " + error);
}
var exception = ExceptionUtil.ToException(error);
// retry only specific exceptions
HandleInvocationException(invocation, exception);
}
else
{
try
{
invocation.Future.Result = response;
}
catch (InvalidOperationException e)
{
if (Logger.IsFinestEnabled())
{
Logger.Finest("Invocation already completed:", e);
}
}
}
}
else
{
Logger.Warning("No call for correlationId: " + correlationId + ", response: " + response);
}
}
internal static void HandleEvent(IClientMessage clientMessage, HandleEntryEventV10 handleEntryEventV10)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry)
{
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
IData value = null;
var valueIsNull = clientMessage.GetBoolean();
if (!valueIsNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
var oldValueIsNull = clientMessage.GetBoolean();
if (!oldValueIsNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
var mergingValueIsNull = clientMessage.GetBoolean();
if (!mergingValueIsNull)
{
mergingValue = clientMessage.GetData();
}
var eventType = clientMessage.GetInt();
var uuid = clientMessage.GetStringUtf8();
var numberOfAffectedEntries = clientMessage.GetInt();
handleEntryEventV10(key, value, oldValue, mergingValue, eventType, uuid, numberOfAffectedEntries);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
private void HandleResponseMessage(IClientMessage response)
{
var correlationId = response.GetCorrelationId();
ClientInvocation invocation;
if (_invocations.TryRemove(correlationId, out invocation))
{
if (response.GetMessageType() == Error.Type)
{
var error = Error.Decode(response);
var exception = ExceptionUtil.ToException(error);
// retry only specific exceptions
HandleException(invocation, exception);
}
// if this was a re-registration operation, then we will throw away the response and just store the alias
else if (invocation is ClientListenerInvocation && invocation.Future.IsComplete &&
invocation.Future.Result != null)
{
var listenerInvocation = (ClientListenerInvocation) invocation;
var originalRegistrationId = GetRegistrationIdFromResponse(listenerInvocation);
var newRegistrationId = listenerInvocation.ResponseDecoder(response);
_client.GetListenerService()
.ReregisterListener(originalRegistrationId, newRegistrationId,
invocation.Message.GetCorrelationId());
if (Logger.IsFinestEnabled())
{
Logger.Finest(string.Format("Re-registered listener for {0} of type {1:X}",
originalRegistrationId,
listenerInvocation.Message.GetMessageType()));
}
}
else
{
invocation.Future.Result = response;
}
}
else
{
Logger.Warning("No call for correlationId: " + correlationId + ", response: " + response);
}
}
public static void Handle(IClientMessage clientMessage, HandleIMapInvalidation handleIMapInvalidation,
HandleIMapBatchInvalidation handleIMapBatchInvalidation)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
IData key = null;
var key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
handleIMapInvalidation(key);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
IList<IData> keys = null;
var keys_size = clientMessage.GetInt();
keys = new List<IData>();
for (var keys_index = 0; keys_index < keys_size; keys_index++)
{
IData keys_item;
keys_item = clientMessage.GetData();
keys.Add(keys_item);
}
handleIMapBatchInvalidation(keys);
return;
}
Logger.GetLogger(typeof (AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
public static void Handle(IClientMessage clientMessage, HandleIMapInvalidation handleIMapInvalidation,
HandleIMapBatchInvalidation handleIMapBatchInvalidation)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
var IMapInvalidationMessageFinished = false;
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
if (!IMapInvalidationMessageFinished)
{
IMapInvalidationMessageFinished = clientMessage.IsComplete();
}
string sourceUuid = null;
if (!IMapInvalidationMessageFinished)
{
sourceUuid = clientMessage.GetStringUtf8();
}
Guid?partitionUuid = null;
if (!IMapInvalidationMessageFinished)
{
partitionUuid = UUIDCodec.Decode(clientMessage);
}
long?sequence = null;
if (!IMapInvalidationMessageFinished)
{
sequence = clientMessage.GetLong();
}
handleIMapInvalidation(key, sourceUuid, partitionUuid, sequence);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
var IMapBatchInvalidationMessageFinished = false;
var keys = new List <IData>();
var keysSize = clientMessage.GetInt();
for (var keysIndex = 0; keysIndex < keysSize; keysIndex++)
{
var keysItem = clientMessage.GetData();
keys.Add(keysItem);
}
if (!IMapBatchInvalidationMessageFinished)
{
IMapBatchInvalidationMessageFinished = clientMessage.IsComplete();
}
IList <string> sourceUuids = null;
if (!IMapBatchInvalidationMessageFinished)
{
sourceUuids = new List <string>();
var sourceUuidsSize = clientMessage.GetInt();
for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++)
{
var sourceUuidsItem = clientMessage.GetStringUtf8();
sourceUuids.Add(sourceUuidsItem);
}
}
IList <Guid> partitionUuids = null;
if (!IMapBatchInvalidationMessageFinished)
{
partitionUuids = new List <Guid>();
var partitionUuidsSize = clientMessage.GetInt();
for (var partitionUuidsIndex = 0;
partitionUuidsIndex < partitionUuidsSize;
partitionUuidsIndex++)
{
var partitionUuidsItem = UUIDCodec.Decode(clientMessage);
partitionUuids.Add(partitionUuidsItem);
}
}
IList <long> sequences = null;
if (!IMapBatchInvalidationMessageFinished)
{
sequences = new List <long>();
var sequencesSize = clientMessage.GetInt();
for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++)
{
var sequencesItem = clientMessage.GetLong();
sequences.Add(sequencesItem);
}
}
handleIMapBatchInvalidation(keys, sourceUuids, partitionUuids, sequences);
return;
}
Hazelcast.Logging.Logger.GetLogger(typeof(AbstractEventHandler))
.Warning("Unknown message type received on event handler :" + clientMessage.GetMessageType());
}
internal static void HandleEvent(IClientMessage clientMessage,
HandleIMapInvalidationEventV10 handleIMapInvalidationEventV10,
HandleIMapInvalidationEventV14 handleIMapInvalidationEventV14,
HandleIMapBatchInvalidationEventV10 handleIMapBatchInvalidationEventV10,
HandleIMapBatchInvalidationEventV14 handleIMapBatchInvalidationEventV14)
{
var messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventIMapInvalidation)
{
IData key = null;
var keyIsNull = clientMessage.GetBoolean();
if (!keyIsNull)
{
key = clientMessage.GetData();
}
if (clientMessage.IsComplete())
{
handleIMapInvalidationEventV10(key);
return;
}
var sourceUuid = clientMessage.GetStringUtf8();
var partitionUuid = GuidCodec.Decode(clientMessage);
var sequence = clientMessage.GetLong();
handleIMapInvalidationEventV14(key, sourceUuid, partitionUuid, sequence);
return;
}
if (messageType == EventMessageConst.EventIMapBatchInvalidation)
{
var keysSize = clientMessage.GetInt();
var keys = new List <IData>(keysSize);
for (var keysIndex = 0; keysIndex < keysSize; keysIndex++)
{
var keysItem = clientMessage.GetData();
keys.Add(keysItem);
}
if (clientMessage.IsComplete())
{
handleIMapBatchInvalidationEventV10(keys);
return;
}
var sourceUuidsSize = clientMessage.GetInt();
var sourceUuids = new List <string>(sourceUuidsSize);
for (var sourceUuidsIndex = 0; sourceUuidsIndex < sourceUuidsSize; sourceUuidsIndex++)
{
var sourceUuidsItem = clientMessage.GetStringUtf8();
sourceUuids.Add(sourceUuidsItem);
}
var partitionUuidsSize = clientMessage.GetInt();
var partitionUuids = new List <Guid>(partitionUuidsSize);
for (var partitionUuidsIndex = 0; partitionUuidsIndex < partitionUuidsSize; partitionUuidsIndex++)
{
var partitionUuidsItem = GuidCodec.Decode(clientMessage);
partitionUuids.Add(partitionUuidsItem);
}
var sequencesSize = clientMessage.GetInt();
var sequences = new List <long>(sequencesSize);
for (var sequencesIndex = 0; sequencesIndex < sequencesSize; sequencesIndex++)
{
var sequencesItem = clientMessage.GetLong();
sequences.Add(sequencesItem);
}
handleIMapBatchInvalidationEventV14(keys, sourceUuids, partitionUuids, sequences);
return;
}
Logger.GetLogger(typeof(EventHandler)).Warning("Unknown message type received on event handler :" + messageType);
}
