public FileIO(IGraph g)
{
try
{
graph = g;
outputnodetype = g.Model.NodeModel.GetType("grIO_OUTPUT");
if (outputnodetype == null) throw new Exception();
createOrOverwriteType = g.Model.EdgeModel.GetType("grIO_CreateOrOverwrite");
if (createOrOverwriteType == null) throw new Exception();
createOrAppendType = g.Model.EdgeModel.GetType("grIO_CreateOrAppend");
if (createOrAppendType == null) throw new Exception();
fileType = g.Model.NodeModel.GetType("grIO_File");
if (fileType == null) throw new Exception();
fileNameAttrType = fileType.GetAttributeType("path");
if (fileNameAttrType == null) throw new Exception();
lineType = g.Model.NodeModel.GetType("grIO_File_Line");
if (lineType == null) throw new Exception();
containsLineType = g.Model.EdgeModel.GetType("grIO_File_ContainsLine");
if (containsLineType == null) throw new Exception();
nextLineType = g.Model.EdgeModel.GetType("grIO_File_NextLine");
if (nextLineType == null) throw new Exception();
lineContentAttrType = lineType.GetAttributeType("content");
if (lineContentAttrType == null) throw new Exception();
}
catch (Exception)
{
throw new Exception("Could not find the required node/edge types. Did you include the GrIO-model?");
}
}
public void should_add_and_get_unamed_node_on_an_array_and_variable(NodeType type)
{
var metadata = new Metadata(new object());
var node = new Node { NodeType = type };
node.ShouldExecuteCallback<INode>(
(x, c) => node.Add(NodeType.Value, metadata, c), x =>
{
x.IsNamed.ShouldBeFalse();
x.NodeType.ShouldEqual(NodeType.Value);
x.Metadata.ShouldNotBeSameAs(metadata);
x.Metadata.Get<object>().ShouldBeSameAs(metadata.Get<object>());
node.ShouldContainInstance(x);
});
node.ShouldExecuteCallback<INode>(
(x, c) => node.Add(NodeType.Object, metadata, c), x =>
{
x.IsNamed.ShouldBeFalse();
x.NodeType.ShouldEqual(NodeType.Object);
x.Metadata.ShouldNotBeSameAs(metadata);
x.Metadata.Get<object>().ShouldBeSameAs(metadata.Get<object>());
node.ShouldContainInstance(x);
});
node.ShouldExecuteCallback<INode>(
(x, c) => node.Add(NodeType.Array, metadata, c), x =>
{
x.IsNamed.ShouldBeFalse();
x.NodeType.ShouldEqual(NodeType.Array);
x.Metadata.ShouldNotBeSameAs(metadata);
x.Metadata.Get<object>().ShouldBeSameAs(metadata.Get<object>());
node.ShouldContainInstance(x);
});
}
private async Task AcceptLoopAsync(ISocketConfiguration socketConfiguration, CancellationToken cancellationToken, NodeType nodeType)
{
_started.Set();
try
{
while (!cancellationToken.IsCancellationRequested)
{
var tcpClient = await _listener.AcceptTcpClientAsync();
SetupTcpClientParametersWithoutReceiveTimeout(tcpClient, socketConfiguration);
tcpClient.ReceiveTimeout = NodeTypeHasReceiveTimeout.HasReceiveTimeout(nodeType) ? socketConfiguration.ReceiveTimeout.ToMillisOrZero() : 0;
var socket = new TcpSocket(_endpoint, tcpClient);
socket.Disconnected += () => ClientDisconnected(socket);
TryFireClientConnectedEvent(socket, socketConfiguration);
}
}
catch (ThreadAbortException)
{
}
catch (OperationCanceledException)
{
}
catch (ObjectDisposedException)
{
}
finally
{
_stopped.Set();
}
}
public BaseNode(string Text)
{
nodeType = NodeType.Base;
this.Text = Text;
this.ImageIndex = DataConvert.GetInt32(IconType.Tasks);
this.SelectedImageIndex = DataConvert.GetInt32(IconType.Tasks);
}
/// <summary>
/// Constructs with the provided node ID, type, activation function ID and auxiliary state data.
/// </summary>
public NetworkNode(uint id, NodeType nodeType, int activationFnId, double[] auxState)
{
_id = id;
_nodeType = nodeType;
_activationFnId = activationFnId;
_auxState = auxState;
}
/// <summary>
/// Constructs with the provided node ID, type and activation function ID.
/// </summary>
public NetworkNode(uint id, NodeType nodeType, int activationFnId)
{
_id = id;
_nodeType = nodeType;
_activationFnId = activationFnId;
_auxState = null;
}
protected internal BinaryFormula(NodeType nodeType, IFormula left, IFormula right, ITypeDeclaration type, IMethodDeclaration method, IFormula parent)
: base(nodeType, type, parent)
{
Left = left;
Method = method;
Right = right;
}
public QuadNode(NodeType nodeType, int nodeSize, int nodeDepth, QuadNode parent, QuadTree parentTree, int positionIndex)
{
NodeType = nodeType;
_nodeSize = nodeSize;
_nodeDepth = nodeDepth;
_positionIndex = positionIndex;
_parent = parent;
_parentTree = parentTree;
//Add the 9 vertices
AddVertices();
Bounds = new BoundingBox(_parentTree.Vertices[VertexTopLeft.Index].Position,
_parentTree.Vertices[VertexBottomRight.Index].Position);
if (nodeSize >= 4)
AddChildren();
//Make call to UpdateNeighbors from the parent node.
//This will update all neighbors recursively for the
//children as well. This ensures all nodes are created
//prior to updating neighbors.
if (_nodeDepth == 1)
{
AddNeighbors();
VertexTopLeft.Activated = true;
VertexTopRight.Activated = true;
VertexCenter.Activated = true;
VertexBottomLeft.Activated = true;
VertexBottomRight.Activated = true;
}
}
public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
{
bool success;
IFileSystem fileSystem;
var address = LayeredNodeAddress.Parse(uri);
lock (this.fileSystemCache)
{
success = this.fileSystemCache.TryGetValue(address.RootUri, out fileSystem);
}
if (!success)
{
var networkUri = String.Format("netvfs://{0}[" + uri + "]/", this.ipAddress);
fileSystem = FileSystemManager.GetManager().ResolveDirectory(networkUri).FileSystem;
lock (this.fileSystemCache)
{
this.fileSystemCache.Add(address.RootUri, fileSystem);
}
}
return fileSystem.Resolve(address.PathAndQuery);
}
public void Update(NodeType nextType)
{
if (nextType == nodeType)
{
return;
}
switch(nextType)
{
case NodeType.Sequence:
mInternalNode = new BirdNest.Nodes.Sequence();
break;
case NodeType.Selector:
mInternalNode = new BirdNest.Nodes.Selector();
break;
case NodeType.Parallel:
mInternalNode = new BirdNest.Nodes.Parallel();
break;
case NodeType.UsePlan:
mInternalNode = new BirdNest.Nodes.UsePlanNode(this);
break;
default:
mInternalNode = null;
return;
}
nodeType = nextType;
}
protected internal BinaryFormula(NodeType nodeType, Formula left, IMethodDeclaration method, Formula right)
: base(nodeType, left.Type)
{
Left = left;
Method = method;
Right = right;
}
public NodeGreetingMessageVerifier(NodeType localNodeType, NodeType expectedRemoteNodeType, params NodeType[] allowOtherRemoteNoteTypes)
{
_expectedRemoteNodeTypes = new HashSet<NodeType> { expectedRemoteNodeType };
if (allowOtherRemoteNoteTypes != null) _expectedRemoteNodeTypes.UnionWith(allowOtherRemoteNoteTypes);
_greetingMessage = new NodeGreetingMessage(localNodeType);
}
public Node(string reference, GTASprite sprite, NodeType type)
{
Ref = reference;
Direction = TreeDirection.Auto;
Type = type;
Sprite = sprite;
}
/// <summary>
/// Constructs a new node.
/// </summary>
internal Node(String name, NodeType type = NodeType.Element, NodeFlags flags = NodeFlags.None)
{
_name = name ?? String.Empty;
_type = type;
_children = new NodeList();
_flags = flags;
}
public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
{
if (this.ChildrenProvider != null)
{
foreach (var node in this.ChildrenProvider(nodeType, acceptNode))
{
yield return node;
}
yield break;
}
foreach (var node in GetJumpPoints(nodeType, acceptNode))
{
if (nodeType == NodeType.Any || node.NodeType == nodeType)
{
yield return node;
}
}
foreach (var node in this.children.Values)
{
if (node.NodeType == nodeType)
{
yield return node;
}
}
}
IClassInfoGraphNode addClassInfoGraphNode(ObjectSpace objectSpace, IMemberInfo memberInfo, NodeType nodeType) {
var classInfoGraphNode =(IClassInfoGraphNode)objectSpace.CreateObject(TypesInfo.Instance.ClassInfoGraphNodeType);
classInfoGraphNode.Name = memberInfo.Name;
classInfoGraphNode.TypeName = getSerializedType(memberInfo).Name;
classInfoGraphNode.NodeType=nodeType;
return classInfoGraphNode;
}
public Node(int id, NodeType type)
{
this.Id = id;
this.type = type;
this.packetSeq = 0;
this.global = Global.getInstance();
}
public Node(
NodeType nodeType,
ObjectNodeBase parent = null) :
base(null, null, null, parent, ObjectNodeBaseTests.Context)
{
_nodeType = nodeType;
}
public Node(NodeType nt,int sym,int freq,int order)
{
this.nt = nt;
this.sym = sym;
this.freq = freq;
this.order = order;
}
/// <summary>
/// Bezparametrowy konstruktor na potrzeby serializacji Xml
/// </summary>
public Register()
: base()
{
type = 0;
parallelThreads = 0;
solvableProblems = new List<string>();
}
public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
{
foreach (string key in Environment.GetEnvironmentVariables().Keys)
{
yield return GetImaginaryChild(key, NodeType.File);
}
}
public Node GetChildByType(NodeType type)
{
if (Children != null)
return Children.FirstOrDefault(c => c.Type == type);
else
return null;
}
public XmlNodeInformation(string contentValue, int depth, CommonNamespaces commonNamespaces)
{
m_contentValue = contentValue;
iDepth = depth;
nodeType = NodeType.content;
m_commonNamespaces = commonNamespaces;
}
/// <summary>
/// Gets the type of the name to value collection from element for.
/// </summary>
/// <param name="mainDocumentPart">The main document part.</param>
/// <param name="elementName">Name of the element.</param>
/// <param name="forNodeType">Type of for node.</param>
/// <returns></returns>
public Dictionary<string, string> GetNameToValueCollectionFromElementForType(MainDocumentPart mainDocumentPart, string elementName, NodeType forNodeType)
{
Dictionary<string, string> nameToValueCollection = new Dictionary<string, string>();
CustomXmlPart customXmlPart = this.customXmlPartCore.GetCustomXmlPart(mainDocumentPart);
if (customXmlPart != null)
{
XElement element = this.customXmlPartCore.GetFirstElementFromCustomXmlPart(customXmlPart, elementName);
if (element != null)
{
if (forNodeType == NodeType.Element)
{
foreach (XElement elem in element.Elements())
{
nameToValueCollection.Add(elem.Name.LocalName, elem.Nodes().Where(node => node.NodeType == XmlNodeType.Element).FirstOrDefault().ToString());
}
}
else if (forNodeType == NodeType.Attribute)
{
foreach (XAttribute attr in element.Attributes())
{
nameToValueCollection.Add(attr.Name.LocalName, attr.Value);
}
}
}
}
return nameToValueCollection;
}
public void should_get_node(NodeType type)
{
var parent = new Node { NodeType = type };
var child = new Node("hai");
parent.Add(child, x => { });
parent.GetNode("hai").ShouldEqual(child);
}
public void AddGeoTreeNode(NodeType mapNodeType, List<GeoNodePara> clutterNodeParas)
{
if (clutterNodeParas.Count != 0)
{
List<GeoTreeNode> treeNode = new List<GeoTreeNode>();
foreach (GeoNodePara para in clutterNodeParas)
{
GeoTreeNode item = this.GetGeoFolderNodeByName(this.m_DynamicNodeCollection, mapNodeType, para.FolderName);
if (item == null)
{
item = new GeoTreeNode(para.FolderName, LayerIDCreator.GetExclusiveID(), mapNodeType, CheckedState.Checked);
this.m_DynamicNodeCollection.Add(item);
treeNode.Add(item);
}
GeoTreeNode node2 = new GeoTreeNode(para.LayerName, para.LayerId, mapNodeType, CheckedState.Checked);
foreach (KeyValuePair<int, string> pair in para.ClutterIdNameDict)
{
int tag = (para.LayerId << 0x10) + ((short) pair.Key);
GeoTreeNode node3 = new GeoTreeNode(pair.Value, tag, mapNodeType, CheckedState.Checked);
node2.ChildrenNodes.Add(node3);
}
item.ChildrenNodes.Add(node2);
}
if (this.OnAddModelNodeEvent != null)
{
this.OnAddModelNodeEvent(treeNode);
}
}
}
protected override INode CreateNode(INodeAddress address, NodeType nodeType)
{
if (!address.IsRoot)
{
var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory);
if (parent is ImaginaryDirectory)
{
var retval = ((ImaginaryDirectory)parent).GetImaginaryChild(address.Name, nodeType);
if (retval != null)
{
return retval;
}
}
}
if (nodeType == NodeType.Directory)
{
return new ImaginaryDirectory(this, address);
}
else if (nodeType == NodeType.File)
{
return new ImaginaryFile(this, address);
}
throw new NotSupportedException(String.Format("{0}:{1}", address, nodeType));
}
public BaseNode(string nodename)
{
NodeType = NodeType.Base;
this.Text = nodename;
this.ImageIndex = DataConvert.GetInt32(IconType.VsTemplates);
this.SelectedImageIndex = DataConvert.GetInt32(IconType.VsTemplates);
}
//Constructor
public NodeValue(string name, Object value, NodeType type)
: base(name, Node.EmptyNodes)
{
_type = type;
_value = value;
_desc = "Value";
}
public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
{
var address = LayeredNodeAddress.Parse(uri);
if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "")
{
throw new MalformedUriException(uri, "Network & Authentication information not permitted");
}
if (nodeType.Is(typeof(IFile)))
{
var uri2 = address.InnerUri;
if (StringUriUtils.ContainsQuery(uri2))
{
uri2 += "&shadow=true";
}
else
{
uri2 += "?shadow=true";
}
return resolver.Resolve(uri2, nodeType);
}
return resolver.Resolve(address.InnerUri);
}
protected VirtualFilesystemNode(NodeType type, string name)
{
Type = type;
Name = name;
}
/// <summary>
/// Initializes a new instance of the <see cref="ManagePermissionSPObject" /> class.
/// </summary>
/// <param name="parentUrl">parentUrl.</param>
/// <param name="parentNodeType">parentNodeType.</param>
/// <param name="siteUrl">siteUrl.</param>
/// <param name="webUrl">webUrl.</param>
/// <param name="primaryAdministrator">primaryAdministrator.</param>
/// <param name="primaryContact">primaryContact.</param>
/// <param name="secondaryContact">secondaryContact.</param>
/// <param name="temporaryGroupTitle">temporaryGroupTitle.</param>
/// <param name="webId">webId.</param>
/// <param name="siteId">siteId.</param>
/// <param name="webServerRelativeUrl">webServerRelativeUrl.</param>
/// <param name="listTitle">listTitle.</param>
/// <param name="topInheritUrl">topInheritUrl.</param>
/// <param name="inheritNodeType">inheritNodeType.</param>
/// <param name="isInheritedPermission">isInheritedPermission.</param>
/// <param name="id">id.</param>
/// <param name="title">title.</param>
/// <param name="fullUrl">fullUrl.</param>
/// <param name="type">type.</param>
public ManagePermissionSPObject(string parentUrl = default(string), NodeType parentNodeType = default(NodeType), string siteUrl = default(string), string webUrl = default(string), ApiUser primaryAdministrator = default(ApiUser), ApiUser primaryContact = default(ApiUser), ApiUser secondaryContact = default(ApiUser), string temporaryGroupTitle = default(string), Guid webId = default(Guid), Guid siteId = default(Guid), string webServerRelativeUrl = default(string), string listTitle = default(string), string topInheritUrl = default(string), NodeType inheritNodeType = default(NodeType), bool isInheritedPermission = default(bool), Guid id = default(Guid), string title = default(string), string fullUrl = default(string), NodeType type = default(NodeType))
{
this.ParentUrl = parentUrl;
this.SiteUrl = siteUrl;
this.WebUrl = webUrl;
this.PrimaryAdministrator = primaryAdministrator;
this.PrimaryContact = primaryContact;
this.SecondaryContact = secondaryContact;
this.TemporaryGroupTitle = temporaryGroupTitle;
this.WebServerRelativeUrl = webServerRelativeUrl;
this.ListTitle = listTitle;
this.TopInheritUrl = topInheritUrl;
this.Title = title;
this.FullUrl = fullUrl;
this.ParentUrl = parentUrl;
this.ParentNodeType = parentNodeType;
this.SiteUrl = siteUrl;
this.WebUrl = webUrl;
this.PrimaryAdministrator = primaryAdministrator;
this.PrimaryContact = primaryContact;
this.SecondaryContact = secondaryContact;
this.TemporaryGroupTitle = temporaryGroupTitle;
this.WebId = webId;
this.SiteId = siteId;
this.WebServerRelativeUrl = webServerRelativeUrl;
this.ListTitle = listTitle;
this.TopInheritUrl = topInheritUrl;
this.InheritNodeType = inheritNodeType;
this.IsInheritedPermission = isInheritedPermission;
this.Id = id;
this.Title = title;
this.FullUrl = fullUrl;
this.Type = type;
}
/// <summary>
/// Advances the reader to the given node type, ignoring depth/scope.
/// </summary>
/// <param name="view">The view at the returned node type.</param>
/// <param name="node">The node type to stop at.</param>
/// <returns>The node type the parser stopped at.</returns>
public NodeType Step(out SerializedValueView view, NodeType node = NodeType.Any)
{
view = ReadInternal(node, NodeParser.k_IgnoreParent);
return(m_Parser.NodeType);
}
/// <summary>
/// Advances the reader to the given node type, ignoring depth/scope.
/// </summary>
/// <param name="node">The node type to stop at.</param>
/// <returns>The node type the parser stopped at.</returns>
public NodeType Step(NodeType node = NodeType.Any)
{
ReadInternal(node, NodeParser.k_IgnoreParent);
return(m_Parser.NodeType);
}
public void AddNode(double x, double y, Guid id, NodeType nodeType)
{
}
private void VisitNode(MemoryNode currentNode)
{
MemoryNode oldMemNode = currentNode;
// Get the generation for the current node.
int generation = _HeapInfo.GenerationFor(oldMemNode.Address);
// Create a MemoryNodeBuilder for the new graph that represents the current node
// unless the current node is the root, as we've already created one.
MemoryNodeBuilder newMemNodeBuilder = null;
if (currentNode.Index == _OriginalMemoryGraph.RootIndex)
{
newMemNodeBuilder = _RootNode;
}
else
{
// Get the parent node.
MemoryNodeBuilder parentMemNodeBuilder = null;
if ((oldMemNode.Address != 0) && (generation > _GenerationToCondemn))
{
if (generation == 1)
{
parentMemNodeBuilder = _Gen1RootNode;
}
else
{
parentMemNodeBuilder = _Gen2RootNode;
}
}
else
{
parentMemNodeBuilder = _OldNodeToNewParentMap[(int)currentNode.Index];
}
if (parentMemNodeBuilder == null)
{
parentMemNodeBuilder = _UnknownRootNode;
}
// Get the current node's type and object address.
NodeType nodeType = _OriginalMemoryGraph.GetType(oldMemNode.TypeIndex, _OldNodeTypeStorage);
// Create the new generation aware type name.
string typeName = null;
if (oldMemNode.Address != 0 && generation >= 0)
{
if (generation == 3)
{
typeName = string.Format("LOH: {0}", nodeType.Name);
}
else
{
typeName = string.Format("Gen{0}: {1}", generation, nodeType.Name);
}
}
else
{
if (oldMemNode.Address != 0)
{
_Log.WriteLine(string.Format("Generation: {0}; Address: {1}; Type: {2}", generation, oldMemNode.Address, nodeType.Name));
}
typeName = nodeType.Name;
}
// Create the new node.
if (ShouldAddToGraph(oldMemNode, nodeType))
{
if (oldMemNode.Address == 0)
{
newMemNodeBuilder = parentMemNodeBuilder.FindOrCreateChild(typeName);
}
else
{
NodeIndex newNodeIndex = _NewMemoryGraph.GetNodeIndex(oldMemNode.Address);
newMemNodeBuilder = new MemoryNodeBuilder(_NewMemoryGraph, typeName, null, newNodeIndex);
parentMemNodeBuilder.AddChild(newMemNodeBuilder);
// Set the object size.
if (generation <= _GenerationToCondemn)
{
newMemNodeBuilder.Size = oldMemNode.Size;
}
else
{
_Log.WriteLine("Ignoring Object Size: " + typeName);
}
}
}
}
// Associate all children of the current node with this object's new MemoryNodeBuilder.
for (NodeIndex childIndex = oldMemNode.GetFirstChildIndex(); childIndex != NodeIndex.Invalid; childIndex = oldMemNode.GetNextChildIndex())
{
_OldNodeToNewParentMap[(int)childIndex] = newMemNodeBuilder;
}
}
internal IndexQueryTreeNode(NodeType type)
{
this.type = type;
}
public AbstractExpressionNode(NodeType type) : base(type)
{
}
/// <summary>
/// Serializes a NodeType object to Json string.
/// </summary>
/// <param name="value">The target object to be serialized.</param>
/// <returns>The serialized Json string.</returns>
public static string ToString(NodeType value)
{
s_ensure_string_builder();
ToString_impl(value, s_stringBuilder, in_json: false);
return(s_stringBuilder.ToString());
}
public static bool HasBomb(this NodeType type)
{
return(type == NodeType.BombCyan || type == NodeType.BombMagenta);
}
public abstract INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options);
void Process()
{
bool matrixOnly = true;
bool hasMatrix = false;
bool hasVector = false;
bool hasSingle = false;
foreach (NodeInput inp in Inputs)
{
if (inp != executeInput)
{
if (inp.HasInput)
{
if (inp.Input.Data is MVector)
{
matrixOnly = false;
hasVector = true;
}
else if (Utils.IsNumber(inp.Input.Data))
{
hasSingle = true;
matrixOnly = false;
}
else if (inp.Input.Data is Matrix4)
{
hasMatrix = true;
}
}
}
}
if (hasVector && hasMatrix)
{
object i1 = Inputs[1].Input.Data;
object i2 = Inputs[2].Input.Data;
NodeType t1 = Inputs[1].Input.Type;
NodeType t2 = Inputs[2].Input.Type;
if (i1 is MVector && i2 is Matrix4)
{
MVector v = (MVector)i1;
if (t1 == NodeType.Float2 || t1 == NodeType.Float3)
{
v.W = 1;
}
Vector4 v2 = new Vector4(v.X, v.Y, v.Z, v.W);
Matrix4 m2 = (Matrix4)i2;
v2 = v2 * m2;
output.Data = new MVector(v2.X, v2.Y, v2.Z, v2.W);
}
else if (i1 is Matrix4 && i2 is MVector)
{
MVector v = (MVector)i2;
if (t2 == NodeType.Float2 || t2 == NodeType.Float3)
{
v.W = 1;
}
Vector4 v2 = new Vector4(v.X, v.Y, v.Z, v.W);
Matrix4 m2 = (Matrix4)i1;
v2 = m2 * v2;
output.Data = new MVector(v2.X, v2.Y, v2.Z, v2.W);
}
else
{
output.Data = i1;
}
}
else if (hasMatrix && matrixOnly)
{
object i1 = Inputs[1].Input.Data;
object i2 = Inputs[2].Input.Data;
if (i1 is Matrix4 && i1 is Matrix4)
{
Matrix4 m1 = (Matrix4)i1;
Matrix4 m2 = (Matrix4)i2;
output.Data = m1 * m2;
}
else
{
output.Data = i1;
}
}
else if (hasMatrix && hasSingle)
{
object i1 = Inputs[1].Input.Data;
object i2 = Inputs[2].Input.Data;
if (Utils.IsNumber(i1) && i2 is Matrix4)
{
float f = Convert.ToSingle(i1);
Matrix4 m2 = (Matrix4)i2;
output.Data = f * m2;
}
else if (i1 is Matrix4 && Utils.IsNumber(i2))
{
float f = Convert.ToSingle(i2);
Matrix4 m2 = (Matrix4)i1;
output.Data = m2 * f;
}
else
{
output.Data = i1;
}
}
else if (hasVector)
{
MVector v = new MVector();
int i = 0;
foreach (NodeInput inp in Inputs)
{
if (inp != executeInput)
{
if (inp.HasInput)
{
object o = inp.Input.Data;
if (o == null)
{
continue;
}
if (Utils.IsNumber(o))
{
if (i == 0)
{
float f = Convert.ToSingle(o);
v.X = v.Y = v.Z = v.W = f;
}
else
{
float f = Convert.ToSingle(o);
v.X *= f;
v.Y *= f;
v.Z *= f;
v.W *= f;
}
}
else if (o is MVector)
{
if (i == 0)
{
var d = (MVector)o;
v.X = d.X;
v.Y = d.Y;
v.Z = d.Z;
v.W = d.W;
}
else
{
MVector f = (MVector)o;
v.X *= f.X;
v.Y *= f.Y;
v.Z *= f.Z;
v.W *= f.W;
}
}
i++;
}
}
}
output.Data = v;
}
else
{
float v = 0;
int i = 0;
foreach (NodeInput inp in Inputs)
{
if (inp != executeInput)
{
if (inp.HasInput)
{
object o = inp.Input.Data;
if (o == null)
{
continue;
}
if (Utils.IsNumber(o))
{
if (i == 0)
{
v = Convert.ToSingle(o);
}
else
{
float f = Convert.ToSingle(o);
v *= f;
}
}
i++;
}
}
}
output.Data = v;
}
if (output.Data != null)
{
result = output.Data.ToString();
}
if (ParentGraph != null)
{
FunctionGraph g = (FunctionGraph)ParentGraph;
if (g != null && g.OutputNode == this)
{
g.Result = output.Data;
}
}
}
private void ChunkIt(Node p_node)
{
NodeType this_type = p_node.Type;
switch (this_type)
{
case NodeType.PROGRAM:
ChunkProgram(p_node as ProgramNode);
break;
case NodeType.BINARY:
ChunkBinary(p_node as BinaryNode);
break;
case NodeType.UNARY:
ChunkUnary(p_node as UnaryNode);
break;
case NodeType.LITERAL:
ChunkLiteral(p_node as LiteralNode);
break;
case NodeType.GROUPING:
ChunkGrouping(p_node as GroupingNode);
break;
case NodeType.STMT_EXPR:
ChunkStmtExpr(p_node as StmtExprNode);
break;
case NodeType.IF:
ChunkIf(p_node as IfNode);
break;
case NodeType.WHILE:
ChunkWhile(p_node as WhileNode);
break;
case NodeType.VARIABLE:
ChunkVariable(p_node as VariableNode);
break;
case NodeType.VAR_DECLARATION:
ChunkVarDeclaration(p_node as VarDeclarationNode);
break;
case NodeType.ASSIGMENT_OP:
ChunkAssignmentOp(p_node as AssignmentNode);
break;
case NodeType.LOGICAL:
ChunkLogical(p_node as LogicalNode);
break;
case NodeType.BLOCK:
ChunkBlock(p_node as BlockNode);
break;
case NodeType.FUNCTION_CALL:
ChunkFunctionCall(p_node as FunctionCallNode);
break;
case NodeType.RETURN:
ChunkReturn(p_node as ReturnNode);
break;
case NodeType.FUNCTION_DECLARATION:
ChunkFunctionDeclaration(p_node as FunctionDeclarationNode);
break;
case NodeType.MEMBER_FUNCTION_DECLARATION:
ChunkMemberFunctionDeclaration(p_node as MemberFunctionDeclarationNode);
break;
case NodeType.FUNCTION_EXPRESSION:
ChunkFunctionExpression(p_node as FunctionExpressionNode);
break;
case NodeType.FOR:
ChunkFor(p_node as ForNode);
break;
case NodeType.TABLE:
ChunkTable(p_node as TableNode);
break;
case NodeType.LIST:
ChunkList(p_node as ListNode);
break;
default:
Error("Received unkown node." + this_type.ToString(), p_node.PositionData);
break;
}
}
public override INode Resolve(string name, NodeType nodeType, AddressScope scope)
{
return(this.viewFileSystem.Resolve(this.parentAddress.ResolveAddress(name).AbsolutePath, nodeType, scope));
}
public FileUploadData(string name, NodeType type = NodeType.FILE)
{
Name = name;
Kind = type;
}
public Node(int xIndex, int yIndex, NodeType nodeType)
{
this.xIndex = xIndex;
this.yIndex = yIndex;
this.nodeType = nodeType;
}
private static Node ConstuctNode(BinaryReader br, UInt32 id, NodeType nodeType, CommandType commandType)
{
//Console.WriteLine(nodeType);
switch (nodeType)
{
case NodeType.Script:
{
var scriptNode = new ScriptNode();
scriptNode.Id = id;
scriptNode.readData(br);
return(scriptNode);
}
case NodeType.Page:
{
var pageNode = new PageNode();
pageNode.Id = id;
pageNode.readData(br);
return(pageNode);
}
case NodeType.OnceOnly:
{
var onceOnly = new OnceOnlyNode();
onceOnly.Id = id;
onceOnly.readData(br);
return(onceOnly);
}
case NodeType.ConditionalTrue:
{
var node = new ConditionalTrueNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.ConditionalFalse:
{
var node = new ConditionalFalseNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.OptionsChoice:
{
var node = new ShowOptionsNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.Option:
{
var node = new OptionNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.ParallelNode:
{
var node = new ParallelNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.BlockNode:
{
var node = new BlockNode();
node.Id = id;
node.readData(br);
return(node);
}
case NodeType.Command:
{
switch (commandType)
{
case CommandType.Say:
{
var command = new SayNode();
command.Id = id;
command.readData(br);
return(command);
}
case CommandType.CallPage:
{
var command = new CallPageNode();
command.Id = id;
command.readData(br);
return(command);
}
case CommandType.Return:
{
var command = new ReturnNode();
command.Id = id;
command.readData(br);
return(command);
}
case CommandType.Wait:
{
var command = new WaitNode();
command.Id = id;
command.readData(br);
return(command);
}
case CommandType.Print:
{
var command = new PrintNode();
command.Id = id;
command.readData(br);
return(command);
}
default:
throw new Exception("Unhandled Node Type:" + nodeType + ":" + commandType);
}
}
// case NodeType.Say
default:
throw new Exception("Unhandled Node Type:" + nodeType);
}
return(null);
}
private void _InsertProfiles(NodeType nodeType, string Ident_DomainRD, string UID_ApplicationServer)
{
ISqlFormatter isql = clsMain.Instance.CurrentConnection.Connection.SqlFormatter;
SqlExecutor cSQL = clsMain.Instance.CurrentConnection.Connection.CreateSqlExecutor(clsMain.Instance.CurrentConnection.PublicKey);
string strSQL = "";
string strSQLEO = "";
TreeListNode tlnProfile;
try
{
// SQL depents on ProfileType
switch (nodeType)
{
case NodeType.AppProfile:
strSQL = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerAppProfile"];
strSQLEO = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerAppProfileErrorsOnly"];
break;
case NodeType.DrvProfile:
strSQL = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerDrvProfile"];
strSQLEO = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerDrvProfileErrorsOnly"];
break;
case NodeType.MacType:
strSQL = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerMacType"];
strSQLEO = clsMain.Instance.CurrentConnection.Connection.SqlStrings["ServerMacTypeErrorsOnly"];
break;
}
// replace the Variables
if (clsMain.Instance.ErrorOnly)
{
strSQL = strSQL.Replace("@ErrorsOnly", strSQLEO); // insert the ErrorOnly part
}
else
{
strSQL = strSQL.Replace("@ErrorsOnly", ""); // remove the ErrorOnly part
}
strSQL = strSQL.Replace("@Ident_DomainRD", isql.FormatValue(Ident_DomainRD, ValType.String));
strSQL = strSQL.Replace("@UID_ApplicationServer", isql.FormatValue(UID_ApplicationServer, ValType.String));
using (IDataReader rData = new CachedDataReader(cSQL.SqlExecute(strSQL)))
{
while (rData.Read())
{
// create a new Node
tlnProfile = tlcProfile.Nodes.Add(rData.GetString(1), 0);
tlnProfile.Tag = new NodeData(nodeType, rData.GetString(0), "");
tlnProfile.SubItems.Add(rData.GetInt32(2).ToString()); // Nr Ist
tlnProfile.SubItems.Add(rData.GetInt32(3).ToString()); // Nr Soll
tlnProfile.SubItems.Add(rData.GetString(4).ToString()); // State P
tlnProfile.SubItems.Add(rData.GetString(5).ToString()); // State S
tlnProfile.SubItems.Add(rData.GetDateTime(6).ToString()); // XDateUpdated
tlnProfile.SubItems.Add("");
}
}
}
catch (Exception ex)
{
ExceptionDialog.Show(this.ParentForm, ex);
}
}
private void treeView1_AfterSelect(object sender, System.Windows.Forms.TreeViewEventArgs e)
{
TreeNode node = treeView1.SelectedNode;
// if(node.Parent != null)
// {
panelIO1.Clear();
NodeType ioType = (NodeType)node.Tag;
string label;
switch (ioType)
{
case NodeType.DigitalInput:
foreach (IDigitalInput ioPoint in ioManifest.digitalInputMap.Values)
{
label = ioPoint.Name;
panelIO1.AddIO(ioPoint, label);
}
break;
case NodeType.DigitalOutput:
foreach (IDigitalOutput ioPoint in ioManifest.digitalOutputMap.Values)
{
label = ioPoint.Name;
panelIO1.AddIO(ioPoint, label);
}
break;
case NodeType.AnalogInput:
foreach (IAnalogInput ioPoint in ioManifest.analogInputMap.Values)
{
label = ioPoint.Name;
panelIO1.AddIO(ioPoint, label);
}
break;
case NodeType.AnalogOutput:
foreach (IAnalogOutput ioPoint in ioManifest.analogOutputMap.Values)
{
label = ioPoint.Name;
panelIO1.AddIO(ioPoint, label);
}
break;
}
if (ioType == NodeType.Axis)
{
panelIO1.Visible = false;
panelIO1.Dock = DockStyle.None;
panelAxis1.Enabled = true;
panelAxis1.Visible = true;
panelAxis1.Dock = DockStyle.Fill;
// assign the one and only axis for this node
panelAxis1.AssignAxisMap(ioManifest.axisMap);
}
else
{
panelIO1.Visible = true;
panelIO1.Dock = DockStyle.Fill;
panelIO1.UpdateLayout();
panelAxis1.Enabled = false;
panelAxis1.Visible = false;
panelAxis1.Dock = DockStyle.Fill;
panelAxis1.AssignAxis(null);
}
// }
}
public void SkuIsGeneratedCorrectly(int cores, int memory, NodeType target, string expectedResult)
{
var SKU = new SKU(cores, memory, target);
Assert.IsTrue(SKU.ToString() == expectedResult);
}
public JSONNode(double value)
{
this._type = NodeType.Number;
_numberValue = value;
}
public JSONNode(Dictionary <string, JSONNode> value)
{
this._type = NodeType.Object;
_objectValue = value;
}
public JSONNode(bool value)
{
this._type = NodeType.Bool;
_boolValue = value;
}
public JSONNode(string value)
{
this._type = NodeType.String;
_stringValue = value;
}
/// <summary>
/// Reads the next node in the stream, respecting depth/scope.
/// </summary>
/// <param name="node">The node type to stop at.</param>
/// <returns>The node type the parser stopped at.</returns>
public NodeType Read(NodeType node = NodeType.Any)
{
ReadInternal(node, m_Parser.TokenParentIndex);
return(m_Parser.NodeType);
}
public JSONNode(List <JSONNode> value)
{
this._type = NodeType.Array;
_arrayValue = value;
}
private GraphItemConfiguration CreateSectionConfiguration(PropertyInfo property, Section section)
{
var sectionConfig = new NodeConfigSectionBase
{
Name = section.Name,
IsProxy = section is ProxySection,
Visibility = section.Visibility,
SourceType = property.PropertyType.GetGenericParameter(),
AddCommandType = section.AddCommandType
};
var referenceSection = section as ReferenceSection;
if (referenceSection != null)
{
sectionConfig.AllowDuplicates = referenceSection.AllowDuplicates;
sectionConfig.AllowAdding = !referenceSection.Automatic;
sectionConfig.ReferenceType = referenceSection.ReferenceType ??
sectionConfig.SourceType.GetGenericParameter() ?? property.PropertyType.GetGenericParameter();
sectionConfig.IsEditable = referenceSection.Editable;
sectionConfig.HasPredefinedOptions = referenceSection.HasPredefinedOptions;
if (sectionConfig.ReferenceType == null)
{
throw new Exception(string.Format("Reference Section on property {0} doesn't have a valid ReferenceType.", property.Name));
}
//sectionConfig.GenericSelector = (node) =>
//{
//};
}
if (sectionConfig.IsProxy || referenceSection == null)
{
var property1 = property;
if (sectionConfig.IsProxy)
{
sectionConfig.AllowAdding = false;
}
sectionConfig.GenericSelector = (node) =>
{
var enumerator = property1.GetValue(node, null) as IEnumerable;
if (enumerator == null)
{
return(null);
}
return(enumerator.Cast <IGraphItem>());
};
}
else if (referenceSection != null)
{
var possibleSelectorProperty = NodeType.GetProperty("Possible" + property.Name);
if (possibleSelectorProperty != null)
{
sectionConfig.GenericSelector = (node) =>
{
var propertyN = NodeType.GetProperty("Possible" + property.Name);
var enumerator = propertyN.GetValue(node, null) as IEnumerable;
if (enumerator == null)
{
return(null);
}
return(enumerator.OfType <IGraphItem>());
};
}
else
{
sectionConfig.GenericSelector = (node) =>
{
return(node.Repository.AllOf <IGraphItem>().Where(p => referenceSection.ReferenceType.IsAssignableFrom(p.GetType())));
};
}
}
return(sectionConfig);
}
public Node(int x, int y, NodeType type, char symbol)
{
Position = new Coordinate(x, y);
Type = type;
Symbol = symbol;
List <Coordinate> sides = GetSides(x, y);
if (type == NodeType.PATH)
{
Field.Add(Position, this);
foreach (var side in sides)
{
if (Field.ContainsKey(side))
{
AddEdge(Field[side]);
}
}
}
else
{
Teleports.Add(Position, this);
foreach (var side in sides)
{
if (Teleports.ContainsKey(side))
{
Node teleport = Teleports[side];
if (symbol == 'A' && teleport.Symbol == 'A')
{
Type = NodeType.START;
teleport.Type = NodeType.START;
Soulmate = teleport;
teleport.Soulmate = this;
}
else if (symbol == 'Z' && teleport.Symbol == 'Z')
{
Type = NodeType.END;
teleport.Type = NodeType.END;
Soulmate = teleport;
teleport.Soulmate = this;
}
else
{
string telId = string.Concat(new[] { symbol, teleport.Symbol });
var pair = new List <Node> {
this, teleport
};
if (TeleportIDs.ContainsKey(telId))
{
TeleportIDs[telId].AddRange(pair);
}
else
{
TeleportIDs.Add(telId, pair);
}
}
}
}
}
}
/// <summary>
/// Reads the next node in the stream, respecting depth/scope.
/// </summary>
/// <param name="view">The view at the returned node type.</param>
/// <param name="node">The node type to stop at.</param>
/// <returns>The node type the parser stopped at.</returns>
public NodeType Read(out SerializedValueView view, NodeType node = NodeType.Any)
{
view = ReadInternal(node, m_Parser.TokenParentIndex);
return(m_Parser.NodeType);
}
/// <summary>
/// 将语法解析为节点树
/// </summary>
/// <param name="reader"></param>
/// <param name="ParentNode"></param>
/// <param name="output"></param>
private void CreateNodeContextRange(StreamReader reader, NodeBlockContext ParentNode, OutPutProvide output)
{
while (true)
{
string line = reader.ReadLine();
if (line == null)
{
return;
}
_lineNumber++;
NodeType type = GetNodeType(line);
NodeContext last = ParentNode.Nodes.LastOrDefault();
if (last?.NdType == NodeType.IF || last?.NdType == NodeType.ELSEIF)
{
if (type != NodeType.ELSEIF && type != NodeType.ELSE)
{
for (int i = ParentNode.Nodes.Count - 1; i >= 0; i--)
{
NodeContext item = ParentNode.Nodes[i];
if (item.NdType != NodeType.ELSEIF && item.NdType != NodeType.IF)
{
break;
}
item.ConvertToExpression();
}
}
}
switch (type)
{
case NodeType.IF:
NodeBlockContext block = new IFNodeContext(line, ParentNode, output);
CreateNodeContextRange(reader, block, output);
ParentNode.Nodes.Add(block);
break;
case NodeType.ELSEIF:
block = new ELSEIFNodeContext(line, ParentNode, output);
CreateNodeContextRange(reader, block, output);
if (last is IFNodeContext ifnd1)
{
ifnd1.ELSENode = block;
}
else if (last is ELSEIFNodeContext elnd1)
{
elnd1.ELSENode = block;
}
else
{
throw new Exception($"第{_lineNumber}行语法错误,elseif必须在 if 或 elseif 之后");
}
ParentNode.Nodes.Add(block);
break;
case NodeType.ELSE:
block = new ELSENodeContext(line, ParentNode, output);
CreateNodeContextRange(reader, block, output);
block.ConvertToExpression();
if (last is IFNodeContext ifnd)
{
ifnd.ELSENode = block;
}
else if (last is ELSEIFNodeContext elnd)
{
elnd.ELSENode = block;
}
else
{
throw new Exception($"第{_lineNumber}行语法错误,else 必须在 if 或 elseif之后");
}
for (int i = ParentNode.Nodes.Count - 1; i >= 0; i--)
{
NodeContext item = ParentNode.Nodes[i];
if (item.NdType != NodeType.ELSEIF && item.NdType != NodeType.IF)
{
break;
}
item.ConvertToExpression();
}
ParentNode.Nodes.Add(block);
break;
case NodeType.EACH:
block = new EACHNodeContext(line, ParentNode, output);
CreateNodeContextRange(reader, block, output);
block.ConvertToExpression();
ParentNode.Nodes.Add(block);
break;
case NodeType.PRINT:
NodeContext node = new PRINTNodeContext(line, ParentNode, output);
node.ConvertToExpression();
ParentNode.Nodes.Add(node);
break;
case NodeType.STRING:
node = new STRINGNodeContext(line, ParentNode, output);
node.ConvertToExpression();
ParentNode.Nodes.Add(node);
break;
case NodeType.SET:
node = new SETNodeContext(line, ParentNode, output);
node.ConvertToExpression();
ParentNode.Nodes.Add(node);
break;
case NodeType.OPER:
node = new OperNodeContext(line, ParentNode, output);
node.ConvertToExpression();
ParentNode.Nodes.Add(node);
break;
case NodeType.ENDIF:
case NodeType.ENDELSEIF:
case NodeType.ENDELSE:
case NodeType.ENDEACH:
return;
default:
throw new Exception($"{type}是不受支持的节点类型");
}
}
}
