/// <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
IBufferObjectDataOutput @out = serializationService.CreateObjectDataOutput(1024);
@out.WriteData(data);
byte[] bytes = @out.ToByteArray();
// emulate socket read by reading data from stream
IBufferObjectDataInput @in = serializationService2.CreateObjectDataInput(bytes);
data = @in.ReadData();
// read data
object 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
object 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());
}
/// <exception cref="System.IO.IOException"/>
internal IPortable ReadAndInitialize(IBufferObjectDataInput @in, int factoryId, int classId)
{
var p = Read(@in, factoryId, classId);
var managedContext = _context.GetManagedContext();
return(managedContext != null ? (IPortable)managedContext.Initialize(p) : p);
}
private DefaultPortableReader CreateReader(IBufferObjectDataInput input, int factoryId, int classId, int version,
int portableVersion)
{
var effectiveVersion = version;
if (version < 0)
{
effectiveVersion = _context.GetVersion();
}
var cd = _context.LookupClassDefinition(factoryId, classId, effectiveVersion);
if (cd == null)
{
var begin = input.Position();
cd = _context.ReadClassDefinition(input, factoryId, classId, effectiveVersion);
input.Position(begin);
}
DefaultPortableReader reader;
if (portableVersion == effectiveVersion)
{
reader = new DefaultPortableReader(this, input, cd);
}
else
{
reader = new MorphingPortableReader(this, input, cd);
}
return(reader);
}
/// <exception cref="System.IO.IOException"></exception>
internal DefaultPortableReader CreateReader(IBufferObjectDataInput input)
{
var factoryId = input.ReadInt();
var classId = input.ReadInt();
var version = input.ReadInt();
return(CreateReader(input, factoryId, classId, version, version));
}
public void ReturnInputBuffer(IBufferObjectDataInput input)
{
if (input == null)
{
return;
}
input.Clear();
OfferOrClose(inputQueue, input);
}
internal DefaultPortableReader CreateMorphingReader(IBufferObjectDataInput input)
{
var factoryId = input.ReadInt();
var classId = input.ReadInt();
var version = input.ReadInt();
var portable = CreateNewPortableInstance(factoryId, classId);
var portableVersion = FindPortableVersion(factoryId, classId, portable);
return(CreateReader(input, factoryId, classId, version, portableVersion));
}
/// <exception cref="System.IO.IOException"/>
private IPortable Read(IBufferObjectDataInput @in, int factoryId, int classId)
{
var version = @in.ReadInt();
var portable = CreateNewPortableInstance(factoryId, classId);
var portableVersion = FindPortableVersion(factoryId, classId, portable);
var reader = CreateReader(@in, factoryId, classId, version, portableVersion);
portable.ReadPortable(reader);
reader.End();
return(portable);
}
public DefaultPortableReader(PortableSerializer serializer, IBufferObjectDataInput @in, IClassDefinition cd)
{
_in = @in;
Serializer = serializer;
Cd = cd;
int fieldCount;
try
{
// final position after portable is read
_finalPosition = @in.ReadInt();
// field count
fieldCount = @in.ReadInt();
}
catch (IOException e)
{
throw new HazelcastSerializationException(e);
}
if (fieldCount != cd.GetFieldCount())
{
throw new InvalidOperationException("Field count[" + fieldCount + "] in stream does not match " + cd);
}
_offset = @in.Position();
}
/// <exception cref="System.IO.IOException" />
internal IClassDefinition ReadClassDefinition(IBufferObjectDataInput @in, int factoryId, int classId, int version)
{
var register = true;
var builder = new ClassDefinitionBuilder(factoryId, classId, version);
// final position after portable is read
@in.ReadInt();
// field count
var fieldCount = @in.ReadInt();
var offset = @in.Position();
for (var i = 0; i < fieldCount; i++)
{
var pos = @in.ReadInt(offset + i * Bits.IntSizeInBytes);
@in.Position(pos);
var len = @in.ReadShort();
var chars = new char[len];
for (var k = 0; k < len; k++)
{
chars[k] = (char)@in.ReadUnsignedByte();
}
var type = (FieldType)(@in.ReadByte());
var name = new string(chars);
var fieldFactoryId = 0;
var fieldClassId = 0;
if (type == FieldType.Portable)
{
// is null
if (@in.ReadBoolean())
{
register = false;
}
fieldFactoryId = @in.ReadInt();
fieldClassId = @in.ReadInt();
if (register)
{
var fieldVersion = @in.ReadInt();
ReadClassDefinition(@in, fieldFactoryId, fieldClassId, fieldVersion);
}
}
else
{
if (type == FieldType.PortableArray)
{
var k_1 = @in.ReadInt();
fieldFactoryId = @in.ReadInt();
fieldClassId = @in.ReadInt();
if (k_1 > 0)
{
var p = @in.ReadInt();
@in.Position(p);
var fieldVersion = @in.ReadInt();
ReadClassDefinition(@in, fieldFactoryId, fieldClassId, fieldVersion);
}
else
{
register = false;
}
}
}
builder.AddField(new FieldDefinition(i, name, type, fieldFactoryId, fieldClassId));
}
var classDefinition = builder.Build();
if (register)
{
classDefinition = RegisterClassDefinition(classDefinition);
}
return(classDefinition);
}
public MorphingPortableReader(PortableSerializer serializer, IBufferObjectDataInput input, IClassDefinition cd)
: base(serializer, input, cd)
{
}
private void ReturnDataInput(IBufferObjectDataInput input) => _bufferPoolThreadLocal.Get().ReturnInputBuffer(input);
public void ReturnInputBuffer(IBufferObjectDataInput input) => _inputPool.Return(input);
/// <exception cref="System.IO.IOException" />
internal IClassDefinition ReadClassDefinition(IBufferObjectDataInput @in, int factoryId, int classId, int version)
{
var register = true;
var builder = new ClassDefinitionBuilder(factoryId, classId, version);
// final position after portable is read
@in.ReadInt();
// field count
var fieldCount = @in.ReadInt();
var offset = @in.Position();
for (var i = 0; i < fieldCount; i++)
{
var pos = @in.ReadInt(offset + i*Bits.IntSizeInBytes);
@in.Position(pos);
var len = @in.ReadShort();
var chars = new char[len];
for (var k = 0; k < len; k++)
{
chars[k] = (char) @in.ReadUnsignedByte();
}
var type = (FieldType) (@in.ReadByte());
var name = new string(chars);
var fieldFactoryId = 0;
var fieldClassId = 0;
if (type == FieldType.Portable)
{
// is null
if (@in.ReadBoolean())
{
register = false;
}
fieldFactoryId = @in.ReadInt();
fieldClassId = @in.ReadInt();
if (register)
{
var fieldVersion = @in.ReadInt();
ReadClassDefinition(@in, fieldFactoryId, fieldClassId, fieldVersion);
}
}
else
{
if (type == FieldType.PortableArray)
{
var k_1 = @in.ReadInt();
fieldFactoryId = @in.ReadInt();
fieldClassId = @in.ReadInt();
if (k_1 > 0)
{
var p = @in.ReadInt();
@in.Position(p);
var fieldVersion = @in.ReadInt();
ReadClassDefinition(@in, fieldFactoryId, fieldClassId, fieldVersion);
}
else
{
register = false;
}
}
}
builder.AddField(new FieldDefinition(i, name, type, fieldFactoryId, fieldClassId));
}
var classDefinition = builder.Build();
if (register)
{
classDefinition = RegisterClassDefinition(classDefinition);
}
return classDefinition;
}