public virtual CodeTypeDeclaration Serialize (IDesignerSerializationManager manager, object root, ICollection members)
{
if (root == null)
throw new ArgumentNullException ("root");
if (manager == null)
throw new ArgumentNullException ("manager");
RootContext rootContext = new RootContext (new CodeThisReferenceExpression (), root);
StatementContext statementContext = new StatementContext ();
if (members != null)
statementContext.StatementCollection.Populate (members);
statementContext.StatementCollection.Populate (root);
CodeTypeDeclaration declaration = new CodeTypeDeclaration (manager.GetName (root));
manager.Context.Push (rootContext);
manager.Context.Push (statementContext);
manager.Context.Push (declaration);
if (members != null) {
foreach (object member in members)
base.SerializeToExpression (manager, member);
}
base.SerializeToExpression (manager, root);
manager.Context.Pop ();
manager.Context.Pop ();
manager.Context.Pop ();
return declaration;
}
public static Context Init(params Context[] contexts)
{
RootContext rootContext = new RootContext();
rootContext.MapBindings();
foreach(Context context in contexts)
{
rootContext.AddContext(context);
}
rootContext.InstantiateBindings();
return rootContext;
}
private static async Task Main(string[] args)
{
var context = new RootContext(new ActorSystem());
var props = Props.FromFunc(ctx => {
if (ctx.Message is string)
{
ctx.Respond("hey");
}
return(Task.CompletedTask);
}
);
var pid = context.Spawn(props);
var reply = await context.RequestAsync <object>(pid, "hello");
Console.WriteLine(reply);
Console.ReadLine();
}
public RootViewModel(IEventAggregator events, INavigator navigator, ITheaterApplicationHost appHost, IServerConnectionManager serverManager, RootContext rootContext)
{
_navigator = navigator;
_serverManager = serverManager;
_rootContext = rootContext;
Notifications = new NotificationTrayViewModel(events);
Commands = new CommandBarViewModel(appHost, navigator);
Clock = new ClockViewModel();
IsInFocus = true;
events.Get<ShowPageEvent>().Subscribe(message => ActivePage = message.ViewModel);
events.Get<PlaybackStopEventArgs>().Subscribe(message => IsInternalMediaPlaying = false);
events.Get<PlaybackStartEventArgs>().Subscribe(message => {
if (message.Player is IInternalMediaPlayer && message.Player is IVideoPlayer && message.Options.Items[0].IsVideo) {
IsInternalMediaPlaying = true;
}
});
}
private static void TestConsistentHashGroup()
{
var context = new RootContext();
var props = Router.NewConsistentHashGroup(
context.Spawn(MyActorProps),
context.Spawn(MyActorProps),
context.Spawn(MyActorProps),
context.Spawn(MyActorProps)
);
var pid = context.Spawn(props);
for (var i = 0; i < 10; i++)
{
context.Send(pid, new Message {
Text = $"{i % 4}"
});
}
}
static async Task Main(string[] args)
{
var log = LoggerFactory.Create(x => x.AddConsole().SetMinimumLevel(LogLevel.Debug));
Log.SetLoggerFactory(log);
Console.WriteLine("Starting Node2");
var system = new ActorSystem();
var serialization = new Serialization();
var context = new RootContext(system);
serialization.RegisterFileDescriptor(ProtosReflection.Descriptor);
var Cluster = new Cluster(system, serialization);
var props = Props.FromFunc(
ctx =>
{
switch (ctx.Message)
{
case HelloRequest _:
ctx.Respond(new HelloResponse {
Message = "Hello from node 2"
});
break;
}
return(Actor.Done);
}
);
var parsedArgs = ParseArgs(args);
Cluster.Remote.RegisterKnownKind("HelloKind", props);
// CONSUL
await Cluster.StartMemberAsync(
"MyCluster", "node2", 12000, new ConsulProvider(new ConsulProviderOptions(), c => c.Address = new Uri("http://consul:8500/"))
);
await Task.Delay(-1);
Console.WriteLine("Shutting Down...");
await Cluster.ShutdownAsync();
}
private static void Main(string[] args)
{
var childProps = Props.FromFunc(context => {
Console.WriteLine($"{context.Self.Id}: MSG: {context.Message.GetType()}");
switch (context.Message)
{
case Started _:
throw new Exception("child failure");
}
return(Task.CompletedTask);
}
);
var rootProps = Props.FromFunc(context => {
Console.WriteLine($"{context.Self.Id}: MSG: {context.Message.GetType()}");
switch (context.Message)
{
case Started _:
context.SpawnNamed(childProps, "child");
break;
case Terminated terminated:
Console.WriteLine($"Terminated {terminated.Who}");
break;
}
return(Task.CompletedTask);
}
)
.WithChildSupervisorStrategy(new OneForOneStrategy((pid, reason) => SupervisorDirective.Escalate, 0,
null
)
);
var rootContext = new RootContext(new ActorSystem());
rootContext.SpawnNamed(rootProps, "root");
Console.ReadLine();
}
public void TestMethodOnObjectPostHookCallback()
{
var tc = new testClass();
var ctx = new RootContext();
int count = 0;
ctx.ExecutionContext.AddPostCallHook("CallNoArgs", "test", (obj, result) =>
{
count++;
Assert.AreEqual(tc, obj, "object that is passed in as central object");
Assert.AreEqual(5, result, "Result not passed correctly");
return(result);
});
ctx.SetVariableValue("p", tc);
var mc = new MethodCallExpression(new VariableValue("p"), new FunctionExpression("CallNoArgs", new IExpression[] { }));
var r = mc.Evaluate(ctx);
Assert.AreEqual(1, count, "# of times the callback was called");
}
private static void TestBroadcastGroup()
{
var system = new ActorSystem();
var context = new RootContext(system);
var props = context.NewBroadcastGroup(
context.Spawn(MyActorProps),
context.Spawn(MyActorProps),
context.Spawn(MyActorProps),
context.Spawn(MyActorProps)
);
for (var i = 0; i < 10; i++)
{
var pid = context.Spawn(props);
context.Send(pid, new Message {
Text = $"{i % 4}"
});
}
}
public void ScriptFileSameWhenRunning()
{
if (Directory.Exists("ScriptFileSameWhenRunning"))
{
Directory.Delete("ScriptFileSameWhenRunning", true);
}
var dirinfo = Directory.CreateDirectory("ScriptFileSameWhenRunning");
File.Copy("LoadFileWithSideEffects.plotlingo", @"ScriptFileSameWhenRunning\effects.plotlingo");
var f = new FunctionExpression("include", new IExpression[] { new StringValue("effects.plotlingo") });
var c = new RootContext();
c.ExecutionContext.ScriptFileContextPush(new FileInfo(string.Format(@"{0}\bogus.plotlingo", dirinfo.FullName)));
var r = f.Evaluate(c);
Assert.AreEqual("bogus.plotlingo", c.ExecutionContext.CurrentScriptFile.Name, "Current script filename");
}
public void LoadFromMainScriptDirectory()
{
if (Directory.Exists("LoadFromMainScriptDirectory"))
{
Directory.Delete("LoadFromMainScriptDirectory", true);
}
var dirinfo = Directory.CreateDirectory("LoadFromMainScriptDirectory");
File.Copy("LoadFileWithSideEffects.plotlingo", @"LoadFromMainScriptDirectory\effects.plotlingo");
var f = new FunctionExpression("include", new IExpression[] { new StringValue("effects.plotlingo") });
var c = new RootContext();
c.ExecutionContext.ScriptFileContextPush(new FileInfo(string.Format(@"{0}\bogus.plotlingo", dirinfo.FullName)));
var r = f.Evaluate(c);
Assert.AreEqual(5, c.GetVariableValue("i"), "variable i");
}
public void TestAddGoodMatchingMatricies()
{
var d1 = new Dictionary <object, object>();
d1["hi"] = 10;
var d2 = new Dictionary <object, object>();
d2["hi"] = 7;
var cl = new FunctionExpression("+", new ObjectValue(d1), new ObjectValue(d2));
var c = new RootContext();
var r = cl.Evaluate(c);
Assert.IsInstanceOfType(r, typeof(Dictionary <object, object>), "type of result");
var rut = r as Dictionary <object, object>;
Assert.AreEqual(1, rut.Count, "# of items");
Assert.AreEqual(17, rut["hi"], "value of hi");
}
public void DictForVarSet2Values()
{
var loop1 = new Dictionary <object, object>()
{
{ "a", 10 },
{ "b", 5 }
};
var loopdict = new ObjectValue(new Dictionary <object, object>[] { loop1 });
var statement1 = new ExpressionStatement(new FunctionExpression("+", new VariableValue("a"), new VariableValue("b")));
var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 });
var forLoop = new FunctionExpression("for", loopdict, exprStatement);
var c = new RootContext();
var r = forLoop.Evaluate(c);
Assert.AreEqual(15, r, "for loop with nothing in it");
}
public void StringWithDictReference()
{
var allvals = new Tuple <IExpression, IExpression>[] {
new Tuple <IExpression, IExpression>(new StringValue("hi"), new StringValue("there")),
new Tuple <IExpression, IExpression>(new StringValue("no"), new StringValue("way")),
};
var d = new Dictionary <object, object>();
d["hi"] = "there";
d["no"] = "way";
var c = new RootContext();
//c.SetVariableValue("dict", new DictionaryValue(allvals));
c.SetVariableValue("dict", d);
var s = new StringValue("hi {dict[\"hi\"]} on my {dict[\"no\"]}.");
var mys = s.Evaluate(c);
Assert.AreEqual("hi there on my way.", mys);
}
public void TestDivideByDisjointMatrixDenom()
{
var d1 = new Dictionary <object, object>();
d1["hi"] = 5.0;
var d2 = new Dictionary <object, object>();
d2["hi"] = 5.0;
d2["there"] = 10.0;
var cl = new FunctionExpression("/", new ObjectValue(d1), new ObjectValue(d2));
var c = new RootContext();
var rut = cl.Evaluate(c);
Assert.IsNotNull(rut, "Result null");
Assert.IsInstanceOfType(rut, typeof(Dictionary <object, object>), "Type of result");
var r = rut as Dictionary <object, object>;
Assert.AreEqual(1.0, r["hi"], "Resulting value");
}
static void Main(string[] args)
{
var context = new RootContext();
//Registering "knownTypes" is not required, but improves performance as those messages
//do not need to pass any typename manifest
var wire = new WireSerializer(new [] { typeof(Ping), typeof(Pong), typeof(StartRemote), typeof(Start) });
Serialization.RegisterSerializer(wire, true);
Remote.Start("127.0.0.1", 12001);
var messageCount = 1000000;
var wg = new AutoResetEvent(false);
var props = Props.FromProducer(() => new LocalActor(0, messageCount, wg));
var pid = context.Spawn(props);
var remote = new PID("127.0.0.1:12000", "remote");
context.RequestAsync <Start>(remote, new StartRemote {
Sender = pid
}).Wait();
var start = DateTime.Now;
Console.WriteLine("Starting to send");
var msg = new Ping();
for (var i = 0; i < messageCount; i++)
{
context.Send(remote, msg);
}
wg.WaitOne();
var elapsed = DateTime.Now - start;
Console.WriteLine("Elapsed {0}", elapsed);
var t = messageCount * 2.0 / elapsed.TotalMilliseconds * 1000;
Console.WriteLine("Throughput {0} msg / sec", t);
Console.ReadLine();
}
public async Task Root_method_call_fails()
{
// arrange
var options = SqliteInMemory.CreateOptions <RootContext>();
using (var context = new RootContext(options))
{
context.Database.EnsureCreated();
var utData = context.SetupSingleDtoAndEntities <SetItemDto>();
var service = new CrudServicesAsync(context, utData.ConfigAndMapper);
// act
var dto = new SetItemDto
{
Id = 1,
Item = "A item!"
};
await service.UpdateAndSaveAsync(dto);
}
}
public void TestSumSevenObj()
{
var d = new Dictionary <object, object>();
d["hi"] = 10;
d[5] = 20;
d["there"] = 5;
d["also"] = 1;
d["noway"] = 2;
d["stuff"] = 4;
d["ops"] = 5;
var fo = new MethodCallExpression(new PlotLingoLib.Expressions.Values.VariableValue("p"),
new FunctionExpression("sum", new IExpression[0]));
var c = new RootContext();
c.SetVariableValue("p", d);
var v = fo.Evaluate(c);
Assert.AreEqual(47, v, "Value");
}
public void DictForDefineLocally()
{
var loop1 = new Dictionary <object, object>()
{
{ "a", 10 }
};
var loopdict = new ObjectValue(new Dictionary <object, object>[] { loop1 });
var statement1 = new ExpressionStatement(new IntegerValue(5));
var exprStatement = new ListOfStatementsExpression(new IStatement[] { statement1 });
var forLoop = new FunctionExpression("for", loopdict, exprStatement);
var c = new RootContext();
c.SetVariableValue("a", 20);
var r = forLoop.Evaluate(c);
Assert.AreEqual(20, c.GetVariableValue("a"), "for loop with nothing in it");
}
public void TestPostMethodHookCallInExtensionMethod()
{
var ctx = new RootContext();
var tc = new testClass();
ctx.SetVariableValue("p", tc);
int count = 0;
ctx.ExecutionContext.AddPostCallHook("CallOneStringArgExt", "test", (obj, result) =>
{
count++;
Assert.AreEqual(tc, obj, "Object that is getting the callb ack");
Assert.AreEqual(4, result, "Result of callback");
return(result);
});
var s = new StringValue("hi");
var mc = new MethodCallExpression(new VariableValue("p"), new FunctionExpression("CallOneStringArgExt", new IExpression[] { s }));
var r = mc.Evaluate(ctx);
Assert.AreEqual(1, count, "# of times the hook got called");
}
// Use this for initialization
protected override void Start()
{
base.Start();
foreach (UnitRank rank in Enum.GetValues(typeof(UnitRank)))
{
if (!rank.Equals(UnitRank.Unknown))
{
GameObject item = Instantiate(MenuItem);
UnitMenuItem itemScript = item.GetComponent <UnitMenuItem>();
if (itemScript != null)
{
RootContext.Inject(itemScript);
itemScript.SetRank(rank);
}
item.transform.SetParent(ContentPanel);
}
}
EventManager.AddListener <GameModeChangedEvent>(HandleGameModeChanged);
}
public async Task Start()
{
var rootContext = new RootContext(interfaceChains);
await routingProtocol.Start(new RouterMetadata(name, interfaces.Keys.ToList())).ConfigureAwait(false);
foreach (var iface in interfaces.Values)
{
await iface.Initialize(interfaceChains, rootContext).ConfigureAwait(false);
}
//Start modules in order
foreach (var module in modules)
{
log.Debug($"Starting module {module}");
await module.Start(rootContext, extensibilitySettings).ConfigureAwait(false);
log.Debug($"Started module {module}");
}
await Task.WhenAll(interfaces.Values.Select(p => p.StartReceiving())).ConfigureAwait(false);
}
static async Task Main(string[] args)
{
var log = LoggerFactory.Create(x => x.AddConsole().SetMinimumLevel(LogLevel.Debug));
Log.SetLoggerFactory(log);
Console.WriteLine("Starting Node1");
var system = new ActorSystem();
var serialization = new Serialization();
var context = new RootContext(system);
serialization.RegisterFileDescriptor(ProtosReflection.Descriptor);
var cluster = new Cluster(system, serialization);
var parsedArgs = ParseArgs(args);
// SINGLE REMOTE INSTANCE
// Cluster.Start("MyCluster", parsedArgs.ServerName, 12001, new SingleRemoteInstanceProvider("localhost", 12000));
// CONSUL
await cluster.StartMemberAsync(
"MyCluster", "node1", 12001, new ConsulProvider(new ConsulProviderOptions(), c => c.Address = new Uri("http://consul:8500/"))
);
var i = 10000;
while (i-- > 0)
{
var res = await cluster.RequestAsync <HelloResponse>("TheName", "HelloKind", new HelloRequest(), CancellationToken.None);
Console.WriteLine(res.Message);
await Task.Delay(500);
}
await Task.Delay(-1);
Console.WriteLine("Shutting Down...");
await cluster.ShutdownAsync();
}
public void DictForOneResultArrayList()
{
var loopList = new object[] { 1, 2 };
var statement1 = new ExpressionStatement(new VariableValue("a"));
var exprStatement = new ObjectValue(new ListOfStatementsExpression(new IStatement[] { statement1 }));
var forLoop = new FunctionExpression("map", new VariableValue("a"), new ObjectValue(loopList), exprStatement);
var c = new RootContext();
var r = forLoop.Evaluate(c);
Assert.IsNotNull(r, "for loop with nothing in it");
var lst = r as IEnumerable <object>;
Assert.IsNotNull(lst, "results isn't in good form!");
var list = lst.ToArray();
Assert.AreEqual(2, list.Count());
Assert.AreEqual(1, list[0]);
Assert.AreEqual(2, list[1]);
}
public RootContext root()
{
RootContext _localctx = new RootContext(_ctx, State);
EnterRule(_localctx, 0, RULE_root);
try {
EnterOuterAlt(_localctx, 1);
{
State = 14; expression(0);
State = 15; Match(Eof);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public async Task Initialize()
{
if (initialized)
{
throw new Exception("The router has already been initialized.");
}
rootContext = new RootContext(interfaceChains, name);
await routingProtocol.Start(new RouterMetadata(name, interfaces.Select(i => i.Name).ToList())).ConfigureAwait(false);
foreach (var iface in sendOnlyInterfaces)
{
await iface.Initialize(interfaceChains).ConfigureAwait(false);
}
foreach (var iface in interfaces)
{
await iface.Initialize(interfaceChains, rootContext).ConfigureAwait(false);
}
initialized = true;
}
public async Task Start(RootContext rootContext, SettingsHolder extensibilitySettings)
{
if (settings.Uninstall)
{
foreach (var link in settings.Links)
{
using (var conn = link.Value.ConnectionFactory())
{
await conn.OpenAsync().ConfigureAwait(false);
using (var trans = conn.BeginTransaction())
{
await outboxInstaller.Uninstall(link.Key, conn, trans).ConfigureAwait(false);
await inboxInstaller.Uninstall(link.Key, conn, trans).ConfigureAwait(false);
trans.Commit();
}
}
}
}
foreach (var link in settings.Links)
{
using (var conn = link.Value.ConnectionFactory())
{
await conn.OpenAsync().ConfigureAwait(false);
using (var trans = conn.BeginTransaction())
{
await outboxInstaller.Install(link.Key, conn, trans).ConfigureAwait(false);
await inboxInstaller.Install(link.Key, conn, trans).ConfigureAwait(false);
trans.Commit();
}
}
}
}
static void Main(string[] args)
{
var context = new RootContext();
Serialization.RegisterFileDescriptor(ProtosReflection.Descriptor);
Remote.Start("127.0.0.1", 12001);
var messageCount = 1000000;
var wg = new AutoResetEvent(false);
var props = Props.FromProducer(() => new LocalActor(0, messageCount, wg));
var pid = context.Spawn(props);
var remote = new PID("127.0.0.1:12000", "remote");
context.RequestAsync <Start>(remote, new StartRemote {
Sender = pid
}).Wait();
var start = DateTime.Now;
Console.WriteLine("Starting to send");
var msg = new Ping();
for (var i = 0; i < messageCount; i++)
{
context.Send(remote, msg);
}
wg.WaitOne();
var elapsed = DateTime.Now - start;
Console.WriteLine("Elapsed {0}", elapsed);
var t = messageCount * 2.0 / elapsed.TotalMilliseconds * 1000;
Console.WriteLine("Throughput {0} msg / sec", t);
Console.ReadLine();
}
public async Task Start(RootContext rootContext, SettingsHolder extensibilitySettings)
{
tokenSource = new CancellationTokenSource();
foreach (var persister in persisters)
{
async Task Dispatch(OutgoingMessage operation)
{
var destinationEndpoint = persister.Key;
var iface = destinationToInterfaceMap[destinationEndpoint];
var chains = rootContext.Interfaces.GetChainsFor(iface);
var chain = chains.Get <AnycastContext>();
var dispatchContext = new OutboxDispatchContext(rootContext, iface);
var forwardContext = new AnycastContext(destinationEndpoint, operation, DistributionStrategyScope.Send, dispatchContext);
dispatchContext.Set(new TransportTransaction());
await chain.Invoke(forwardContext).ConfigureAwait(false);
}
await persister.Value.Start(tokenSource.Token, Dispatch);
}
}
/// <summary>
/// Saves the surface graph to bytes.
/// </summary>
/// <remarks>
/// The method calls the <see cref="ISurfaceContext.SurfaceData"/> setter to assign the result bytes. Sets null value if failed.
/// </remarks>
public void Save()
{
var wasEdited = IsEdited;
// Update the current context meta
_context.CachedSurfaceMeta.ViewCenterPosition = ViewCenterPosition;
_context.CachedSurfaceMeta.Scale = ViewScale;
// Save context (and every modified child context)
bool failed = RootContext.Save();
if (failed)
{
// Error
return;
}
// Clear flag
if (wasEdited)
{
Owner.OnSurfaceEditedChanged();
}
}
public void TestGeneration()
{
var k1 = new StringValue("1");
var k2 = new StringValue("2");
var v1 = new IntegerValue(1);
var v2 = new IntegerValue(2);
var allvals = new Tuple <IExpression, IExpression>[] {
new Tuple <IExpression, IExpression>(k1, v1),
new Tuple <IExpression, IExpression>(k2, v2),
};
var dv = new DictionaryValue(allvals);
var c = new RootContext();
var o = dv.Evaluate(c);
Assert.IsInstanceOfType(o, typeof(IDictionary <object, object>), "Dict type");
var od = o as IDictionary <object, object>;
Assert.AreEqual(1, od["1"], "value of 1");
Assert.AreEqual(2, od["2"], "value of 2");
}
public void DictForOneResult()
{
var loop1 = new Dictionary <object, object>()
{
{ "a", 10 }
};
var loopdict = new ObjectValue(new Dictionary <object, object>[] { loop1 });
var statement1 = new ExpressionStatement(new IntegerValue(5));
var exprStatement = new ObjectValue(new ListOfStatementsExpression(new IStatement[] { statement1 }));
var forLoop = new FunctionExpression("map", loopdict, exprStatement);
var c = new RootContext();
var r = forLoop.Evaluate(c);
Assert.IsNotNull(r, "for loop with nothing in it");
var lst = r as IEnumerable <object>;
Assert.IsNotNull(lst, "results isn't in good form!");
Assert.AreEqual(1, lst.Count());
Assert.AreEqual(5, lst.First());
}
public static async Task RunTest(Func <IMailbox> mailbox)
{
var context = new RootContext();
const int n = 10 * 1000;
var props = Props.FromFunc(c =>
{
switch (c.Message)
{
case string s:
c.Respond("done");
break;
}
return(Actor.Done);
})
.WithMailbox(mailbox);
var pid = context.Spawn(props);
for (var i = 1; i <= n; i++)
{
context.Send(pid, i);
}
await context.RequestAsync <string>(pid, "stop");
}
public RootContext () {
GuiContext = new GuiContext();
instance = this;
Turn = 1;
}
void Awake()
{
Context = new RootContext();
View.SetContext(Context);
}
public override object Serialize (IDesignerSerializationManager manager, object value)
{
if (manager == null)
throw new ArgumentNullException ("manager");
if (value == null)
throw new ArgumentNullException ("value");
if (_codeMap == null)
_codeMap = new CodeMap (value.GetType (), manager.GetName (value));
_codeMap.Clear ();
RootContext rootContext = new RootContext (new CodeThisReferenceExpression (), value);
manager.Context.Push (rootContext);
this.SerializeComponents (manager, ((IComponent) value).Site.Container.Components, (IComponent) value);
// Serialize root component
//
CodeStatementCollection statements = new CodeStatementCollection ();
statements.Add (new CodeCommentStatement (String.Empty));
statements.Add (new CodeCommentStatement (manager.GetName (value)));
statements.Add (new CodeCommentStatement (String.Empty));
// Note that during the serialization process below ComponentCodeDomSerializer
// will be invoked to serialize the rootcomponent during expression serialization.
// It will check for RootContext and return that.
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
_codeMap.AddInitStatements (statements);
manager.Context.Pop ();
return _codeMap.GenerateClass ();
}
public override object Serialize (IDesignerSerializationManager manager, object value)
{
if (manager == null)
throw new ArgumentNullException ("manager");
if (value == null)
throw new ArgumentNullException ("value");
// Add the provider to supply the ComponentCodeSerializer, Primitives..., etc
manager.AddSerializationProvider (_provider);
RootContext rootContext = new RootContext (new CodeThisReferenceExpression (), value);
manager.Context.Push (rootContext);
// Initialize code map
if (_codeMap != null)
_codeMap = new CodeMap (value.GetType (), manager.GetName (value));
_codeMap.Clear ();
CodeStatementCollection statements = null;
CodeDomSerializer serializer = null;
foreach (object component in ((IComponent) value).Site.Container.Components) {
if (!Object.ReferenceEquals (component, value)) {
serializer = base.GetSerializer (manager, component) as CodeDomSerializer; // ComponentCodeDomSerializer
if (serializer != null) {
// add an expressioncontext to inform the component that we want it fully serialized (it is in context)
ExpressionContext context = new ExpressionContext (null, null, null, component);
manager.Context.Push (context);
_codeMap.AddField (new CodeMemberField (value.GetType (), manager.GetName (value)));
statements = (CodeStatementCollection) serializer.Serialize (manager, component);
manager.Context.Pop ();
// XXX: what if there are more than one objects constructed by the serializer?
// this will only add the first one on the statements list.
CodeStatement ctorStatement = ExtractCtorStatement (statements);
if (ctorStatement != null)
_codeMap.AddPreInitStatement (ctorStatement);
_codeMap.AddInitStatements (statements);
}
}
}
// Serializer root component
//
statements = new CodeStatementCollection ();
base.SerializeProperties (manager, statements, value, new Attribute[0]);
base.SerializeEvents (manager, statements, value, new Attribute[0]);
_codeMap.AddInitStatements (statements);
manager.Context.Pop ();
return _codeMap.GenerateClass ();
}
// Use this for initialization
void Awake()
{
context = new RootContext(this);
}
