private void BuildParentEntityNodes()
{
NodeMap.Add("ContractType",
new EngineNodeHolder(EngineNode: null, EngineNodeOptions.CallbackValue, "Lease"));
NodeMap.Add("LegalEntity.Name",
new EngineNodeHolder(EngineNode: "_Customer"));
NodeMap.Add("Customer.Party.PartyName",
new EngineNodeHolder(EngineNode: "_ShipContact", EngineNodeOptions.LinePosition, "2"));
NodeMap.Add("Vendor.Party.PartyName",
new EngineNodeHolder(EngineNode: "_CompanyName1"));
NodeMap.Add("InvoiceNumber",
new EngineNodeHolder(EngineNode: "_DocumentRef"));
NodeMap.Add("Alias",
new EngineNodeHolder(EngineNode: "_CallRef"));
NodeMap.Add("InvoiceDate",
new EngineNodeHolder(EngineNode: "_Date", EngineNodeOptions.Date));
NodeMap.Add("DueDate",
new EngineNodeHolder(EngineNode: "_Date", EngineNodeOptions.Date));
NodeMap.Add("Currency.Name",
new EngineNodeHolder(EngineNode: null, EngineNodeOptions.CallbackValue, "ZAR"));
NodeMap.Add("ContractCurrency.Name",
new EngineNodeHolder(EngineNode: null, EngineNodeOptions.CallbackValue, "ZAR"));
NodeMap.Add("InvoiceTotal",
new EngineNodeHolder(EngineNode: "_Total", EngineNodeOptions.NodePosition, "10"));
NodeMap.Add("NumberOfAssets",
new EngineNodeHolder(EngineNode: "_LineItems", EngineNodeOptions.NodeCount));
NodeMap.Add("AllowCreateAssets",
new EngineNodeHolder(EngineNode: null, EngineNodeOptions.CallbackValue, "true"));
}
/// <summary>
/// Removes a node and all of its edges. If the node doesn't exist, nothing happens.
/// </summary>
/// <param name="node">node reference</param>
public virtual void RemoveNode(Node node)
{
if (node == null || !NodeMap.ContainsKey(node.Id))
{
return;
}
var delendi = new ArrayList();
foreach (Edge e in node.InEdges)
{
delendi.Add(e);
}
foreach (Edge e in node.OutEdges)
{
delendi.Add(e);
}
foreach (Edge e in node.SelfEdges)
{
delendi.Add(e);
}
foreach (Edge e in delendi)
{
RemoveEdge(e);
}
NodeMap.Remove(node.Id);
GeometryGraph.Nodes.Remove(node.GeometryObject as Core.Layout.Node);
}
public void DestroyBoard(bool playSound = true)
{
if (_gameBoard == null)
{
return;
}
// Destroy the lattice grid
_lattice.DestroyGrid();
// Destroy all objects in the game board
var i = 0;
foreach (var node in NodeMap.Values)
{
node.WaveOut(i++, NodeMap.Count, playSound: playSound);
}
foreach (var field in FieldMap.Fields)
{
field.Highlight(false);
}
foreach (Transform child in transform)
{
var node = child.gameObject.GetComponent <NodeView>();
var arc = child.gameObject.GetComponent <ArcView>();
var field = child.gameObject.GetComponent <FieldView>();
// Only destroy board pieces
if (node != null)
{
_itemPool.Release(node, 3f);
}
else if (arc != null)
{
_itemPool.Release(arc, 3f);
}
else if (field != null)
{
_itemPool.Release(field, 3f);
}
}
NodeMap.Clear();
ArcMap.Clear();
FieldMap.Clear();
_gameBoard = null;
if (!playSound)
{
return;
}
// TODO: make configurable
const float volume = 0.5f;
_gameAudio.Play(GameClip.GameEnd, volume: volume);
}
protected void ClearNodeCache(TreeNode node)
{
if (node == null)
{
return;
}
if (node.Tag is Guid)
{
Guid uid = (Guid)node.Tag;
if (NodeMap.ContainsKey(uid))
{
NodeMap[uid].Remove(node);
if (NodeMap[uid].Count == 0)
{
NodeMap.Remove(uid);
}
}
}
foreach (TreeNode subNode in node.Nodes)
{
ClearNodeCache(subNode);
}
}
private List <NodeMap> GetNextLayerNodes(List <NodeMap> prevLayerNodes, IReadOnlyList <IConnectionGene> innerConnections)
{
var connectionNodes = innerConnections
.Where(c =>
{
return(prevLayerNodes.FirstOrDefault(n => n.NeuronId == c.SourceNodeIdx) != null);
})
.Select(c => c)
.GroupBy(c => c.TargetNodeIdx)
.ToList();
List <NodeMap> nextNodeLayer = new List <NodeMap>(connectionNodes.Count);
foreach (var connectionNode in connectionNodes)
{
var netMapNode = _netMap.Keys.FirstOrDefault(n => n.NeuronId == connectionNode.Key);
if (netMapNode == null)
{
var nodeMap = new NodeMap(_nextNetNodeId, connectionNode.Key);
_netMap.Add(nodeMap, new List <INetConnection>());
nextNodeLayer.Add(nodeMap);
_nextNetNodeId++;
}
}
return(nextNodeLayer);
}
public void Test19_1_ポインタの加算と減算()
{
// TODO: 現状は全ての変数をスタックに 8byte ずつ積んでいるので成立する
var src = @"
int main() {
int a;
int b;
int c;
int d;
d = 1;
c = 2;
b = 4;
a = 8;
int *p;
int *q;
p = &d;
q = p + 3;
return *q;
}
";
var tokenList = TokenList.Tokenize(src);
var nodeMap = NodeMap.Create(tokenList);
Assert.IsTrue(ValidateNodeValuesAndOffsets(nodeMap));
Assert.AreEqual(8, CopmlileAndExecOnWsl(src));
}
/// <summary>
/// 正面のノードを計算する
/// </summary>
/// <returns></returns>
public static string FrontNode(NodeMap nodeMap, string current, string next)
{
var nodes = nodeMap.nodeMap;
// current node を除く
var n = nodes[next].Graph.Where(name => name != current).ToList();
if (n.Count > 0)
{
n.Sort((a, b) =>
{
var cpos = nodes[current].Position;
var npos = nodes[next].Position;
var apos = nodes[a].Position;
var bpos = nodes[b].Position;
var ad = Vector3.Dot((npos - cpos).normalized, (apos - npos).normalized);
var bd = Vector3.Dot((npos - cpos).normalized, (bpos - npos).normalized);
return(bd.CompareTo(ad));
});
return(n[0]);
}
else
{
return(current);
}
}
public void Test10_if文()
{
var src = @"
int main() {
if ( 1 )
return 2;
else
return 3;
}
";
var tokenList = TokenList.Tokenize(src);
var nodeMap = NodeMap.Create(tokenList);
Assert.IsTrue(ValidateNodeValuesAndOffsets(nodeMap));
var block = nodeMap.Head.Nodes.Item1;
Assert.AreEqual(1, block.Bodies.Count);
var n0 = block.Bodies[0];
Assert.AreEqual(NodeKind.If, n0.Kind);
Assert.AreEqual(1, n0.Condition.Value);
Assert.AreEqual(NodeKind.Return, n0.Nodes.Item1.Kind);
Assert.AreEqual(2, n0.Nodes.Item1.Nodes.Item1.Value);
Assert.AreEqual(NodeKind.Return, n0.Nodes.Item2.Kind);
Assert.AreEqual(3, n0.Nodes.Item2.Nodes.Item1.Value);
Assert.AreEqual(2, CopmlileAndExecOnWsl(src));
}
public void Test09_return文()
{
var src = @"
int main() {
int abc;
abc = 15;
return abc;
}
";
var tokenList = TokenList.Tokenize(src);
var nodeMap = NodeMap.Create(tokenList);
Assert.IsTrue(ValidateNodeValuesAndOffsets(nodeMap));
var block = nodeMap.Head.Nodes.Item1;
Assert.AreEqual(3, block.Bodies.Count);
var n0 = block.Bodies[1];
var n1 = block.Bodies[2];
Assert.AreEqual(NodeKind.Assign, n0.Kind);
Assert.AreEqual(8, n0.Nodes.Item1.Offset);
Assert.AreEqual(15, n0.Nodes.Item2.Value);
Assert.AreEqual(NodeKind.Return, n1.Kind);
Assert.AreEqual(8, n1.Nodes.Item1.Offset);
Assert.IsNull(n1.Nodes.Item2);
Assert.AreEqual(15, CopmlileAndExecOnWsl(src));
}
public void Test08_複数文字のローカル変数()
{
var src = @"
int main() {
int foo;
int bar;
foo = 1;
bar = 2 + 3;
foo + bar;
}
";
var tokenList = TokenList.Tokenize(src);
var nodeMap = NodeMap.Create(tokenList);
Assert.IsTrue(ValidateNodeValuesAndOffsets(nodeMap));
var block = nodeMap.Head.Nodes.Item1;
Assert.AreEqual(block.Bodies.Count, 5);
var n0 = block.Bodies[2];
var n1 = block.Bodies[3];
var n2 = block.Bodies[4];
Assert.AreEqual(8, n0.Nodes.Item1.Offset);
Assert.AreEqual(1, n0.Nodes.Item2.Value);
Assert.AreEqual(16, n1.Nodes.Item1.Offset);
Assert.AreEqual(NodeKind.Add, n1.Nodes.Item2.Kind);
Assert.AreEqual(2, n1.Nodes.Item2.Nodes.Item1.Value);
Assert.AreEqual(3, n1.Nodes.Item2.Nodes.Item2.Value);
Assert.AreEqual(NodeKind.Add, n2.Kind);
Assert.AreEqual(8, n2.Nodes.Item1.Offset);
Assert.AreEqual(16, n2.Nodes.Item2.Offset);
Assert.AreEqual(6, CopmlileAndExecOnWsl(src));
}
public void Solve()
{
NodeMap <Nodes> nodeMap = new NodeMap <Nodes>(mazeNodes, nodeConnections);
QueueSearcher queueSearcher = new QueueSearcher();
Nodes startingNode = null;
Nodes endingNode = null;
foreach (Nodes node in mazeNodes)
{
if (node.StartingPoint)
{
startingNode = node;
}
else if (node.FinishingPoint)
{
endingNode = node;
}
}
var shortestPath = queueSearcher.ShortestPath(nodeMap, startingNode);
string returnedString = string.Join(", ", shortestPath(endingNode));
if (returnedString != "")
{
Console.WriteLine("Maze Solution: {0}", returnedString);
}
else
{
Console.WriteLine("Maze cannot be solved");
}
}
public IActionResult Get(string id, string start, string end)
{
NodeMap item = null;
item = _context.MapsDB.FirstOrDefault(t => t.ID == id);
if (item == null)
{
return(NotFound("Map ID not found"));
}
bool validStart = item.allNodes.ContainsKey(start);
bool validEnd = item.allNodes.ContainsKey(end);
if (!validStart || !validEnd)
{
return(NotFound("Start or end ID not found!"));
}
Node testNode = item.allNodes[start];
Node testnode2 = item.allNodes["e"];
BestPathDirections returnObjectUnserialized =
item.getBestPath(item.allNodes[start], item.allNodes[end]);
string jsonTestSer = JsonConvert.SerializeObject(returnObjectUnserialized);
return(new ObjectResult(returnObjectUnserialized));
//now that we have the result...
}
public void CopyToModel(NodeMap nodeMap)
{
lock (_modelLock)
{
Model.CopyFrom(nodeMap);
}
}
private void Start()
{
//create map
map = new NodeMap();
map.defaultNodeGraphic = defaultSprite;
map.defaultUnpathableGraphic = unpathableSprite;
map.Initialize(WIDTH, HEIGHT, SIZE);
//set unpathable nodes
map.SetPathingAt(2, 1, false);
map.SetPathingAt(2, 2, false);
map.SetPathingAt(2, 3, false);
map.SetPathingAt(3, 3, false);
map.SetPathingAt(4, 3, false);
map.SetPathingAt(5, 3, false);
map.SetPathingAt(6, 3, false);
map.SetPathingAt(7, 3, false);
map.SetPathingAt(7, 2, false);
map.SetPathingAt(7, 1, false);
map.SetPathingAt(7, 0, false);
//create and place character
if (characterSprite)
{
character = new NodeOccupant();
character.graphic = (GameObject)Instantiate(characterSprite, new Vector3(0, 0, 0), Quaternion.identity);
map.SetNodeOccupantAt(1, 1, character);
}
map.Build();
map.OnNodeClicked += OnNodeClicked;
}
/// <summary>
/// This is used to serialize a representation of the object value
/// provided. If there is a <c>Registry</c> binding present
/// for the provided type then this will use the converter specified
/// to serialize a representation of the object. If however there
/// is no binding present then this will delegate to the internal
/// strategy. This returns true if the serialization has completed.
/// </summary>
/// <param name="type">
/// this is the type that represents the field or method
/// </param>
/// <param name="value">
/// this is the object instance to be serialized
/// </param>
/// <param name="node">
/// this is the XML element to be serialized to
/// </param>
/// <param name="map">
/// this is the session map used by the serializer
/// </param>
/// <returns>
/// this returns true if it was serialized, false otherwise
/// </returns>
public bool Write(Type type, Object value, NodeMap<OutputNode> node, Dictionary map) {
bool reference = strategy.Write(type, value, node, map);
if(!reference) {
return Write(type, value, node);
}
return reference;
}
public void Test07_1文字変数()
{
var src = @"
int main() {
int a;
int z;
a = 10;
z = 50;
a = z + a;
}
";
var tokenList = TokenList.Tokenize(src);
var nodeMap = NodeMap.Create(tokenList);
Assert.IsTrue(ValidateNodeValuesAndOffsets(nodeMap));
var block = nodeMap.Head.Nodes.Item1;
Assert.AreEqual(5, block.Bodies.Count);
var n0 = block.Bodies[2];
var n1 = block.Bodies[3];
var n2 = block.Bodies[4];
Assert.AreEqual(8, n0.Nodes.Item1.Offset);
Assert.AreEqual(10, n0.Nodes.Item2.Value);
Assert.AreEqual(16, n1.Nodes.Item1.Offset);
Assert.AreEqual(50, n1.Nodes.Item2.Value);
Assert.AreEqual(8, n2.Nodes.Item1.Offset);
Assert.AreEqual(NodeKind.Add, n2.Nodes.Item2.Kind);
Assert.AreEqual(16, n2.Nodes.Item2.Nodes.Item1.Offset);
Assert.AreEqual(8, n2.Nodes.Item2.Nodes.Item2.Offset);
Assert.AreEqual(60, CopmlileAndExecOnWsl(src));
}
private void Start()
{
// To "Bake" the node map to capture untraversable areas. Whill scan the each node on wallTileMap for untraversable tiles on nodeMap
nodeMap.BakeBlockedMap(wallTileMap);
// Baking traversable but not desirable areas with 1.5 cost
nodeMap.BakeCostMap(LayerMask.GetMask("Water"), 1.5f);
/*
* For 3D map baking
*
* Overloaded method, takes integer repersenting LayerMask id for *IGNORED* physics layer
*
* Scans each node with Physics.CheckSphere() for colliders around node, any collider detected not in above mentioned LayerMask will be consider an obstacle.
* Therefore, marking that node as untraversable.
*/
// nodeMap.BakeBlockedMap(LayerMask.GetMask("Ignore Raycast"));
// Save baked map as "MyNodeMap.bin" at ../UnityProjectFile/Assets/MyNodeMap.bin
nodeMap.Save("MyNodeMap");
// Load baked map from ../UnityProjectFile/Assets/MyNodeMap.bin
nodeMap = NodeMap.Load("MyNodeMap");
}
/// <summary>
/// This is used to read the <c>Value</c> which will be used
/// to represent the deserialized object. If there is an binding
/// present then the value will contain an object instance. If it
/// does not then it is up to the internal strategy to determine
/// what the returned value contains.
/// </summary>
/// <param name="type">
/// this is the type that represents a method or field
/// </param>
/// <param name="node">
/// this is the node representing the XML element
/// </param>
/// <param name="map">
/// this is the session map that contain variables
/// </param>
/// <returns>
/// the value representing the deserialized value
/// </returns>
public Value Read(Type type, NodeMap<InputNode> node, Dictionary map) {
Value value = strategy.Read(type, node, map);
if(IsReference(value)) {
return value;
}
return Read(type, node, value);
}
/// <summary>
/// Rebuilds the tree from scratch.
/// </summary>
public void RebuildTree()
{
// store old tree state
List <string> previouslyExpanded = ExpandedPaths;
Point scrollPos = Win32.Scrolling.GetScrollPos(this);
string currentPath = SelectedNode != null ? SelectedNode.BackingPath : null;
try
{
BeginUpdate();
BuildTree();
// BUG: avoid nodes expansion to generate redraws
EndUpdate();
BeginUpdate();
// restore tree state
ExpandedPaths = previouslyExpanded;
if (currentPath != null && NodeMap.ContainsKey(currentPath))
{
SelectedNode = NodeMap[currentPath];
}
else
{
SelectedNode = Nodes[0] as GenericNode;// projectNode;
}
}
finally
{
EndUpdate();
Win32.Scrolling.SetScrollPos(this, scrollPos);
}
}
private string SelectXmlNodes(string[] NodesToBeIterated)
{
StringBuilder sb = new StringBuilder();
foreach (var nodetobeiterated in NodesToBeIterated)
{
using (StringReader s = new StringReader(cleanEngineXmlString))
{
XDocument xdoc = XDocument.Load(s);
var childnodes = xdoc.Descendants(nodetobeiterated).ToArray();
foreach (var childnode in childnodes)
{
var child =
new XElement("PayableInvoiceAsset",
NodeMap.Where(keyvaluePair => !keyvaluePair.Value.IsParentAttribute &&
keyvaluePair.Value.engineNodeOptions != EngineNodeOptions.ChildEntityPointer)
.Select(keyvaluePair => new XElement(keyvaluePair.Key,
XmlHelperInstance.FetchValueFromNodeForChild(NodeMap.GetValueOrDefault(keyvaluePair.Key), childnode))
)
);
sb.Append(child.ConvertToString());
}
}
}
return(sb.ToString());
}
public async void WaitForActiveNodeMaps(NodeMap map)
{
await ToSignal(map, "finished");
activeNodeMaps[map] = false;
CheckActiveNodeMaps();
}
public Project(int width, int height, int frequency)
{
this.projectWidth = width;
this.projectHeight = height;
this.geoFrequency = frequency;
map = new NodeMap();
}
public HashSet <T> BFSearch <T>(NodeMap <T> nodeMap, T rootNode)
{
HashSet <T> visitedNodes = new HashSet <T>();
if (!nodeMap.ConnectingList.ContainsKey(rootNode))
{
return(visitedNodes);
}
Queue <T> queue = new Queue <T>();
queue.Enqueue(rootNode);
while (queue.Count > 0)
{
var nodeVertex = queue.Dequeue();
if (visitedNodes.Contains(nodeVertex))
{
continue;
}
visitedNodes.Add(nodeVertex);
foreach (T neighborNode in nodeMap.ConnectingList[nodeVertex])
{
if (!visitedNodes.Contains(neighborNode))
{
queue.Enqueue(neighborNode);
}
}
}
return(visitedNodes);
}
public SettingInfo(OryxSettingName settingName, NodeType nodeType, NodeMap nodeMap, string value)
{
_SettingName = settingName;
_NodeType = nodeType;
_NodeMap = nodeMap;
_Value = value;
}
public IActionResult Put(string id, [FromBody] string value)
{
if (value == null || !value.Contains("nodes"))
{
return(BadRequest());
}
IncomingNodeListJSON testing = JsonConvert.DeserializeObject <IncomingNodeListJSON>(value);
testing.ID = id;
NodeMap nodeMap = new NodeMap(id);
foreach (string name in testing.nodes.Keys)
{
Node n = new Node(name);
foreach (var pair in testing.nodes[name])
{
n.nodeDictionary.Add(pair.Key, pair.Value);
}
_context.MapsDB.Add(nodeMap);
_context.SaveChanges();
Console.WriteLine("PUT ID: {0}", id);
Console.WriteLine(testing);
return(Ok());
}
return(BadRequest());
}
public async void Intro()
{
Control root = GetNode("Intro") as Control;
root.SetVisible(true);
Tween tween = new Tween();
AddChild(tween);
/*
* Label label = root.GetNode("Title") as Label;
* await ToSignal(this, "next");
* label.SetVisible(true);
* tween = CommonTweenUtil.Fade(label, 0.3f, 0, 1, tween);
* tween.Start();
* await ToSignal(tween, "tween_completed");
*/
NodeMap maze = root.GetNode("NodeMap") as NodeMap;
// set maze size
maze.SetHeight(79);
maze.SetWidth(159);
maze.ResizeBlock();
//maze.animate = false;
await ToSignal(this, "next");
maze.SetVisible(true);
tween = CommonTweenUtil.Fade(maze, 0.3f, 0, 1, tween);
//tween = CommonTweenUtil.Scale(maze, new Vector2(0, 0), new Vector2(1, 1), 0.3f, tween);
tween.Start();
await ToSignal(tween, "tween_completed");
await ToSignal(this, "next");
maze.GenerateMap();
await ToSignal(maze, "finished");
maze.SetDst(159 * 2 - 2);
await ToSignal(this, "next");
maze.AStar();
await ToSignal(maze, "finished");
await ToSignal(this, "next");
tween.RemoveAll();
tween = CommonTweenUtil.Fade(root, 0.3f, 1, 0, tween);
tween.Start();
await ToSignal(tween, "tween_completed");
tween.QueueFree();
root.SetVisible(false);
EmitSignal("section_finished");
}
public AStar(Vector2Int _start, Vector2Int _end, NodeMap _map /*,PathFinder _finder*/)
{
start = _map.GetNodeByGridPos(_start.x, _start.y);
end = _map.GetNodeByGridPos(_end.x, _end.y);
now = start;
map = _map;
//finder = _finder;
}
public Signal(NodeMap<LocalNode> locals, NodeMap<RemoteNode> remotes)
{
this.Locals = locals;
this.Remotes = remotes;
this.Signature = "";
this.Funcs = new List<Function>();
this.Context = new SignalContext();
}
/// <summary>
/// This method will read with an internal strategy after it has
/// been intercepted by the visitor. Interception of the XML node
/// before it is delegated to the internal strategy allows the
/// visitor to change some attributes or details before the node
/// is interpreted by the strategy.
/// </summary>
/// <param name="type">
/// this is the type of the root element expected
/// </param>
/// <param name="node">
/// this is the node map used to resolve an override
/// </param>
/// <param name="map">
/// this is used to maintain contextual information
/// </param>
/// <returns>
/// the value that should be used to describe the instance
/// </returns>
public Value Read(Type type, NodeMap <InputNode> node, Dictionary map)
{
if (visitor != null)
{
visitor.Read(type, node);
}
return(strategy.Read(type, node, map));
}
public Project()
{
//Default values for project resoultion
this.projectWidth = 640;
this.projectHeight = 480;
this.geoFrequency = 4;
map = new NodeMap();
}
public void Setup()
{
nodeMap = new NodeMap();
string[] names = new string[] { "a", "b", "c", "d", "e", "f", "g", "h", "i" };
foreach (string name in names)
{
nodeMap.Nodes.Add(new Node
{
NodeName = name,
ConnectedNodes = new LinkedList <KeyValuePair <Node, int> >()
});
}
// A
nodeMap.Nodes[0].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "b"), 3));
nodeMap.Nodes[0].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "c"), 2));
nodeMap.Nodes[0].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "d"), 5));
// B
nodeMap.Nodes[1].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "a"), 3));
nodeMap.Nodes[1].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 8));
// C
nodeMap.Nodes[2].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "a"), 2));
nodeMap.Nodes[2].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 6));
// D
nodeMap.Nodes[3].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "a"), 5));
nodeMap.Nodes[3].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "h"), 4));
// E
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "b"), 8));
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "c"), 6));
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "f"), 1));
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "g"), 2));
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "h"), 5));
nodeMap.Nodes[4].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "i"), 7));
// F
nodeMap.Nodes[5].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 1));
nodeMap.Nodes[5].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "g"), 9));
// G
nodeMap.Nodes[6].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 2));
nodeMap.Nodes[6].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "h"), 8));
// H
nodeMap.Nodes[7].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "d"), 4));
nodeMap.Nodes[7].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 5));
nodeMap.Nodes[7].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "g"), 8));
nodeMap.Nodes[7].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "i"), 1));
// I
nodeMap.Nodes[8].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "e"), 7));
nodeMap.Nodes[8].ConnectedNodes.AddLast(new KeyValuePair <Node, int>(nodeMap.Nodes.Find(n => n.NodeName == "h"), 1));
dijkstra = new Dijkstra(nodeMap);
}
public Value Read(Type field, NodeMap node, Dictionary map) {
Node value = node.remove(ELEMENT_NAME);
if(value == null) {
return null;
}
String name = value.Value;
Class type = Class.forName(name);
return new SimpleType(type);
}
public ProxyPipe(NodeMap<LocalNode> locals, string uri)
{
Settings = new PipeSettings();
var u = new Uri(uri);
Settings.HostName = u.Host;
Settings.Port = u.Port;
Settings.BasePath = u.PathAndQuery;
Nodes = new JArray(locals.Nodes.Select(node => new JObject(new JProperty("name", node.Name), new JProperty("classes", node.Classes)))).ToString();
var listen = Task.Run(() => _listen());
}
public void TestIt()
{
List<object> results = new List<object>();
NodeMap<LocalNode> locals = new NodeMap<LocalNode>();
NodeMap<RemoteNode> remotes = new NodeMap<RemoteNode>();
var NodeA = new LocalNode("NodeA", new string[] { "Calculator", "Printer" });
locals.AddNode(NodeA);
NodeA["Add"] = new FuncEx((sig, args, cb) =>
{
cb(new JArray(args[0].Value<int>() + args[1].Value<int>()));
});
NodeA["Print"] = new FuncEx((sig, args, cb) =>
{
results.Add(args[0].Value<int>());
});
Signal s = new Signal(locals, remotes);
s.Load("NodeA.Calculator.Add(4,4)\n\t(res) => \n\t\tNodeA.Prinaster.Print(res)");
s.Start();
Assert.IsTrue(results.Count == 1 && (int)results[0] == 8);
}
/// <summary>
/// This method is used to read an object from the specified node.
/// In order to get the root type the field and node map are
/// specified. The field represents the annotated method or field
/// within the deserialized object. The node map is used to get
/// the attributes used to describe the objects identity, or in
/// the case of an existing object it contains an object reference.
/// </summary>
/// <param name="type">
/// the method or field in the deserialized object
/// </param>
/// <param name="node">
/// this is the XML element attributes to read
/// </param>
/// <param name="map">
/// this is the session map used for deserialization
/// </param>
/// <returns>
/// this returns an instance to insert into the object
/// </returns>
public Value Read(Type type, NodeMap node, Dictionary map) {
ReadGraph graph = read.Find(map);
if(graph != null) {
return graph.Read(type, node);
}
return null;
}
/// <summary>
/// This is used to recover the object references from the document
/// using the special attributes specified. This allows the element
/// specified by the <c>NodeMap</c> to be used to discover
/// exactly which node in the object graph the element represents.
/// </summary>
/// <param name="type">
/// the type of the field or method in the instance
/// </param>
/// <param name="real">
/// this is the overridden type from the XML element
/// </param>
/// <param name="node">
/// this is the XML element to be deserialized
/// </param>
/// <returns>
/// this is used to return the type to acquire the value
/// </returns>
public Value ReadInstance(Type type, Class real, NodeMap node) {
Node entry = node.remove(mark);
if(entry == null) {
return ReadReference(type, real, node);
}
String key = entry.getValue();
if(containsKey(key)) {
throw new CycleException("Element '%s' already exists", key);
}
return ReadValue(type, real, node, key);
}
public bool Write(Type field, Object value, NodeMap node, Dictionary map) {
if(field.Type != value.getClass()) {
node.put(ELEMENT_NAME, value.getClass().getName());
}
return false;
}
public void Read(Type type, NodeMap<InputNode> node) {
InputNode element = node.getNode();
if(element.isRoot()) {
Object source = element.getSource();
Class sourceType = source.getClass();
Class itemType = type.getType();
System.out.printf(">>>>> ELEMENT=[%s]%n>>>>> TYPE=[%s]%n>>>>> SOURCE=[%s]%n", element, itemType, sourceType);
}
}
public void Write(Type type, NodeMap<OutputNode> node) {
if(!node.getNode().isRoot()) {
Comment comment = type.getAnnotation(Comment.class);
/// <summary>
/// This is used to acquire the <c>Value</c> which can be used
/// to represent the deserialized value. The type create cab be
/// added to the graph of created instances if the XML element has
/// an identification attribute, this allows cycles to be completed.
/// </summary>
/// <param name="type">
/// the type of the field or method in the instance
/// </param>
/// <param name="real">
/// this is the overridden type from the XML element
/// </param>
/// <param name="node">
/// this is the XML element to be deserialized
/// </param>
/// <returns>
/// this is used to return the type to acquire the value
/// </returns>
public Value ReadValue(Type type, Class real, NodeMap node) {
Class expect = type.getType();
if(expect.isArray()) {
return ReadArray(type, real, node);
}
return new ObjectValue(real);
}
/// <summary>
/// This is used to acquire the <c>Value</c> which can be used
/// to represent the deserialized value. The type create cab be
/// added to the graph of created instances if the XML element has
/// an identification attribute, this allows cycles to be completed.
/// </summary>
/// <param name="type">
/// the type of the field or method in the instance
/// </param>
/// <param name="real">
/// this is the overridden type from the XML element
/// </param>
/// <param name="node">
/// this is the XML element to be deserialized
/// </param>
/// <param name="key">
/// the key the instance is known as in the graph
/// </param>
/// <returns>
/// this is used to return the type to acquire the value
/// </returns>
public Value ReadValue(Type type, Class real, NodeMap node, String key) {
Value value = ReadValue(type, real, node);
if(key != null) {
return new Allocate(value, this, key);
}
return value;
}
public PipeModelInfo(Knot knot, NodeMap nodeMap, Edge edge, Vector3 offset)
: base("pipe1")
{
Knot = knot;
NodeMap = nodeMap;
Edge = edge;
Node node1 = nodeMap.FromNode (edge);
Node node2 = nodeMap.ToNode (edge);
PositionFrom = node1.ToVector () + offset;
PositionTo = node2.ToVector () + offset;
Position = node1.CenterBetween (node2) + offset;
Direction = PositionTo - PositionFrom;
Direction.Normalize ();
Scale = Vector3.One * 10f;
// a pipe is movable
IsMovable = true;
}
/// <summary>
/// This is used to write the reference in to the XML element that
/// is to be written. This will either insert an object identity if
/// the object has not previously been written, or, if the object
/// has already been written in a previous element, this will write
/// the reference to that object. This allows all cycles within the
/// graph to be serialized so that they can be fully deserialized.
/// </summary>
/// <param name="type">
/// the type of the field or method in the object
/// </param>
/// <param name="value">
/// this is the actual object that is to be written
/// </param>
/// <param name="node">
/// this is the XML element attribute map to use
/// </param>
/// <param name="map">
/// this is the session map used for the serialization
/// </param>
/// <returns>
/// returns true if the object has been fully serialized
/// </returns>
public bool Write(Type type, Object value, NodeMap node, Dictionary map) {
WriteGraph graph = write.Find(map);
if(graph != null) {
return graph.Write(type, value, node);
}
return false;
}
public void Read(Type type, NodeMap<InputNode> node) {
/// <summary>
/// This is used to recover the object references from the document
/// using the special attributes specified. This allows the element
/// specified by the <c>NodeMap</c> to be used to discover
/// exactly which node in the object graph the element represents.
/// </summary>
/// <param name="type">
/// the type of the field or method in the instance
/// </param>
/// <param name="real">
/// this is the overridden type from the XML element
/// </param>
/// <param name="node">
/// this is the XML element to be deserialized
/// </param>
/// <returns>
/// this is used to return the type to acquire the value
/// </returns>
public Value ReadReference(Type type, Class real, NodeMap node) {
Node entry = node.remove(refer);
if(entry == null) {
return ReadValue(type, real, node);
}
String key = entry.getValue();
Object value = get(key);
if(!containsKey(key)) {
throw new CycleException("Invalid reference '%s' found", key);
}
return new Reference(value, real);
}
public void Write(Type type, NodeMap<OutputNode> node) {
if(!node.getNode().isRoot()) {
node.getNode().setComment(type.getType().getName());
}
}
/// <summary>
/// This method will write with an internal strategy before it has
/// been intercepted by the visitor. Interception of the XML node
/// before it is delegated to the internal strategy allows the
/// visitor to change some attributes or details before the node
/// is interpreted by the strategy.
/// </summary>
/// <param name="type">
/// this is the type of the root element expected
/// </param>
/// <param name="node">
/// this is the node map used to resolve an override
/// </param>
/// <param name="map">
/// this is used to maintain contextual information
/// </param>
/// <returns>
/// the value that should be used to describe the instance
/// </returns>
public bool Write(Type type, Object value, NodeMap<OutputNode> node, Dictionary map) {
bool result = strategy.Write(type, value, node, map);
if(visitor != null) {
visitor.Write(type, node);
}
return result;
}
public void Read(Type field, NodeMap<InputNode> node) {
String namespace = node.getNode().getReference();
/// <summary>
/// This method will read with an internal strategy after it has
/// been intercepted by the visitor. Interception of the XML node
/// before it is delegated to the internal strategy allows the
/// visitor to change some attributes or details before the node
/// is interpreted by the strategy.
/// </summary>
/// <param name="type">
/// this is the type of the root element expected
/// </param>
/// <param name="node">
/// this is the node map used to resolve an override
/// </param>
/// <param name="map">
/// this is used to maintain contextual information
/// </param>
/// <returns>
/// the value that should be used to describe the instance
/// </returns>
public Value Read(Type type, NodeMap<InputNode> node, Dictionary map) {
if(visitor != null) {
visitor.Read(type, node);
}
return strategy.Read(type, node, map);
}
/// <summary>
/// This is used to read the <c>Value</c> which will be used
/// to represent the deserialized object. If there is an annotation
/// present then the value will contain an object instance. If it
/// does not then it is up to the internal strategy to determine
/// what the returned value contains.
/// </summary>
/// <param name="type">
/// this is the type that represents a method or field
/// </param>
/// <param name="node">
/// this is the node representing the XML element
/// </param>
/// <param name="value">
/// this is the value from the internal strategy
/// </param>
/// <returns>
/// the value representing the deserialized value
/// </returns>
public Value Read(Type type, NodeMap<InputNode> node, Value value) {
Converter converter = scanner.GetConverter(type, value);
InputNode parent = node.getNode();
if(converter != null) {
Object data = converter.Read(parent);
if(value != null) {
value.setValue(data);
}
return new Reference(value, data);
}
return value;
}
/// <summary>
/// This is used to resolve and load a class for the given element.
/// Resolution of the class to used is done by inspecting the
/// XML element provided. If there is a "class" attribute on the
/// element then its value is used to resolve the class to use.
/// This also expects a "length" attribute for the array length.
/// </summary>
/// <param name="type">
/// this is the type of the XML element expected
/// </param>
/// <param name="node">
/// this is the element used to resolve an override
/// </param>
/// <returns>
/// returns the class that should be used for the object
/// </returns>
public Value ReadArray(Class type, NodeMap node) {
Node entry = node.remove(length);
int size = 0;
if(entry != null) {
String value = entry.getValue();
size = Integer.parseInt(value);
}
return new ArrayValue(type, size);
}
/// <summary>
/// This is used to resolve and load a class for the given element.
/// Resolution of the class to used is done by inspecting the
/// XML element provided. If there is a "class" attribute on the
/// element then its value is used to resolve the class to use.
/// If no such attribute exists the specified field is returned,
/// or if the field type is an array then the component type.
/// </summary>
/// <param name="type">
/// this is the type of the XML element expected
/// </param>
/// <param name="node">
/// this is the element used to resolve an override
/// </param>
/// <returns>
/// returns the class that should be used for the object
/// </returns>
public Class ReadValue(Type type, NodeMap node) {
Node entry = node.remove(label);
Class expect = type.getType();
if(expect.isArray()) {
expect = expect.getComponentType();
}
if(entry != null) {
String name = entry.getValue();
expect = loader.Load(name);
}
return expect;
}
/// <summary>
/// This is used to serialize a representation of the object value
/// provided. If there is a <c>Convert</c> annotation present
/// on the provided type then this will use the converter specified
/// to serialize a representation of the object. If however there
/// is no annotation then this will delegate to the internal
/// strategy. This returns true if the serialization has completed.
/// </summary>
/// <param name="type">
/// this is the type that represents the field or method
/// </param>
/// <param name="value">
/// this is the object instance to be serialized
/// </param>
/// <param name="node">
/// this is the XML element to be serialized to
/// </param>
/// <returns>
/// this returns true if it was serialized, false otherwise
/// </returns>
public bool Write(Type type, Object value, NodeMap<OutputNode> node) {
Converter converter = scanner.GetConverter(type, value);
OutputNode parent = node.getNode();
if(converter != null) {
converter.Write(parent, value);
return true;
}
return false;
}
/// <summary>
/// This is used to attach a attribute to the provided element
/// that is used to identify the class. The attribute name is
/// "class" and has the value of the fully qualified class
/// name for the object provided. This will only be invoked
/// if the object class is different from the field class.
/// </summary>
/// <param name="type">
/// this is the declared class for the field used
/// </param>
/// <param name="value">
/// this is the instance variable being serialized
/// </param>
/// <param name="node">
/// this is the element used to represent the value
/// </param>
/// <param name="map">
/// this is used to maintain contextual information
/// </param>
/// <returns>
/// this returns true if serialization is complete
/// </returns>
public bool Write(Type type, Object value, NodeMap node, Dictionary map) {
Class actual = value.getClass();
Class expect = type.getType();
Class real = actual;
if(actual.isArray()) {
real = WriteArray(expect, value, node);
}
if(actual != expect) {
node.put(label, real.getName());
}
return false;
}
/// <summary>
/// This is used to add a length attribute to the element due to
/// the fact that the serialized value is an array. The length
/// of the array is acquired and inserted in to the attributes.
/// </summary>
/// <param name="field">
/// this is the field type for the array to set
/// </param>
/// <param name="value">
/// this is the actual value for the array to set
/// </param>
/// <param name="node">
/// this is the map of attributes for the element
/// </param>
/// <returns>
/// returns the array component type that is set
/// </returns>
public Class WriteArray(Class field, Object value, NodeMap node) {
int size = Array.getLength(value);
if(length != null) {
node.put(length, String.valueOf(size));
}
return field.getComponentType();
}
/// <summary>
/// This is used to serialize a representation of the object value
/// provided. If there is a <c>Convert</c> annotation present
/// on the provided type then this will use the converter specified
/// to serialize a representation of the object. If however there
/// is no annotation then this will delegate to the internal
/// strategy. This returns true if the serialization has completed.
/// </summary>
/// <param name="type">
/// this is the type that represents the field or method
/// </param>
/// <param name="value">
/// this is the object instance to be serialized
/// </param>
/// <param name="node">
/// this is the XML element to be serialized to
/// </param>
/// <param name="map">
/// this is the session map used by the serializer
/// </param>
/// <returns>
/// this returns true if it was serialized, false otherwise
/// </returns>
public bool Write(Type type, Object value, NodeMap<OutputNode> node, Dictionary map) {
bool reference = strategy.Write(type, value, node, map);
if(!reference) {
return Write(type, value, node);
}
return reference;
}
/// <summary>
/// This is used to resolve and load a class for the given element.
/// Resolution of the class to used is done by inspecting the
/// XML element provided. If there is a "class" attribute on the
/// element then its value is used to resolve the class to use.
/// If no such attribute exists on the element this returns null.
/// </summary>
/// <param name="type">
/// this is the type of the XML element expected
/// </param>
/// <param name="node">
/// this is the element used to resolve an override
/// </param>
/// <param name="map">
/// this is used to maintain contextual information
/// </param>
/// <returns>
/// returns the class that should be used for the object
/// </returns>
public Value Read(Type type, NodeMap node, Dictionary map) {
Class actual = ReadValue(type, node);
Class expect = type.getType();
if(expect.isArray()) {
return ReadArray(actual, node);
}
if(expect != actual) {
return new ObjectValue(actual);
}
return null;
}
/// <summary>
/// This is used to read the <c>Value</c> which will be used
/// to represent the deserialized object. If there is an annotation
/// present then the value will contain an object instance. If it
/// does not then it is up to the internal strategy to determine
/// what the returned value contains.
/// </summary>
/// <param name="type">
/// this is the type that represents a method or field
/// </param>
/// <param name="node">
/// this is the node representing the XML element
/// </param>
/// <param name="map">
/// this is the session map that contain variables
/// </param>
/// <returns>
/// the value representing the deserialized value
/// </returns>
public Value Read(Type type, NodeMap<InputNode> node, Dictionary map) {
Value value = strategy.Read(type, node, map);
if(IsReference(value)) {
return value;
}
return Read(type, node, value);
}
public Funcis(string sigPath = @"\Signals")
{
locals = new NodeMap<LocalNode>();
remotes = new NodeMap<RemoteNode>();
this.sigPath = sigPath;
}
