public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
byte status;
status = clientMessage.GetByte();
parameters.status = status;
Address address = null;
bool address_isNull = clientMessage.GetBoolean();
if (!address_isNull)
{
address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
string uuid = null;
bool uuid_isNull = clientMessage.GetBoolean();
if (!uuid_isNull)
{
uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
string ownerUuid = null;
bool ownerUuid_isNull = clientMessage.GetBoolean();
if (!ownerUuid_isNull)
{
ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
byte serializationVersion;
serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
return parameters;
}
public Error(IClientMessage message)
{
ErrorCode = message.GetInt();
ClassName = message.GetStringUtf8();
var messageIsNull = message.GetBoolean();
if (!messageIsNull)
{
Message = message.GetStringUtf8();
}
var stackTraceCount = message.GetInt();
StackTrace = new StackTraceElement[stackTraceCount];
for (var i = 0; i < stackTraceCount; i++)
{
StackTrace[i] = StackTraceElementCodec.Decode(message);
}
CauseErrorCode = message.GetInt();
var causeClassNameIsNull = message.GetBoolean();
if (!causeClassNameIsNull)
{
CauseClassName = message.GetStringUtf8();
}
}
public static DistributedObjectInfo Decode(IClientMessage clientMessage)
{
var serviceName = clientMessage.GetStringUtf8();
var name = clientMessage.GetStringUtf8();
return(new DistributedObjectInfo(serviceName, name));
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var status = clientMessage.GetByte();
parameters.status = status;
var addressIsNull = clientMessage.GetBoolean();
if (!addressIsNull)
{
var address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
var uuidIsNull = clientMessage.GetBoolean();
if (!uuidIsNull)
{
var uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
var ownerUuidIsNull = clientMessage.GetBoolean();
if (!ownerUuidIsNull)
{
var ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
var serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
if (clientMessage.IsComplete())
{
return(parameters);
}
var serverHazelcastVersion = clientMessage.GetStringUtf8();
parameters.serverHazelcastVersion = serverHazelcastVersion;
parameters.serverHazelcastVersionExist = true;
var clientUnregisteredMembersIsNull = clientMessage.GetBoolean();
if (!clientUnregisteredMembersIsNull)
{
var clientUnregisteredMembers = new List <Core.IMember>();
var clientUnregisteredMembersSize = clientMessage.GetInt();
for (var clientUnregisteredMembersIndex = 0;
clientUnregisteredMembersIndex < clientUnregisteredMembersSize;
clientUnregisteredMembersIndex++)
{
var clientUnregisteredMembersItem = MemberCodec.Decode(clientMessage);
clientUnregisteredMembers.Add(clientUnregisteredMembersItem);
}
parameters.clientUnregisteredMembers = clientUnregisteredMembers;
}
parameters.clientUnregisteredMembersExist = true;
return(parameters);
}
public static StackTraceElement Decode(IClientMessage clientMessage)
{
var declaringClass = clientMessage.GetStringUtf8();
var methodName = clientMessage.GetStringUtf8();
var fileName_notNull = clientMessage.GetBoolean();
string fileName = null;
if (fileName_notNull)
{
fileName = clientMessage.GetStringUtf8();
}
var lineNumber = clientMessage.GetInt();
return new StackTraceElement(declaringClass, methodName, fileName, lineNumber);
}
public static Member Decode(IClientMessage clientMessage)
{
Address address = AddressCodec.Decode(clientMessage);
string uuid = clientMessage.GetStringUtf8();
bool liteMember = clientMessage.GetBoolean();
int attributeSize = clientMessage.GetInt();
IDictionary<string, string> attributes = new Dictionary<string, string>();
for (int i = 0; i < attributeSize; i++)
{
string key = clientMessage.GetStringUtf8();
string value = clientMessage.GetStringUtf8();
attributes[key] = value;
}
return new Member(address, uuid, attributes, liteMember);
}
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 StackTraceElement Decode(IClientMessage clientMessage)
{
var declaringClass = clientMessage.GetStringUtf8();
var methodName = clientMessage.GetStringUtf8();
var filename_Null = clientMessage.GetBoolean();
string fileName = null;
if (!filename_Null)
{
fileName = clientMessage.GetStringUtf8();
}
var lineNumber = clientMessage.GetInt();
return(new StackTraceElement(declaringClass, methodName, fileName, lineNumber));
}
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, 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, 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 Member Decode(IClientMessage clientMessage)
{
var address = AddressCodec.Decode(clientMessage);
var uuid = clientMessage.GetStringUtf8();
var liteMember = clientMessage.GetBoolean();
var attributeSize = clientMessage.GetInt();
IDictionary <string, string> attributes = new Dictionary <string, string>();
for (var i = 0; i < attributeSize; i++)
{
var key = clientMessage.GetStringUtf8();
var value = clientMessage.GetStringUtf8();
attributes[key] = value;
}
return(new Member(address, uuid, attributes, liteMember));
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var value = clientMessage.GetLong();
parameters.value = value;
var replicaTimestampsSize = clientMessage.GetInt();
var replicaTimestamps = new List <KeyValuePair <string, long> >(replicaTimestampsSize);
for (var replicaTimestampsIndex = 0; replicaTimestampsIndex < replicaTimestampsSize; replicaTimestampsIndex++)
{
var replicaTimestampsItemKey = clientMessage.GetStringUtf8();
var replicaTimestampsItemVal = clientMessage.GetLong();
var replicaTimestampsItem = new KeyValuePair <string, long>(replicaTimestampsItemKey, replicaTimestampsItemVal);
replicaTimestamps.Add(replicaTimestampsItem);
}
parameters.replicaTimestamps = replicaTimestamps;
var replicaCount = clientMessage.GetInt();
parameters.replicaCount = replicaCount;
return(parameters);
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var response = clientMessage.GetStringUtf8();
parameters.response = response;
return(parameters);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
ResponseParameters parameters = new ResponseParameters();
string response = null;
response = clientMessage.GetStringUtf8();
parameters.response = response;
return parameters;
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
string response = null;
response = clientMessage.GetStringUtf8();
parameters.response = response;
return(parameters);
}
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, 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 Error(IClientMessage message)
{
ErrorCode = message.GetInt();
ClassName = message.GetStringUtf8();
var message_isNull = message.GetBoolean();
if (!message_isNull)
{
Message = message.GetStringUtf8();
}
var stackTraceCount = message.GetInt();
StackTrace = new StackTraceElement[stackTraceCount];
for (var i = 0; i < stackTraceCount; i++)
{
StackTrace[i] = StackTraceElementCodec.Decode(message);
}
CauseErrorCode = message.GetInt();
var causeClassName_isNull = message.GetBoolean();
if (!causeClassName_isNull)
{
CauseClassName = message.GetStringUtf8();
}
}
public static Address Decode(IClientMessage clientMessage)
{
var host = clientMessage.GetStringUtf8();
var port = clientMessage.GetInt();
try
{
return new Address(host, port);
}
catch (SocketException)
{
return null;
}
}
public static Address Decode(IClientMessage clientMessage)
{
var host = clientMessage.GetStringUtf8();
var port = clientMessage.GetInt();
try
{
return(new Address(host, port));
}
catch (SocketException)
{
return(null);
}
}
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);
}
public static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
byte status;
status = clientMessage.GetByte();
parameters.status = status;
Address address = null;
var address_isNull = clientMessage.GetBoolean();
if (!address_isNull)
{
address = AddressCodec.Decode(clientMessage);
parameters.address = address;
}
string uuid = null;
var uuid_isNull = clientMessage.GetBoolean();
if (!uuid_isNull)
{
uuid = clientMessage.GetStringUtf8();
parameters.uuid = uuid;
}
string ownerUuid = null;
var ownerUuid_isNull = clientMessage.GetBoolean();
if (!ownerUuid_isNull)
{
ownerUuid = clientMessage.GetStringUtf8();
parameters.ownerUuid = ownerUuid;
}
byte serializationVersion;
serializationVersion = clientMessage.GetByte();
parameters.serializationVersion = serializationVersion;
return(parameters);
}
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());
}
internal static ResponseParameters DecodeResponse(IClientMessage clientMessage)
{
var parameters = new ResponseParameters();
var namePartitionSequenceListSize = clientMessage.GetInt();
var namePartitionSequenceList =
new List <KeyValuePair <string, IList <KeyValuePair <int, long> > > >(namePartitionSequenceListSize);
for (var namePartitionSequenceListIndex = 0;
namePartitionSequenceListIndex < namePartitionSequenceListSize;
namePartitionSequenceListIndex++)
{
var namePartitionSequenceListItemKey = clientMessage.GetStringUtf8();
var namePartitionSequenceListItemValSize = clientMessage.GetInt();
var namePartitionSequenceListItemVal = new List <KeyValuePair <int, long> >(namePartitionSequenceListItemValSize);
for (var namePartitionSequenceListItemValIndex = 0;
namePartitionSequenceListItemValIndex < namePartitionSequenceListItemValSize;
namePartitionSequenceListItemValIndex++)
{
var namePartitionSequenceListItemValItemKey = clientMessage.GetInt();
var namePartitionSequenceListItemValItemVal = clientMessage.GetLong();
var namePartitionSequenceListItemValItem =
new KeyValuePair <int, long>(namePartitionSequenceListItemValItemKey,
namePartitionSequenceListItemValItemVal);
namePartitionSequenceListItemVal.Add(namePartitionSequenceListItemValItem);
}
var namePartitionSequenceListItem =
new KeyValuePair <string, IList <KeyValuePair <int, long> > >(namePartitionSequenceListItemKey,
namePartitionSequenceListItemVal);
namePartitionSequenceList.Add(namePartitionSequenceListItem);
}
parameters.namePartitionSequenceList = namePartitionSequenceList;
var partitionUuidListSize = clientMessage.GetInt();
var partitionUuidList = new List <KeyValuePair <int, Guid> >(partitionUuidListSize);
for (var partitionUuidListIndex = 0; partitionUuidListIndex < partitionUuidListSize; partitionUuidListIndex++)
{
var partitionUuidListItemKey = clientMessage.GetInt();
var partitionUuidListItemVal = GuidCodec.Decode(clientMessage);
var partitionUuidListItem = new KeyValuePair <int, Guid>(partitionUuidListItemKey, partitionUuidListItemVal);
partitionUuidList.Add(partitionUuidListItem);
}
parameters.partitionUuidList = partitionUuidList;
return(parameters);
}
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, 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());
}
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);
}
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());
}
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);
}
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());
}
public static DistributedObjectInfo Decode(IClientMessage clientMessage)
{
var serviceName = clientMessage.GetStringUtf8();
var name = clientMessage.GetStringUtf8();
return new DistributedObjectInfo(serviceName, name);
}
public static void Handle(IClientMessage clientMessage, HandleEntry handleEntry)
{
int messageType = clientMessage.GetMessageType();
if (messageType == EventMessageConst.EventEntry) {
IData key = null;
bool key_isNull = clientMessage.GetBoolean();
if (!key_isNull)
{
key = clientMessage.GetData();
}
IData value = null;
bool value_isNull = clientMessage.GetBoolean();
if (!value_isNull)
{
value = clientMessage.GetData();
}
IData oldValue = null;
bool oldValue_isNull = clientMessage.GetBoolean();
if (!oldValue_isNull)
{
oldValue = clientMessage.GetData();
}
IData mergingValue = null;
bool 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;
}
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)
{
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());
}
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());
}
