/// <summary>
/// Ensures that an entry has a key.
/// </summary>
/// <param name="entry">The entry.</param>
private void EnsureKey(ReadOnlyLazyEntry <TKey, TValue> entry)
{
if (entry.HasKey)
{
return;
}
entry.Key = _serializationService.ToObject <TKey>(entry.KeyData);
}
public bool TryGetValue(TKey key, out TValue value)
{
if (FindEntry(key, out var entry))
{
value = _serializationService.ToObject <TValue>(entry.Value);
return(true);
}
value = default(TValue);
return(false);
}
internal IEnumerable <KeyValuePair <int, KeyValuePair <object, object> > > AsAnchorIterator(ISerializationService serializationService)
{
var dataEntryIterator = AnchorDataList.GetEnumerator();
dataEntryIterator.MoveNext();
foreach (var pageNumber in AnchorPageList)
{
var dataEntry = dataEntryIterator.Current;
var key = serializationService.ToObject(dataEntry.Key);
var value = serializationService.ToObject(dataEntry.Value);
var entry = new KeyValuePair <object, object>(key, value);
yield return(new KeyValuePair <int, KeyValuePair <object, object> >(pageNumber, entry));
}
}
internal static void TestDifferentClassVersions(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("named-portable", 123);
var data = serializationService.ToData(p1);
var p2 = new NamedPortableV2("named-portable", 123);
var data2 = serializationService2.ToData(p2);
Parallel.For(0, 100, i => { serializationService2.ToObject <NamedPortableV2>(data); });
var o1 = serializationService2.ToObject <NamedPortableV2>(data);
var o2 = serializationService.ToObject <NamedPortable>(data2);
Assert.AreEqual(o1.name, o2.name);
}
private void AssertAggregator <TAggregator>(TAggregator aggregator, int classId)
where TAggregator : IAggregator
{
Assert.That(aggregator.FactoryId, Is.EqualTo(FactoryIds.AggregatorDsFactoryId));
Assert.That(aggregator.ClassId, Is.EqualTo(classId));
Assert.Throws <ArgumentException>(() => _ = Aggregator.Count(""));
Assert.Throws <ArgumentException>(() => _ = Aggregator.Count(null));
Assert.Throws <ArgumentNullException>(() => aggregator.WriteData(null));
Assert.Throws <ArgumentNullException>(() => aggregator.ReadData(null));
using var output = new ByteArrayObjectDataOutput(1024, _serializationService, Endianness.Unspecified);
aggregator.WriteData(output);
using var input = new ByteArrayObjectDataInput(output.Buffer, _serializationService, Endianness.Unspecified);
var a = (TAggregator)Activator.CreateInstance(typeof(TAggregator));
a.ReadData(input);
Assert.That(a.AttributePath, Is.EqualTo(aggregator.AttributePath));
var data = _serializationService.ToData(aggregator);
IAggregator x = null;
if (typeof(TAggregator).IsGenericType)
{
// doh - cannot deserialize generic types?
if (typeof(TAggregator).GetGenericTypeDefinition() == typeof(MaxAggregator <>))
{
x = _serializationService.ToObject <MaxAggregator <object> >(data);
}
else if (typeof(TAggregator).GetGenericTypeDefinition() == typeof(MinAggregator <>))
{
x = _serializationService.ToObject <MinAggregator <object> >(data);
}
else
{
Assert.Fail("Unsupported generic aggregator type.");
}
}
else
{
x = _serializationService.ToObject <TAggregator>(data);
}
Assert.That(x.AttributePath, Is.EqualTo(aggregator.AttributePath));
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
NamedPortable portableV1 = new NamedPortable("portable-v1", 111);
IData dataV1 = serializationService.ToData(portableV1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(dataV1);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
dataV1 = @in.ReadData();
// serialize new portable version
var portableV2 = new NamedPortableV2("portable-v2", 123, 500);
var dataV2 = serializationService2.ToData(portableV2);
NamedPortable v1FromV2 = serializationService.ToObject <NamedPortable>(dataV2);
Assert.AreEqual(portableV2.name, v1FromV2.name);
Assert.AreEqual(portableV2.k, v1FromV2.k);
NamedPortableV2 v2FromV1 = serializationService2.ToObject <NamedPortableV2>(dataV1);
Assert.AreEqual(portableV1.name, v2FromV1.name);
Assert.AreEqual(portableV1.k, v2FromV1.k);
Assert.AreEqual(v2FromV1.v, 0);
}
static void Mainzz(string[] args)
{
var clientConfig = new ClientConfig();
clientConfig.GetNetworkConfig().AddAddress("127.0.0.1");
clientConfig.GetSerializationConfig().AddDataSerializableFactory(1, new MyDataSerializableFactory());
IHazelcastInstance client = HazelcastClient.NewHazelcastClient(clientConfig);
//All cluster operations that you can do with ordinary HazelcastInstance
IMap <string, DataSerializableType> map = client.GetMap <string, DataSerializableType>("imap");
ISerializationService service = ((HazelcastClientProxy)client).GetSerializationService();
object obj = new DataSerializableType(1000, 1000);
long start = Clock.CurrentTimeMillis();
var data = service.ToData(obj);
var dataSerializableType = service.ToObject <DataSerializableType>(data);
long diff = Clock.CurrentTimeMillis() - start;
Console.WriteLine("Serialization time:" + diff);
Console.ReadKey();
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("portable-v1", 111);
var data = serializationService.ToData(p1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(data);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
data = @in.ReadData();
// read data
var object1 = serializationService2.ToObject <object>(data);
// serialize new portable version
var p2 = new NamedPortableV2("portable-v2", 123);
var data2 = serializationService2.ToData(p2);
// de-serialize back using old version
var object2 = serializationService.ToObject <object>(data2);
Assert.IsNotNull(object1, "object1 should not be null!");
Assert.IsNotNull(object2, "object2 should not be null!");
Assert.IsInstanceOf <NamedPortableV2>(object1, "Should be instance of NamedPortableV2: " + object1.GetType());
Assert.IsInstanceOf <NamedPortable>(object2, "Should be instance of NamedPortable: " + object2.GetType());
}
internal static void TestPreDefinedDifferentVersions(ISerializationService serializationService,
ISerializationService serializationService2, MainPortable mainPortable)
{
var data = serializationService.ToData(mainPortable);
Assert.AreEqual(mainPortable, serializationService2.ToObject <MainPortable>(data));
}
public void TestSerializeDeserializeJsonValue()
{
var jsonValue = new HazelcastJsonValue("{ \"key\": \"value\" }");
var jsonData = _serializationService.ToData(jsonValue);
var jsonDeserialized = _serializationService.ToObject <HazelcastJsonValue>(jsonData);
Assert.AreEqual(jsonValue, jsonDeserialized);
}
/// <summary>
/// Ensures that a cache entry has a value.
/// </summary>
/// <param name="entry">The cache entry.</param>
private void EnsureValue(ReadOnlyLazyEntry <TValue> entry)
{
if (entry.HasValue)
{
return;
}
// accepted race-condition here
entry.Value = _serializationService.ToObject <TValue>(entry.ValueData);
}
private T AssertPredicate <T>(T predicate, int classId)
where T : IPredicate
{
Assert.That(predicate.FactoryId, Is.EqualTo(FactoryIds.PredicateFactoryId));
Assert.That(predicate.ClassId, Is.EqualTo(classId));
Assert.Throws <ArgumentNullException>(() => predicate.WriteData(null));
Assert.Throws <ArgumentNullException>(() => predicate.ReadData(null));
using var output = new ByteArrayObjectDataOutput(1024, _serializationService, Endianness.Unspecified);
predicate.WriteData(output);
T p = default;
if (typeof(T) != typeof(PagingPredicate) && typeof(T) != typeof(PartitionPredicate))
{
using var input = new ByteArrayObjectDataInput(output.Buffer, _serializationService, Endianness.Unspecified);
p = (T)Activator.CreateInstance(typeof(T));
p.ReadData(input);
Assert.That(predicate.Equals(p));
Assert.That(predicate.Equals(predicate));
Assert.That(predicate.Equals(null), Is.False);
Assert.That(Equals(predicate, p));
Assert.That(Equals(predicate, predicate));
Assert.That(Equals(predicate, null), Is.False);
var type = typeof(T);
MethodInfo staticEquals;
do
{
staticEquals = type.GetMethod("Equals", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
type = type.BaseType;
} while (staticEquals == null && type != typeof(object));
Assert.That(staticEquals, Is.Not.Null);
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, p }));
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, predicate }));
Assert.That((bool)staticEquals.Invoke(null, new object[] { predicate, null }), Is.False);
var data = _serializationService.ToData(predicate);
p = _serializationService.ToObject <T>(data);
Assert.That(predicate.Equals(p));
}
_ = predicate.GetHashCode();
Console.WriteLine($"{typeof(T)}: {predicate}");
return(p);
}
public virtual void TestLargeStringEncodeDecode()
{
var sb = new StringBuilder();
var i = 0;
var j = 0;
while (j < TestStrSize)
{
var ch = i++ % char.MaxValue;
if (char.IsLetter((char)ch))
{
sb.Append(ch);
j++;
}
}
var actualStr = sb.ToString();
var strBytes = Encoding.UTF8.GetBytes(actualStr);
var actualDataBytes = _serializationService.ToData(actualStr).ToByteArray();
var expectedDataByte = ToDataByte(strBytes, actualStr.Length);
var decodedStr = (string)_serializationService.ToObject <object>(new HeapData(expectedDataByte));
Assert.AreEqual(expectedDataByte, actualDataBytes, "Deserialized byte array do not match utf-8 encoding");
Assert.AreEqual(decodedStr, actualStr);
}
public bool MoveNext()
{
if (iter.MoveNext())
{
try
{
_currentE = serializationService.ToObject <E>(iter.Current);
return(true);
}
catch (Exception)
{
return(false);
}
}
return(false);
}
public ICollection <IDistributedObject> GetDistributedObjects()
{
try
{
var request = ClientGetDistributedObjectsCodec.EncodeRequest();
var task = invocationService.InvokeOnRandomTarget(request);
var response = ThreadUtil.GetResult(task);
var result = ClientGetDistributedObjectsCodec.DecodeResponse(response).infoCollection;
foreach (var data in result)
{
var o = serializationService.ToObject <DistributedObjectInfo>(data);
GetDistributedObject <IDistributedObject>(o.GetServiceName(), o.GetName());
}
return(proxyManager.GetDistributedObjects());
}
catch (Exception e)
{
throw ExceptionUtil.Rethrow(e);
}
}
internal static void TestDifferentClassVersions(ISerializationService serializationService,
ISerializationService serializationService2)
{
NamedPortable portableV1 = new NamedPortable("named-portable", 123);
IData dataV1 = serializationService.ToData(portableV1);
NamedPortableV2 portableV2 = new NamedPortableV2("named-portable", 123, 500);
IData dataV2 = serializationService2.ToData(portableV2);
NamedPortable v1FromV2 = serializationService.ToObject <NamedPortable>(dataV2);
Assert.AreEqual(portableV2.name, v1FromV2.name);
Assert.AreEqual(portableV2.k, v1FromV2.k);
NamedPortableV2 v2FromV1 = serializationService2.ToObject <NamedPortableV2>(dataV1);
Assert.AreEqual(portableV1.name, v2FromV1.name);
Assert.AreEqual(portableV1.k, v2FromV1.k);
Assert.AreEqual(v2FromV1.v, 0);
//Assert.IsNull(v2FromV1.v);
}
public virtual void TestNestedPortableVersionedSerializer()
{
SerializationServiceBuilder builder1 = new SerializationServiceBuilder();
builder1.SetPortableVersion(6);
builder1.AddPortableFactory(1, new MyPortableFactory());
ISerializationService ss1 = builder1.Build();
SerializationServiceBuilder builder2 = new SerializationServiceBuilder();
builder2.SetPortableVersion(6);
builder2.AddPortableFactory(1, new MyPortableFactory());
ISerializationService ss2 = builder2.Build();
//make sure ss2 cached class definition of Child
ss2.ToData(new Child("ubeyd"));
//serialized parent from ss1
Parent parent = new Parent(new Child("ubeyd"));
IData data = ss1.ToData(parent);
// cached class definition of Child and the class definition from data coming from ss1 should be compatible
Assert.AreEqual(parent, ss2.ToObject <Parent>(data));
}
internal static void TestPreDefinedDifferentVersions(ISerializationService serializationService,
ISerializationService serializationService2, MainPortable mainPortable)
{
var data = serializationService.ToData(mainPortable);
Assert.AreEqual(mainPortable, serializationService2.ToObject<MainPortable>(data));
}
/// <exception cref="System.IO.IOException" />
internal static void TestDifferentClassVersionsUsingDataWriteAndRead(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("portable-v1", 111);
var data = serializationService.ToData(p1);
// emulate socket write by writing data to stream
var @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(data);
var bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
var @in = serializationService2.CreateObjectDataInput(bytes);
data = @in.ReadData();
// read data
var object1 = serializationService2.ToObject<object>(data);
// serialize new portable version
var p2 = new NamedPortableV2("portable-v2", 123);
var data2 = serializationService2.ToData(p2);
// de-serialize back using old version
var object2 = serializationService.ToObject<object>(data2);
Assert.IsNotNull(object1, "object1 should not be null!");
Assert.IsNotNull(object2, "object2 should not be null!");
Assert.IsInstanceOf<NamedPortableV2>(object1, "Should be instance of NamedPortableV2: " + object1.GetType());
Assert.IsInstanceOf<NamedPortable>(object2, "Should be instance of NamedPortable: " + object2.GetType());
}
internal static void TestDifferentClassVersions(ISerializationService serializationService,
ISerializationService serializationService2)
{
var p1 = new NamedPortable("named-portable", 123);
var data = serializationService.ToData(p1);
var p2 = new NamedPortableV2("named-portable", 123);
var data2 = serializationService2.ToData(p2);
var o1 = serializationService2.ToObject<NamedPortableV2>(data);
var o2 = serializationService.ToObject<NamedPortable>(data2);
Assert.AreEqual(o1.name, o2.name);
}
private TOut ValueFactory <TOut>(object input)
{
return(_serializationService.ToObject <TOut>(input));
}
