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