public IEnumerable <IPersistenceObject> SetObjects(IZetboxContext ctx, IEnumerable <IPersistenceObject> objects, IEnumerable <ObjectNotificationRequest> notficationRequests)
{
IEnumerable <IPersistenceObject> result = null;
// Serialize
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(_map, new BinaryWriter(ms)))
{
SendObjects(objects, sw);
var handler = _memoryFactory.GetServerObjectSetHandler();
var changedObjects = handler
.SetObjects(ZetboxGeneratedVersionAttribute.Current, _backingStore, objects, notficationRequests ?? new ObjectNotificationRequest[0])
.Cast <IStreamable>();
var bytes = SendObjects(changedObjects, true).ToArray();
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes))))
{
// merge auxiliary objects into primary set objects result
List <IStreamable> auxObjects;
var receivedObjects = ReceiveObjects(ctx, sr, out auxObjects);
result = receivedObjects.Concat(auxObjects).Cast <IPersistenceObject>();
}
}
return(result);
}
private IEnumerable <IStreamable> ReceiveObjects(IZetboxContext ctx, ZetboxStreamReader sr, out List <IStreamable> auxObjects)
{
var result = ReceiveObjectList(ctx, sr);
auxObjects = ReceiveObjectList(ctx, sr);
return(result);
}
public IEnumerable <T> FetchRelation <T>(IZetboxContext ctx, Guid relationId, RelationEndRole role, IDataObject parent, out List <IStreamable> auxObjects)
where T : class, IRelationEntry
{
// TODO: could be implemented in generated properties
if (parent.ObjectState == DataObjectState.New)
{
auxObjects = new List <IStreamable>();
return(new List <T>());
}
Relation rel = ctx.FindPersistenceObject <Relation>(relationId);
IEnumerable <T> result = null;
List <IStreamable> tmpAuxObjects = null;
var handler = _memoryFactory
.GetServerCollectionHandler(
_backingStore,
_iftFactory(rel.A.Type.GetDataType()),
_iftFactory(rel.B.Type.GetDataType()),
role);
var objects = handler
.GetCollectionEntries(ZetboxGeneratedVersionAttribute.Current, _backingStore, relationId, role, parent.ID)
.Cast <IStreamable>();
var bytes = SendObjects(objects, true).ToArray();
using (MemoryStream s = new MemoryStream(bytes))
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(s)))
{
result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <T>();
}
auxObjects = tmpAuxObjects;
return(result);
}
public void Stream()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
var ctx = GetContext();
ctx.Attach(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t));
BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null);
result.FromStream(sr);
Assert.That(result.GetType(), Is.EqualTo(obj.GetType()));
Assert.That(result.ID, Is.EqualTo(obj.ID));
Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState));
}
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
TestInt = sr.ReadInt32();
TestString = sr.ReadString();
return baseResult;
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
TestProperty = sr.ReadString();
return(baseResult);
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.ReadConverter(i => _objectState = (DataObjectState)i);
return(baseResult);
}
public IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
sr.Read(out _ID);
sr.Read(out _StringProperty);
sr.Read(out _IntProperty);
sr.Read(out _BoolProperty);
return(null);
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.Read(out this._Value);
sr.Read(out this._fk_Parent);
return(baseResult);
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.ReadConverter(i => ClientObjectState = (DataObjectState)i);
sr.ReadInt32(); // ignore access permissions
return(baseResult);
}
private IEnumerable <IStreamable> ReceiveObjects(IZetboxContext ctx, ZetboxStreamReader sr, out List <IStreamable> auxObjects)
{
var result = ReceiveObjectList(ctx, sr);
auxObjects = ReceiveObjectList(ctx, sr);
Logging.Facade.DebugFormat("retrieved: {0} objects; {1} auxObjects", result.Count, auxObjects.Count);
return(result);
}
public override void SetUp()
{
base.SetUp();
readerFactory = scope.Resolve<ZetboxStreamReader.Factory>();
writerFactory = scope.Resolve<ZetboxStreamWriter.Factory>();
stream = new MemoryStream();
reader = readerFactory.Invoke(new BinaryReader(stream));
writer = writerFactory.Invoke(new BinaryWriter(stream));
}
public override void SetUp()
{
base.SetUp();
readerFactory = scope.Resolve <ZetboxStreamReader.Factory>();
writerFactory = scope.Resolve <ZetboxStreamWriter.Factory>();
stream = new MemoryStream();
reader = readerFactory.Invoke(new BinaryReader(stream));
writer = writerFactory.Invoke(new BinaryWriter(stream));
}
public void should_use_interfacetype_on_the_stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType()));
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader binStream)
{
var baseResult = base.FromStream(binStream);
binStream.Read(out this._MyIntProperty);
binStream.Read(out this._fk_ObjectProp);
binStream.Read(out this._StringProp);
{
int?baseValue;
binStream.Read(out baseValue);
((TestObjClass)this).TestEnumProp = (Zetbox.App.Test.TestEnum)baseValue;
}
return(baseResult);
}
public ZetboxService(IServerObjectHandlerFactory sohFactory, Func<IZetboxContext> ctxFactory, InterfaceType.Factory iftFactory, IPerfCounter perfCounter, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory)
{
if (readerFactory == null) throw new ArgumentNullException("readerFactory");
if (writerFactory == null) throw new ArgumentNullException("writerFactory");
Logging.Facade.Debug("Creating new ZetboxService instance");
_sohFactory = sohFactory;
_ctxFactory = ctxFactory;
_iftFactory = iftFactory;
_perfCounter = perfCounter;
_readerFactory = readerFactory;
_writerFactory = writerFactory;
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
InitialiseObject(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestObjClassSerializationMock.AssertCorrectContents <TestObjClass, TestEnum>(sr, _iftFactory);
}
public override IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
var result = new List <IPersistenceObject>();
this.fk_BaseTestObjClass = sr.ReadNullableInt32() ?? -1;
this._StringProp = sr.ReadString();
this._TestEnumProp = (TestEnum)sr.ReadInt32();
sr.ReadCollectionEntries(this, this.TestNamesImpl);
result.AddRange(this.TestNamesImpl.Cast <IPersistenceObject>());
return(baseResult == null
? result
: result.Concat(baseResult));
}
public Zetbox.App.Base.Blob SetBlobStream(IZetboxContext ctx, Stream stream, string filename, string mimetype)
{
Zetbox.App.Base.Blob result = null;
var handler = _memoryFactory.GetServerDocumentHandler();
var serverBlob = handler.SetBlobStream(ZetboxGeneratedVersionAttribute.Current, _backingStore, stream, filename, mimetype);
BlobResponse resp = new BlobResponse();
resp.ID = serverBlob.ID;
resp.BlobInstance = SendObjects(new IDataObject[] { serverBlob }, true);
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(resp.BlobInstance)))
{
result = ReceiveObjectList(ctx, sr).Cast <Zetbox.App.Base.Blob>().Single();
}
return(result);
}
private List <IStreamable> ReceiveObjectList(IZetboxContext ctx, ZetboxStreamReader sr)
{
List <IStreamable> result = new List <IStreamable>();
var cont = sr.ReadBoolean();
while (cont)
{
var objType = sr.ReadSerializableType();
IStreamable obj = (IStreamable)ctx.Internals().CreateUnattached(_iftFactory(objType.GetSystemType()));
obj.FromStream(sr);
result.Add((IStreamable)obj);
cont = sr.ReadBoolean();
}
return(result);
}
public IEnumerable <IDataObject> GetListOf(IZetboxContext ctx, InterfaceType ifType, int ID, string property, out List <IStreamable> auxObjects)
{
List <IStreamable> tmpAuxObjects = null;
IEnumerable <IDataObject> result = null;
var handler = _memoryFactory.GetServerObjectHandler(ifType);
var objects = handler.GetListOf(ZetboxGeneratedVersionAttribute.Current, _backingStore, ID, property);
var bytes = SendObjects(objects, true).ToArray();
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes))))
{
result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <IDataObject>();
}
auxObjects = tmpAuxObjects;
return(result);
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
InitialiseObject(ctx, obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
Assert.Ignore("need to implement mocked serialization for ObjectClass");
//TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, int>(sr);
}
}
public void FromStream_Attached()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var ctxMock = GetContext();
TestObjClass result = ctxMock.Create<TestObjClass>();
Assert.That(result.IsAttached, Is.True);
Assert.That(() => result.FromStream(sr), Throws.InstanceOf<InvalidOperationException>());
}
public HttpServiceClient(ICredentialsResolver credentialsResolver, ZetboxStreamReader.Factory readerFactory, ZetboxStreamWriter.Factory writerFactory)
{
if (credentialsResolver == null) throw new ArgumentNullException("credentialsResolver");
if (readerFactory == null) throw new ArgumentNullException("readerFactory");
if (writerFactory == null) throw new ArgumentNullException("writerFactory");
SetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetObjects");
GetObjectsUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetObjects");
GetListOfUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetListOf");
FetchRelationUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/FetchRelation");
GetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/GetBlobStream");
SetBlobStreamUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/SetBlobStream");
InvokeServerMethodUri = new Uri(ConfigurationManager.AppSettings["serviceUri"] + "/InvokeServerMethod");
_credentialsResolver = credentialsResolver;
_readerFactory = readerFactory;
_writerFactory = writerFactory;
}
public void FromStream_Attached()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var ctxMock = GetContext();
TestObjClass result = ctxMock.Create <TestObjClass>();
Assert.That(result.IsAttached, Is.True);
Assert.That(() => result.FromStream(sr), Throws.InstanceOf <InvalidOperationException>());
}
public void Stream()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestCompoundObject result = new TestCompoundObject();
result.FromStream(sr);
Assert.That(result.TestInt, Is.EqualTo(obj.TestInt));
Assert.That(result.TestString, Is.EqualTo(obj.TestString));
}
public void FromStream_Attached_fails()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
using (var ctx = GetContext())
{
var result = ctx.Create <ObjectClass>();
result.FromStream(sr);
}
}
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve <TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
Assert.Ignore("need to implement mocked serialization for ObjectClass");
//TestObjClassSerializationMock.ToStream<TestObjClass, int>(sw);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
obj.FromStream(sr);
//TestObjClassSerializationMock.AssertCorrectContentsInt<TestObjClass>(objImpl);
}
}
public IEnumerable <IDataObject> GetList(IZetboxContext ctx, InterfaceType ifType, int maxListCount, bool eagerLoadLists, IEnumerable <Expression> filter, IEnumerable <OrderBy> orderBy, out List <IStreamable> auxObjects)
{
List <IStreamable> tmpAuxObjects = null;
IEnumerable <IDataObject> result = null;
var handler = _memoryFactory.GetServerObjectHandler(ifType);
var objects = handler.GetList(
ZetboxGeneratedVersionAttribute.Current,
_backingStore,
maxListCount,
filter != null ? filter.ToList() : null,
orderBy != null ? orderBy.ToList() : null);
var bytes = SendObjects(objects, eagerLoadLists).ToArray();
using (var sr = new ZetboxStreamReader(_map, new BinaryReader(new MemoryStream(bytes))))
{
result = ReceiveObjects(ctx, sr, out tmpAuxObjects).Cast <IDataObject>();
}
auxObjects = tmpAuxObjects;
return(result);
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
TestObjClassSerializationMock.ToStream<TestObjClass, TestEnum>(sw, _iftFactory);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t));
var obj = new TestObjClassImpl();
obj.FromStream(sr);
ctx.Attach(obj);
TestObjClassSerializationMock.AssertCorrectContentsEnum<TestObjClass>(obj);
}
private List <IStreamable> ReceiveObjectList(IZetboxContext ctx, ZetboxStreamReader sr)
{
List <IStreamable> result = new List <IStreamable>();
bool cont = sr.ReadBoolean();
long dbgByteCounter = 0;
long dbgObjTypeByteCounter = 0;
while (cont)
{
long dbgCurrentPos = sr.BaseStream.Position;
var objType = sr.ReadSerializableType();
dbgObjTypeByteCounter += sr.BaseStream.Position - dbgCurrentPos;
IStreamable obj = (IStreamable)ctx.Internals().CreateUnattached(_iftFactory(objType.GetSystemType()));
obj.FromStream(sr);
result.Add((IStreamable)obj);
cont = sr.ReadBoolean();
long dbgSize = sr.BaseStream.Position - dbgCurrentPos;
dbgByteCounter += dbgSize;
}
Logging.Facade.DebugFormat("ReceiveObjectList: {0:n0} objects; {1:n0} bytes total size; {2:n0} bytes avg. size / object; Total ObjType size: {3:n0}; {4:n2}% of total", result.Count, dbgByteCounter, (double)dbgByteCounter / (double)result.Count, dbgObjTypeByteCounter, (double)dbgObjTypeByteCounter / (double)dbgByteCounter * 100.0);
return(result);
}
public void FromStream_creates_correct_Object()
{
var typeMap = scope.Resolve <TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
TestObjClassSerializationMock.ToStream <TestObjClass, TestEnum>(sw, _iftFactory);
sw.Flush();
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(TestObjClass)), string.Format("{0} not assignable to {1}", typeof(TestObjClass), t));
var obj = new TestObjClassImpl();
obj.FromStream(sr);
ctx.Attach(obj);
TestObjClassSerializationMock.AssertCorrectContentsEnum <TestObjClass>(obj);
}
public static void AssertCorrectContents <LOCALINTERFACE, ENUMTYPE>(ZetboxStreamReader sr, InterfaceType.Factory iftFactory)
where LOCALINTERFACE : TestObjClass <LOCALINTERFACE, ENUMTYPE>
where ENUMTYPE : struct
{
Assert.That(sr, Is.Not.Null, "no stream to inspect");
var objType = sr.ReadSerializableType();
Assert.That(objType, Is.EqualTo(GetSerializableType <LOCALINTERFACE, ENUMTYPE>(iftFactory)), "wrong interface type found");
var testObjId = sr.ReadInt32();
Assert.That(testObjId, Is.EqualTo(TestObjClassId), "wrong object ID found");
DataObjectState?objectState = null;
sr.ReadConverter(i => objectState = (DataObjectState)i);
Assert.That(objectState, Is.EqualTo(TestObjectState), "wrong ObjectState found");
int accessRights = sr.ReadInt32();
Assert.That(accessRights, Is.GreaterThan(0), "wrong Access Rights found");
// TestObjClass
// BaseTestObjClass Reference
int?testObjRefId;
sr.Read(out testObjRefId);
Assert.That(testObjRefId, Is.EqualTo(TestBaseClassId), "wrong BaseObjClass ID found");
// StringProp
string testStringProp;
sr.Read(out testStringProp);
Assert.That(testStringProp, Is.EqualTo(TestStringPropValue), "wrong StringProp Value found");
//// SubClasses are not serialized, but fetched lazily
//foreach (int subClassID in TestSubClassesIds)
//{
// bool continuationMarkerForSubClasses = false;
// BinarySerializer.FromStream(out continuationMarkerForSubClasses, sr);
// Assert.That(continuationMarkerForSubClasses, Is.True, "wrong continuation marker for subClassId {0}", subClassID);
// int readSubClassId;
// BinarySerializer.FromStream(out readSubClassId, sr);
// Assert.That(readSubClassId, Is.EqualTo(readSubClassId), "wrong subClassId read", subClassID);
//}
//bool continuationMarkerAfterSubClasses = false;
//BinarySerializer.FromStream(out continuationMarkerAfterSubClasses, sr);
//Assert.That(continuationMarkerAfterSubClasses, Is.False, "wrong continuation marker after subClassIds");
// TestEnumProp
var testEnum = (TestEnum)sr.ReadInt32();
Assert.That(testEnum, Is.EqualTo(TestEnum.TestSerializationValue), "wrong enum value found");
// TestNames
for (int i = 0; i < TestTestNamesIds.Length; i++)
{
var continuationMarkerForCes = sr.ReadBoolean();
Assert.That(continuationMarkerForCes, Is.True, "wrong continuation marker for testName #{0}", i);
var ceType = sr.ReadSerializableType();
Assert.That(ceType, Is.EqualTo(GetSerializableCollectionEntryType <LOCALINTERFACE, ENUMTYPE>(iftFactory)), "wrong interface type found for collection entry #{0}", i);
var readCeId = sr.ReadInt32();
Assert.That(readCeId, Is.EqualTo(TestTestNamesIds[i]), "wrong id read for collection entry #{0}", i);
DataObjectState?ceObjectState = null;
sr.ReadConverter(read => ceObjectState = (DataObjectState)read);
Assert.That(ceObjectState, Is.EqualTo(TestCollectionEntryState), "wrong ObjectState found for collection entry #{0}", i);
var readCeAccessRights = sr.ReadInt32();
Assert.That(readCeAccessRights, Is.GreaterThan(0), "wrong access rights for collection entry #{0}", i);
var readValue = sr.ReadString();
Assert.That(readValue, Is.EqualTo(TestTestNamesValues[i]), "wrong value read for collection entry #{0}", i);
}
var continuationMarkerAfterCes = sr.ReadBoolean();
Assert.That(continuationMarkerAfterCes, Is.False, "wrong continuation marker after testNames collection entries");
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.ReadConverter(i => ClientObjectState = (DataObjectState)i);
sr.ReadInt32(); // ignore access permissions
return baseResult;
}
public IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
sr.Read(out _ID);
sr.Read(out _TestName);
return null;
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.ReadConverter(i => _ObjectState = (DataObjectState)i);
sr.ReadConverter(i => ApplyRightsFromStream((API.AccessRights)i));
return baseResult;
}
public void Stream()
{
var typeMap = scope.Resolve<TypeMap>();
using (var ms = new MemoryStream())
using (var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms)))
using (var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms)))
{
var ctx = GetContext();
ctx.Attach(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t.GetSystemType().IsAssignableFrom(typeof(ANewObjectClass)), string.Format("{0} not assignable to {1}", typeof(ANewObjectClass), t));
BaseClientDataObjectMockImpl result = new BaseClientDataObjectMockImpl(null);
result.FromStream(sr);
Assert.That(result.GetType(), Is.EqualTo(obj.GetType()));
Assert.That(result.ID, Is.EqualTo(obj.ID));
Assert.That(result.ObjectState, Is.EqualTo(obj.ObjectState));
}
}
public IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
throw new NotImplementedException();
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
sr.ReadConverter(i => _objectState = (DataObjectState)i);
return baseResult;
}
public IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
sr.Read(out _ID);
sr.Read(out _StringProperty);
sr.Read(out _IntProperty);
sr.Read(out _BoolProperty);
return null;
}
private void InitStreams()
{
ms = new MemoryStream();
sw = scope.Resolve <ZetboxStreamWriter.Factory>().Invoke(new BinaryWriter(ms));
sr = scope.Resolve <ZetboxStreamReader.Factory>().Invoke(new BinaryReader(ms));
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader binStream)
{
var baseResult = base.FromStream(binStream);
binStream.Read(out this._MyIntProperty);
binStream.Read(out this._fk_ObjectProp);
binStream.Read(out this._StringProp);
{
int? baseValue;
binStream.Read(out baseValue);
((TestObjClass)this).TestEnumProp = (Zetbox.App.Test.TestEnum)baseValue;
}
return baseResult;
}
public IEnumerable <IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
sr.Read(out _ID);
sr.Read(out _TestName);
return(null);
}
public void should_use_interfacetype_on_the_stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
ms.Seek(0, SeekOrigin.Begin);
var t = sr.ReadSerializableType();
Assert.That(t, Is.EqualTo(_iftFactory(typeof(TestObjClass)).ToSerializableType()));
}
public override IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
var baseResult = base.FromStream(sr);
var result = new List<IPersistenceObject>();
this.fk_BaseTestObjClass = sr.ReadNullableInt32() ?? -1;
this._StringProp = sr.ReadString();
this._TestEnumProp = (TestEnum)sr.ReadInt32();
sr.ReadCollectionEntries(this, this.TestNamesImpl);
result.AddRange(this.TestNamesImpl.Cast<IPersistenceObject>());
return baseResult == null
? result
: result.Concat(baseResult);
}
public void ToStream_creates_correct_Stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
InitialiseObject(obj);
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestObjClassSerializationMock.AssertCorrectContents<TestObjClass, TestEnum>(sr, _iftFactory);
}
public IEnumerable<IPersistenceObject> FromStream(ZetboxStreamReader sr)
{
throw new NotImplementedException();
}
public void Stream()
{
var typeMap = scope.Resolve<TypeMap>();
var ms = new MemoryStream();
var sw = new ZetboxStreamWriter(typeMap, new BinaryWriter(ms));
var sr = new ZetboxStreamReader(typeMap, new BinaryReader(ms));
obj.ToStream(sw, null, false);
Assert.That(ms.Length, Is.GreaterThan(0));
ms.Seek(0, SeekOrigin.Begin);
TestCompoundObject result = new TestCompoundObject();
result.FromStream(sr);
Assert.That(result.TestInt, Is.EqualTo(obj.TestInt));
Assert.That(result.TestString, Is.EqualTo(obj.TestString));
}
