public void CanSerializeWithSurrogate() { var surrogateHasBeenInvoked = false; var surrogates = new[] { Surrogate.Create <Foo, FooSurrogate>(FooSurrogate.FromFoo, surrogate => { surrogateHasBeenInvoked = true; return(surrogate.Restore()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var foo = new Foo { Bar = "I will be replaced!" }; serializer.Serialize(foo, stream); stream.Position = 0; var actual = serializer.Deserialize <Foo>(stream); Assert.Equal(foo.Bar, actual.Bar); Assert.True(surrogateHasBeenInvoked); }
public void Issue263_CanSerializeArrayOfSurrogate_WhenPreservingObjectReference() { var invoked = new List <SurrogatedClass.ClassSurrogate>(); var serializer = new Serializer(new SerializerOptions( preserveObjectReferences: true, surrogates: new [] { Surrogate.Create <SurrogatedClass, SurrogatedClass.ClassSurrogate>( to => to.ToSurrogate(), from => { invoked.Add(from); return(from.FromSurrogate()); }), })); var objectRef = new SurrogatedClass(5); var expected = new List <SurrogatedClass> { objectRef, objectRef }; using (var stream = new MemoryStream()) { serializer.Serialize(expected, stream); stream.Position = 0; var deserialized = serializer.Deserialize <List <SurrogatedClass> >(stream); deserialized.Count.Should().Be(2); invoked.Count.Should().Be(1); ReferenceEquals(deserialized[0], deserialized[1]).Should().BeTrue(); } }
static void Main(string[] args) { IHuman Bruce = new Operator(); Surrogate surrogate = new Surrogate(Bruce); surrogate.Request(); }
public void CanSerializeWithSurrogateInCollection() { var invoked = new List <ISurrogate>(); var surrogates = new[] { Surrogate.Create <IOriginal, ISurrogate>(from => from.ToSurrogate(), surrogate => { invoked.Add(surrogate); return(surrogate.FromSurrogate()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var key = new SurrogatedKey("test key"); var foo = new Foo { Bar = "I will be replaced!" }; var dictionary = new Dictionary <SurrogatedKey, Foo> { [key] = foo }; serializer.Serialize(dictionary, stream); stream.Position = 0; var actual = serializer.Deserialize <Dictionary <SurrogatedKey, Foo> > (stream); Assert.Equal(key, actual.Keys.First()); Assert.Equal(foo.Bar, actual[key].Bar); Assert.Equal(2, invoked.Count); }
public void AssignInheritedReferences() { _AttackManager = GetComponent <AttackManager>(); _HealthManager = GetComponent <HealthManager>(); // These don't have any public variables, so adding them at the runtime makes the prefab less cluttered _DamageManager = gameObject.AddComponent <DamageManager>(); _CollisionKeeper = gameObject.AddComponent <CollisionKeeper>(); _Rigidbody2D = GetComponent <Rigidbody2D>(); _Collider2D = GetComponent <CapsuleCollider2D>(); _SpriteRenderer = GetComponent <SpriteRenderer>(); _Sprite = _SpriteRenderer.sprite; var surrogatePrefab = (GameObject)Resources.Load("Prefabs/Surrogate"); var surrogate = Instantiate(surrogatePrefab); surrogate.layer = gameObject.layer; surrogate.name = $"{gameObject.name} Surrogate"; surrogate.transform.position = gameObject.transform.position; _Surrogate = surrogate.GetComponent <Surrogate>(); _Surrogate.SetOwner(gameObject); foreach (var weapon in HeldWeapons) { weapon.WeaponObject = Instantiate(weapon.WeaponPrefab, _Surrogate.gameObject.transform); weapon.WeaponObject.layer = gameObject.layer; weapon._Weapon = weapon.WeaponObject.GetComponent <Weapon>(); weapon._Weapon.Owner = gameObject; } }
public static Buffer Create(Surrogate surrogate) { Buffer buffer = new Buffer(surrogate); buffer.InitAssociations(); return(buffer); }
public void Initialize(Logger logger) { var surogates = new[] { Surrogate.Create <ActorPath, ActorPathSurrogate>(ActorPathSurrogate.From, x => x.Original()), Surrogate.Create <StreamPath, StreamPathSurrogate>(StreamPathSurrogate.From, x => x.Original()), Surrogate.Create <ActorRef, ActorRefSurrogate>(ActorRefSurrogate.From, x => x.Original(this)), Surrogate.Create <StreamRef, StreamRefSurrogate>(StreamRefSurrogate.From, x => x.Original(this)), Surrogate.Create <ClientRef, ClientRefSurrogate>(ClientRefSurrogate.From, x => x.Original(this)), }; var options = new SerializerOptions( versionTolerance: true, preserveObjectReferences: true, surrogates: surogates); serializer = new Hyperion.Serializer(options); options = new SerializerOptions( versionTolerance: false, preserveObjectReferences: true, surrogates: surogates); copier = new Hyperion.Serializer(options); }
private void SetUpWindow(bool createIfNotExist) { if (Configs == null || Configs.Count < 1) { return; } var container = CustomEditorWindow <Configuration> .GetWindow(createIfNotExist); if (container == null) { return; } var assets = new Assets(_assetsDirectory); Utility.DiagnosticRun(assets.Load); _targetGui = new Surrogate <IGUIContainer, Assets>(container, assets); _targetGui.Container.DrawGuiCallback = DrawCrashReporterGui; if (createIfNotExist) { _targetGui.Container.Show(); } }
public void CanSerializeWithInterfaceSurrogate() { var surrogateHasBeenInvoked = false; var surrogates = new[] { Surrogate.Create <IOriginal, ISurrogate>(from => from.ToSurrogate(), surrogate => { surrogateHasBeenInvoked = true; return(surrogate.FromSurrogate()); }) }; var stream = new MemoryStream(); var serializer = new Serializer(new SerializerOptions(surrogates: surrogates)); var foo = new Foo { Bar = "I will be replaced!" }; serializer.Serialize(foo, stream); stream.Position = 0; var actual = serializer.Deserialize <Foo>(stream); Assert.AreEqual(foo.Bar, actual.Bar); Assert.IsTrue(surrogateHasBeenInvoked); }
private void SetUpWindow(bool createIfNotExist) { var container = CustomEditorWindow <Configuration> .GetWindow(createIfNotExist); if (container == null) { return; } _feedbackMessage = Config.FeedbackMessage; _starRects = new Rect[Config.MaxStar]; var assetsDirectory = Utility.GetPathRelativeToCurrentDirectory("Editor Resources"); var assets = new Assets(assetsDirectory); Utility.DiagnosticRun(assets.Load); _targetGui = new Surrogate <IGUIContainer, Assets>(container, assets); _targetGui.Container.DrawGuiCallback = DrawRateGui; if (createIfNotExist) { _targetGui.Container.Show(); } SetCountStar(1); }
private void SetUpWindow(bool createIfNotExist) { var container = CustomEditorWindow <Configuration> .GetWindow(createIfNotExist); if (container == null) { return; } Utility.DiagnosticRun(LoadMenuItems); var assetsDirectory = Utility.GetPathRelativeToCurrentDirectory("Editor Resources"); var assets = new Assets(assetsDirectory); Utility.DiagnosticRun(assets.Load); container.DrawGuiCallback = OnWindowGui; container.CloseCallback = OnWindowClosed; container.LostFocusCallback = OnWindowLostFocus; container.FocusCallback = OnWindowFocus; _target = new Surrogate <IGUIContainer, Assets>(container, assets); if (createIfNotExist) { container.Show(); container.Focus(); } }
/// <summary> /// Initializes a new instance of the <see cref="HyperionSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> /// <param name="settings">Serializer settings.</param> public HyperionSerializer(ExtendedActorSystem system, HyperionSerializerSettings settings) : base(system) { Settings = settings; var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); var provider = CreateKnownTypesProvider(system, settings.KnownTypesProvider); if (system != null) { var settingsSetup = system.Settings.Setup.Get <HyperionSerializerSetup>() .GetOrElse(HyperionSerializerSetup.Empty); settingsSetup.ApplySettings(Settings); } _serializer = new HySerializer(new SerializerOptions( versionTolerance: settings.VersionTolerance, preserveObjectReferences: settings.PreserveObjectReferences, surrogates: new[] { akkaSurrogate }, serializerFactories: null, knownTypes: provider.GetKnownTypes(), ignoreISerializable: true, packageNameOverrides: settings.PackageNameOverrides)); }
public void DestroySurrogate() { if (m_MonoBehaviour) { DestroyImmediate(m_MonoBehaviour.gameObject); m_MonoBehaviour = null; } }
static void _MemCacheRelease(dfs.DfsFile df, bool force) { dfs dc = LoadDfsConfig(); string exception = ""; string[] slaves = dc.Slaves.SlaveList.Split(';'); { //foreach (string slave in slaves) MySpace.DataMining.Threading.ThreadTools <string> .Parallel( new Action <string>( delegate(string slave) { System.Net.Sockets.NetworkStream nstm = Surrogate.ConnectService(slave); nstm.WriteByte((byte)'C'); nstm.WriteByte((byte)'r'); XContent.SendXContent(nstm, df.Name); XContent.SendXContent(nstm, new byte[1] { (byte)(force ? 1 : 0) }); int ich = nstm.ReadByte(); if ('+' != ich) { string errmsg = null; if ('-' == ich) { try { errmsg = XContent.ReceiveXString(nstm, null); } catch { } } lock (slaves) { string newexception; if (null != errmsg) { newexception = ("Error received from DO service during MemCache rollback from " + slave + ": " + errmsg); } else { newexception = ("Did not receive a success signal from DO service during MemCache rollback from " + slave); } if (string.IsNullOrEmpty(exception) || -1 != exception.IndexOf("MemCacheWarning")) { exception = newexception; } } } }), slaves, slaves.Length); } if (!string.IsNullOrEmpty(exception)) { throw new Exception(exception); } }
public object GetObjectToSerialize(object obj, Type targetType) { var message = obj.AsValid <Subject>() .Message; var result = new Surrogate { Message = $"Hello world from Surrogate: {message}" }; return(result); }
internal PostsCollection(Surrogate surrogate, IFindierService findierService) { foreach (var item in surrogate.Items) { Add(item); } _request = surrogate.Request; _findierService = findierService; _currentResponse = surrogate.CurrentResponse; }
internal MoviesIncrementalLoadingCollection(Surrogate surrogate) { foreach (var moviePartial in surrogate.Items) { Add(moviePartial); } _request = surrogate.Request; _currentResponse = surrogate.CurrentResponse; _maxCount = surrogate.CurrentResponse?.Data?.MovieCount ?? -1; }
TypeData MakeGenericTypeData(IReadOnlyList <TypeData> parameters) { if (!IsSupported) { return(this); } if (IsGenericParameter) { return(parameters[this.GenericParameterIndex]); } if (!IsGeneric) { return(this); } var result = new TypeData() { IsSupported = true, Kind = Kind, IsSealed = IsSealed, IsReference = IsReference, IsEnum = IsEnum, IsInterface = IsInterface, HasConverter = HasConverter, IsISerializable = IsISerializable, IsGeneric = true, IsGenericTypeDefinition = false, IsNullable = IsNullable, Element = this, GenericParameters = GenericParameters.Select(x => x.MakeGenericTypeData(parameters)).ToList().AsReadOnly(), }; result.BaseType = BaseType?.MakeGenericTypeData(parameters); result.Surrogate = Surrogate?.MakeGenericTypeData(parameters); if (Surrogate == null && !IsInterface && !IsArray && !IsEnum && !IsGenericParameter) { foreach (var m in Members) { var rm = new Member(result); rm.Name = m.Name; rm.Type = m.Type.MakeGenericTypeData(parameters); result.Members.Add(rm); } result.CollectionType = CollectionType; result.Collection1 = Collection1?.MakeGenericTypeData(parameters); result.Collection2 = Collection2?.MakeGenericTypeData(parameters); } return(result); }
public void CreateObject() { object obj = new object(); Surrogate surrogate = new Surrogate(obj); ImportContext context = new ImportContext(); ObjectConstructionResult result = surrogate.CreateObject(context); Assert.AreSame(obj, result.Object); JsonReader tail = result.TailReader; tail.ReadToken(JsonTokenClass.Object); tail.ReadToken(JsonTokenClass.EndObject); }
public TestMessageFormatter() : base( new SerializerOptions( versionTolerance: false, preserveObjectReferences: true, surrogates: new[] { Surrogate.Create <ITestMessage, TestMessageSurrogate>(TestMessageSurrogate.ToSurrogate, TestMessageSurrogate.FromSurrogate), } )) { }
public void CreateSequenceFile(string name) { using (System.IO.StreamWriter sf = System.IO.File.CreateText(name)) { sf.WriteLine("*sequence*"); for (int i = 0; i < nodes.Length; i++) { sf.WriteLine(Surrogate.NetworkPathForHost( nodes[i].Host.Split(';')[0]) + @"\" + nodes[i].Name); } } }
public void ImportNonObjectMember() { var surrogate = new Surrogate(new object()); var context = new ImportContext(); surrogate.Import(context, "foo", JsonText.CreateReader("bar")); var tail = surrogate.CreateObject(context).TailReader; tail.ReadToken(JsonTokenClass.Object); Assert.AreEqual("foo", tail.ReadMember()); Assert.AreEqual("bar", tail.ReadString()); tail.ReadToken(JsonTokenClass.EndObject); }
public void CreateObject() { var obj = new object(); var surrogate = new Surrogate(obj); var context = new ImportContext(); var result = surrogate.CreateObject(context); Assert.AreSame(obj, result.Object); var tail = result.TailReader; tail.ReadToken(JsonTokenClass.Object); tail.ReadToken(JsonTokenClass.EndObject); }
internal static void _KillMemCache_mt(List <dfs.DfsFile> delfiles, bool verbose) { dfs dc = LoadDfsConfig(); string[] slaves = dc.Slaves.SlaveList.Split(';'); foreach (dfs.DfsFile df in delfiles) { try { // Unpin shared memory segments on all machines. _MemCacheRelease(df, true); // force=true } catch (System.Threading.ThreadAbortException) { } catch (Exception e) { if (verbose) { string msg = e.Message; if (-1 == msg.IndexOf("MemCacheWarning")) { Console.WriteLine("Warning: {0}", msg); } } } foreach (string slave in slaves) { try { string mdfp = Surrogate.NetworkPathForHost(slave) + @"\" + df.MemCache.MetaFileName; System.IO.File.Delete(mdfp); } catch { } } } _KillDataFileChunks_unlocked_mt(delfiles, false); if (verbose) { foreach (dfs.DfsFile df in delfiles) { Console.WriteLine("Successfully deleted MemCache '{0}' ({1} parts)", df.Name, df.Nodes.Count); } } }
System.IO.Stream _OpenStream(dfs.DfsFile.FileNode node) { string[] nodehosts = node.Host.Split(';'); string[] fullnames = new string[nodehosts.Length]; int ReplicateCurrentIndex = ReplicateStartIndex; for (int i = 0; i < fullnames.Length; i++) { fullnames[i] = Surrogate.NetworkPathForHost( nodehosts[ReplicateCurrentIndex % nodehosts.Length]) + @"\" + node.Name; ReplicateCurrentIndex++; } return(new MySpace.DataMining.AELight.DfsFileNodeStream(fullnames, true, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.Read, 0x400 * 4)); }
public ClunkerApp(ResourceLoader resourceLoader, Scene initialScene) { Resources = resourceLoader; Serializer = new Serializer(new SerializerOptions(true, true, new[] { Surrogate.Create <Resource <Image <Rgba32> >, ResourceSurrogate <Image <Rgba32> > >(r => new ResourceSurrogate <Image <Rgba32> >() { Id = r.Id }, s => resourceLoader.LoadImage(s.Id)) })); NextScene = initialScene; _renderers = new List <IRenderer>(); WorkQueue = new RoundRobinWorkQueue(new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue(), new ThreadedWorkQueue()); BestEffortFrameQueue = new DrivenWorkQueue(); }
static void EnsureReplication(string dfsxmlpath, int replicationfactor) { bool toomany = false; Console.WriteLine("Ensure data is replicated..."); { dfs dc = dfs.ReadDfsConfig_unlocked(dfsxmlpath); foreach (dfs.DfsFile df in dc.Files) { if (0 == string.Compare(DfsFileTypes.NORMAL, df.Type, StringComparison.OrdinalIgnoreCase) || 0 == string.Compare(DfsFileTypes.BINARY_RECT, df.Type, StringComparison.OrdinalIgnoreCase)) { foreach (dfs.DfsFile.FileNode fn in df.Nodes) { string[] nhosts = fn.Host.Split(';', ','); if (nhosts.Length < replicationfactor) { throw new Exception("dfs://" + df.Name + " node " + fn.Name + " does not live on " + replicationfactor.ToString() + " machines"); } else if (nhosts.Length > replicationfactor) { if (!toomany) { toomany = true; Console.Error.WriteLine("Warning: too many replicates for one or more DFS file chunks"); } } for (int ni = 0; ni < nhosts.Length; ni++) { string np = Surrogate.NetworkPathForHost(nhosts[ni]) + @"\" + fn.Name; if (!System.IO.File.Exists(np)) { throw new Exception("dfs://" + df.Name + " node " + fn.Name + " does not actually live on host " + nhosts[ni] + " as indicated by meta-data [" + np + "]"); } if (df.HasZsa) { if (!System.IO.File.Exists(np + ".zsa")) { throw new Exception("Sample data for dfs://" + df.Name + " node " + fn.Name + " (" + fn.Name + ".zsa) does not actually live on host " + nhosts[ni] + " as indicated by meta-data [" + np + ".zsa]"); } } } } } } } }
public DfsStream(string dfsfile, bool PreserveOrder, bool MachineLock) { if (MachineLock) { this.Mutex = new System.Threading.Mutex(false, "DfsStream{24A86864-EED6-4680-AB0E-3BDE97262339}"); this.Mutex.WaitOne(); } ReplicateStartIndex = StaticGlobals.Qizmt_BlockID; surrogatedir = Surrogate.NetworkPathForHost(Surrogate.MasterHost); dfs dc = dfs.ReadDfsConfig_unlocked(surrogatedir + @"\" + dfs.DFSXMLNAME); this.RetryTimeout = dc.slave.CookTimeout; this.RetryCount = dc.slave.CookRetries; dfs.DfsFile df = dc.FindAny(dfsfile); if (null == df) { throw new System.IO.FileNotFoundException("DFS file '" + dfsfile + "' not found", dfsfile); } if (0 != string.Compare(DfsFileTypes.NORMAL, df.Type, StringComparison.OrdinalIgnoreCase) && 0 != string.Compare(DfsFileTypes.BINARY_RECT, df.Type, StringComparison.OrdinalIgnoreCase)) { throw new InvalidOperationException("DFS file '" + df.Name + "' cannot be opened because file is of type " + df.Type); } this.reclen = df.RecordLength; nodes = df.Nodes.ToArray(); if (!PreserveOrder) { Random rnd = new Random(unchecked ( System.Threading.Thread.CurrentThread.ManagedThreadId + DateTime.Now.Millisecond * 351 + ReplicateStartIndex + nodes.Length * 6131)); for (int i = 0; i < nodes.Length; i++) { int ridx = rnd.Next(0, nodes.Length); dfs.DfsFile.FileNode tmpnode = nodes[i]; nodes[i] = nodes[ridx]; nodes[ridx] = tmpnode; } } }
/// <summary> /// Initializes a new instance of the <see cref="WireSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> public WireSerializer(ExtendedActorSystem system) : base(system) { var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); _serializer = new Hyperion.Serializer(new SerializerOptions( preserveObjectReferences: true, versionTolerance: true, surrogates: new[] { akkaSurrogate })); }
/// <summary> /// Initializes a new instance of the <see cref="HyperionSerializer"/> class. /// </summary> /// <param name="system">The actor system to associate with this serializer.</param> /// <param name="settings">Serializer settings.</param> public HyperionSerializer(ExtendedActorSystem system, HyperionSerializerSettings settings) : base(system) { this.Settings = settings; var akkaSurrogate = Surrogate .Create <ISurrogated, ISurrogate>( from => from.ToSurrogate(system), to => to.FromSurrogate(system)); var provider = CreateKnownTypesProvider(system, settings.KnownTypesProvider); _serializer = new Hyperion.Serializer(new SerializerOptions( preserveObjectReferences: settings.PreserveObjectReferences, versionTolerance: settings.VersionTolerance, surrogates: new[] { akkaSurrogate }, knownTypes: provider.GetKnownTypes())); }
public void CannotImportNonObjectMemberWithNullContext() { Surrogate surrogate = new Surrogate(new object()); surrogate.Import(null, "foo", StockJsonBuffers.EmptyObject.CreateReader()); }
public void CannotImportNonObjectMemberWithNullReader() { Surrogate surrogate = new Surrogate(new object()); surrogate.Import(new ImportContext(), "foo", null); }
public void ImportNonObjectMember() { Surrogate surrogate = new Surrogate(new object()); ImportContext context = new ImportContext(); surrogate.Import(context, "foo", JsonText.CreateReader("bar")); JsonReader tail = surrogate.CreateObject(context).TailReader; tail.ReadToken(JsonTokenClass.Object); Assert.AreEqual("foo", tail.ReadMember()); Assert.AreEqual("bar", tail.ReadString()); tail.ReadToken(JsonTokenClass.EndObject); }