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