private void VisitNodes(GeneralTree<INode> features, INode node) { if (node.IsIndexMarkDownNode()) { return; } string nodePath = this.fileSystem.Path.Combine(this.configuration.OutputFolder.FullName, node.RelativePathFromRoot); string htmlFilePath; if (node.NodeType == NodeType.Content) { htmlFilePath = nodePath.Replace(this.fileSystem.Path.GetExtension(nodePath), ".html"); this.WriteContentNode(features, node, htmlFilePath); } else if (node.NodeType == NodeType.Structure) { this.fileSystem.Directory.CreateDirectory(nodePath); htmlFilePath = this.fileSystem.Path.Combine(nodePath, "index.html"); this.WriteContentNode(features, node, htmlFilePath); } else { // copy file from source to output this.fileSystem.File.Copy(node.OriginalLocation.FullName, nodePath, overwrite: true); } }
public IEnumerable<NodeConnection> GetPossibleTransitions(INode from) { var wsFrom = ((WorldStateNode)from).State; var result = new List<NodeConnection>(); foreach (var action in planner.Actions) { var pre = action.Preconditions; var mask = pre.Mask; var met = (pre.Values & mask) == (wsFrom.Values & mask); if (met) { var neighbour = planner.PerformAction(action, wsFrom); if (wsFrom.Match(neighbour)) { continue; } var connection = new NodeConnection(); connection.From = from; connection.To = new WorldStateNode(this, neighbour, action); connection.Cost = action.Cost; result.Add(connection); } } return result; }
// inserting before current position is not allowed in a Transformer // but inserting after it is possible protected void InsertAfterSibling(INode sibling, INode newNode) { if (sibling == null || sibling.Parent == null) return; int index = sibling.Parent.Children.IndexOf(sibling); sibling.Parent.Children.Insert(index + 1, newNode); newNode.Parent = sibling.Parent; }
private static void PrintSolution(PathFinder pathFinder, INode result) { int steps = 0; INode node = result; if (node != null) { var stack = new Stack<INode>(); do { stack.Push(node); } while ((node = node.Parent) != null); Debug.WriteLine("8-Puzzle Solved in {0} Cycles", pathFinder.Cycles); Debug.WriteLine("-------------------------------------------"); foreach (EightPuzzleNode solutionNode in stack) { string tiles = solutionNode.Tiles .Aggregate("", (current, i) => current + i.ToString()); Debug.WriteLine("{0:00} - {1} - F: {2:00.0} G: {3:00.0} H: {4:00.0}", steps++, tiles, solutionNode.F, solutionNode.G, solutionNode.H); } } else { Debug.WriteLine("No solution"); } }
public AStarNode(Location location, INode parent, decimal costFromStart, decimal costToGoal) : base(location, parent) { CostFromStart = costFromStart; CostToGoal = costToGoal; }
public bool AttemptConnect(string host, string portStr) { try { var port = Int32.Parse(portStr); RemoteHost = NodeBuilder.BuildNode().Host(host).WithPort(port).WithTransportType(TransportType.Tcp); Connection = new ClientBootstrap() .SetTransport(TransportType.Tcp) .RemoteAddress(RemoteHost) .OnConnect(ConnectionEstablishedCallback) .OnReceive(ReceivedDataCallback) .OnDisconnect(ConnectionTerminatedCallback) .Build().NewConnection(NodeBuilder.BuildNode().Host(IPAddress.Any).WithPort(10001), RemoteHost); Connection.Open(); return true; } catch (Exception ex) { AppendStatusText(ex.Message); AppendStatusText(ex.StackTrace); AppendStatusText(ex.Source); return false; } }
public SearcherResult(DateTime startTimeStamp, INode resultNode, string path, SearchOptions searchOptions) { StartTimestamp = startTimeStamp; ResultNode = resultNode; Path = path; SearchOptions = searchOptions; }
readonly int selectedIndex; // the implementation that is bound public Subplan(INode n, int selectedIndex, InjectionPlan[] alternatives) : base(n) { this.alternatives = alternatives; if (selectedIndex < -1 || selectedIndex >= alternatives.Length) { Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IndexOutOfRangeException(), LOGGER); } this.selectedIndex = selectedIndex; if (selectedIndex != -1) { // one was bound this.numAlternatives = alternatives[selectedIndex].GetNumAlternatives(); } else { // no one was bound, but anyone could be used int numAlternatives = 0; foreach (InjectionPlan a in alternatives) { numAlternatives += a.GetNumAlternatives(); } this.numAlternatives = numAlternatives; } }
public QuickRemove(ToolStripMenuItem menu, IGraph g, INode objNode, String file) { this._menu = menu; this._g = g; this._objNode = objNode; this._file = file; }
protected override void LoadProperties(Content.IContentManager contentManager, INode node) { base.LoadProperties(contentManager, node); CirclePrimitive circlePrimitive = (CirclePrimitive)node; circlePrimitive.Radius = Radius; }
public Transition(string identifier, bool isDefault, INode source, INode destination) { IsDefault = isDefault; Source = source; Destination = destination; Identifier = identifier; }
internal static void Add(Identifier identifier, INode node) { if (_symbols.ContainsKey(identifier.Name)) _symbols[identifier.Name] = node; else _symbols.Add(identifier.Name, node); }
public void Run(INode typeDeclaration) { typeDeclaration.AcceptVisitor(this, null); foreach (VariableDeclaration decl in fields) { decl.Name = prefix + decl.Name; } }
public ImportSymbolSelectionDlg(INode[] nodes) { this.Build (); SetResponseSensitive(ResponseType.Ok, true); SetResponseSensitive(ResponseType.Cancel, true); buttonOk.GrabFocus(); Modal = true; WindowPosition = Gtk.WindowPosition.CenterOnParent; // Init name column var nameCol = new TreeViewColumn(); var textRenderer = new CellRendererText(); nameCol.PackStart(textRenderer, true); nameCol.AddAttribute(textRenderer, "text", 0); list.AppendColumn(nameCol); // Init list model var nodeStore = new ListStore(typeof(string),typeof(INode)); list.Model = nodeStore; // Fill list foreach (var n in nodes) if(n!=null) nodeStore.AppendValues(n.ToString(), n); // Select first result TreeIter iter; if(nodeStore.GetIterFirst(out iter)) list.Selection.SelectIter(iter); }
internal SetPropertyValueOperation(INode node, string name, object oldvalue, object newvalue) { this.node = node; this.name = name; this.oldvalue = oldvalue; this.newvalue = newvalue; }
/* Pushes a node on to the stack. */ internal virtual void pushNode(INode n) { System.Object temp_object; temp_object = n; System.Object generatedAux = temp_object; nodes.Push(temp_object); ++sp; }
public void OnFocusedNodeChanged(INode inode) { if (focusedNodeChanged != null) { focusedNodeChanged(this, inode); } }
//private List<MovieDictionaryItem> MoviesDictionary { get; set; } private void LookupMovieAtCinemas(INode cinemasNode, MovieDictionaryItem movieDictionaryItem) { foreach (INode cityNode in cinemasNode.ChildrenAsList) { var cityDictionary = new CityDictionaryItem(); cityDictionary.Cinemas = new List<CinemaDictionaryItem>(); cityDictionary.CityName = cityNode.Name; foreach (INode cinemaNode in cityNode.ChildrenAsList) { var cinema = ModelFactory.CreateModel<Cinema>(cinemaNode); foreach (var program in cinema.MoviePrograms) { if (program.MovieLink.NodeId == movieDictionaryItem.MovieNodeId) { cityDictionary.Cinemas.Add(new CinemaDictionaryItem() { Name = cinema.Name, NodeUrl = cinema.NodeUrl }); break; } } } if (cityDictionary.Cinemas.Count > 0) { if (movieDictionaryItem.Cities == null) movieDictionaryItem.Cities = new List<CityDictionaryItem>(); movieDictionaryItem.Cities.Add(cityDictionary); } } }
public XElement Format(INode contentNode, IEnumerable<INode> features) { var featureItemNode = contentNode as FeatureNode; if (featureItemNode != null) { var formattedContent = this.htmlFeatureFormatter.Format(featureItemNode.Feature); this.htmlImageRelocator.Relocate(contentNode, formattedContent); return formattedContent; } var indexItemNode = contentNode as FolderNode; if (indexItemNode != null) { return this.htmlIndexFormatter.Format(indexItemNode, features); } var markdownItemNode = contentNode as MarkdownNode; if (markdownItemNode != null) { this.htmlImageRelocator.Relocate(contentNode, markdownItemNode.MarkdownContent); return markdownItemNode.MarkdownContent; } throw new InvalidOperationException("Cannot format a FeatureNode with a Type of " + contentNode.GetType() + " as content"); }
////数字节点只能是叶子。 //public GeneralNode(double number_p) //{ // number = number_p; // left = right = null; // isNumber = true; // symbol = Esymbol.Nothing; // priority = Epriority.Nothing; //} //操作符节点初始化 public void SetUpNode(params object[] paras)//Esymbol symbol_p, INode left_p, INode right_p) { if (paras != null && paras.Length == 4) { if (paras[0] != null) { number = (double)paras[0]; isNumber = true; } else { isNumber = false; } left = (INode)paras[1]; right = (INode)paras[2]; if (paras[3] != null) { symbol = (Esymbol)paras[3]; } else { symbol = Esymbol.Nothing; } priority = this.SymbolInPriority(symbol); } else throw new Exception("Node初始化参数数量对!"); }
public LinkBehavior(XmlAttributeCollection collection) : base(collection) { fileNode = null; contextNode = null; typeNode = null; }
public IEnumerable<Triple> GetTriplesWithSubjectPredicate(INode subj, INode pred) { Document lookup = new Document(); lookup["graph.subject"] = this._formatter.Format(subj); lookup["graph.predicate"] = this._formatter.Format(pred); return new MongoDBGraphCentricEnumerable(this._manager, lookup, t => t.Subject.Equals(subj) && t.Predicate.Equals(pred)); }
public static string GetUriStringForNode(INode node) { if (node.IsEmpty()) return string.Empty; return string.Format("{0}://{1}:{2}", GetProtocolStringForTransportType(node.TransportType), GetHostStringForAddress(node.Host), node.Port); }
public override INode AddNode(INode currentParent, IConverter converter) { INode orNode = new OrNode(converter); //// First element of a chain //if (currentParent is RootNode) // throw new NotImplementedException("Or cannot be the first element"); // Insert at root if (currentParent is RootNode) { var root = (currentParent as RootNode); var firstChild = root.Children.First(); firstChild.Parent = orNode; (orNode as OrNode).Children.Add(firstChild); orNode.Parent = root; root.Children.Remove(firstChild); } // Insert before its parent else if (currentParent.Parent != null && currentParent.Parent as IMotherNode != null) { var grandParent = currentParent.Parent as IMotherNode; grandParent.Children.Remove(currentParent); (orNode as OrNode).Children.Add(currentParent); currentParent = currentParent.Parent; } this.LinkNodeToParent(currentParent, orNode); return orNode; }
public static string ToText(INode node) { var output = new CSharpOutputVisitor(); node.AcceptVisitor(output, null); return output.Text; }
INode INodeCreator.CreateNode(Session session, INode parent, string name, IEnumerable<Property> properties) { if (parent != null && parent.ChildNodes[name] != null) throw new InvalidOperationException("Duplicated Child Node Name"); return new Node(session, parent, name, properties, this.store); }
protected override void EndVisit(INode node) { if (node is PropertyGetRegion || node is PropertySetRegion) { this.currentContext = VisitorContext.Default; } base.EndVisit(node); }
public override bool DoMatch(INode other, Match match) { if (other == null || other.IsNull) return this.MinCount <= 0; else return this.MaxCount >= 1 && childNode.DoMatch(other, match); }
IExpressionNode CreateNode(INode node) { IExpressionNode expressionNode = null; if (node is ExpressionStatement) { var statementNode = (ExpressionStatement)node; expressionNode = new StatementExpressionNode { Expression = CreateNode(statementNode.Expression) }; } else if (node is BinaryOperatorExpression) { var binaryNode = ((BinaryOperatorExpression)node); expressionNode = new BinaryExpressionNode { Operator = (BinaryExpressionNode.Operators)binaryNode.Op, Left = CreateNode(binaryNode.Left), Right = CreateNode(binaryNode.Right), }; } else if (node is PrimitiveExpression) { var primitiveNode = (PrimitiveExpression)node; var valueType = primitiveNode.Value == null ? typeof(object) : primitiveNode.Value.GetType(); var value = (IValueNode)Activator.CreateInstance(typeof(ValueNode<>).MakeGenericType(valueType), primitiveNode.Value); expressionNode = new ValueExpressionNode { Value = value, }; } return expressionNode; }
public override INode AddNode(INode currentParent, IConverter converter) { //If the current parent is neither the root nor a group if(!(currentParent is IMotherNode)) throw new ArgumentException("Trying to insert an 'AS' node, but the current node's type '" + currentParent.GetType() + "' is illegal. " + CheckString); GroupNode group; //If the current parent is the root if (currentParent is RootNode) { group = (currentParent as IMotherNode).Children.Last() as GroupNode; if (group == null) throw new ArgumentException("Trying to insert an 'AS' node, but no Group found at root nor in its children. " + CheckString); } // The current parent is the group else if (currentParent is GroupNode) group = currentParent as GroupNode; // The group is the last child of the current parent else if ((currentParent as IMotherNode).Children.Last() is GroupNode) group = (currentParent as IMotherNode).Children.Last() as GroupNode; else throw new ArgumentException("Trying to insert an 'AS' node, but the current node is neither a group nor contains a group as children. " + CheckString); if (converter != null && converter.Function != null && converter.Function.Arguments != null && converter.Function.Arguments.Any()) group.Name = converter.Function.Arguments[0].ToString(); return currentParent; }
public static DomRegion DomRegion(this INode node) { return(new DomRegion(node.StartLocation.Line, node.StartLocation.Column, node.EndLocation.Line, node.EndLocation.Column)); }
public Task AddAsync(INode Child) { throw new NotSupportedException(); }
public Task <bool> AcceptsParentAsync(INode Parent) { return(Task.FromResult <bool>(false)); }
public Task <bool> AcceptsChildAsync(INode Child) { return(Task.FromResult <bool>(false)); }
public Task <bool> RemoveAsync(INode Child) { return(Task.FromResult <bool>(false)); }
protected override bool ValidateInternal(INode focusNode, IEnumerable <INode> valueNodes, Report report) { var invalidValues = QualifiedValueNodes(focusNode, valueNodes).Skip(NumericValue); return(ReportFocusNode(focusNode, invalidValues, report)); }
internal QualifiedMaxCount(Shape shape, INode node) : base(shape, node) { }
public void Visit(ElementNode node, INode parentNode) { var typeref = Module.ImportReference(node.XmlType.GetTypeReference(Module, node)); TypeDefinition typedef = typeref.ResolveCached(); if (IsXaml2009LanguagePrimitive(node)) { var vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(PushValueFromLanguagePrimitive(typedef, node)); Context.IL.Emit(Stloc, vardef); return; } //if this is a MarkupExtension that can be compiled directly, compile and returns the value var compiledMarkupExtensionName = typeref .GetCustomAttribute(Module, ("Xamarin.Forms.Core", "Xamarin.Forms.Xaml", "ProvideCompiledAttribute")) ?.ConstructorArguments?[0].Value as string; Type compiledMarkupExtensionType; ICompiledMarkupExtension markupProvider; if (compiledMarkupExtensionName != null && (compiledMarkupExtensionType = Type.GetType(compiledMarkupExtensionName)) != null && (markupProvider = Activator.CreateInstance(compiledMarkupExtensionType) as ICompiledMarkupExtension) != null) { var il = markupProvider.ProvideValue(node, Module, Context, out typeref); typeref = Module.ImportReference(typeref); var vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } node.CollectionItems.Clear(); Context.IL.Append(RegisterSourceInfo(Context, node)); return; } MethodDefinition factoryCtorInfo = null; MethodDefinition factoryMethodInfo = null; MethodDefinition parameterizedCtorInfo = null; MethodDefinition ctorInfo = null; if (node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod)) { factoryCtorInfo = typedef.AllMethods().FirstOrDefault(md => md.methodDef.IsConstructor && !md.methodDef.IsStatic && md.methodDef.HasParameters && md.methodDef.MatchXArguments(node, typeref, Module, Context)).methodDef; ctorInfo = factoryCtorInfo ?? throw new BuildException(BuildExceptionCode.ConstructorXArgsMissing, node, null, typedef.FullName); if (!typedef.IsValueType) //for ctor'ing typedefs, we first have to ldloca before the params { Context.IL.Append(PushCtorXArguments(factoryCtorInfo.ResolveGenericParameters(typeref, Module), node)); } } else if (node.Properties.ContainsKey(XmlName.xFactoryMethod)) { var factoryMethod = (string)(node.Properties[XmlName.xFactoryMethod] as ValueNode).Value; factoryMethodInfo = typedef.AllMethods().FirstOrDefault(md => !md.methodDef.IsConstructor && md.methodDef.Name == factoryMethod && md.methodDef.IsStatic && md.methodDef.MatchXArguments(node, typeref, Module, Context)).methodDef; if (factoryMethodInfo == null) { throw new BuildException(BuildExceptionCode.MethodStaticMissing, node, null, typedef.FullName, factoryMethod, null); } Context.IL.Append(PushCtorXArguments(factoryMethodInfo.ResolveGenericParameters(typeref, Module), node)); } if (ctorInfo == null && factoryMethodInfo == null) { parameterizedCtorInfo = typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.IsStatic && md.HasParameters && md.Parameters.All( pd => pd.CustomAttributes.Any( ca => ca.AttributeType.FullName == "Xamarin.Forms.ParameterAttribute"))); } string missingCtorParameter = null; if (parameterizedCtorInfo != null && ValidateCtorArguments(parameterizedCtorInfo, node, out missingCtorParameter)) { ctorInfo = parameterizedCtorInfo; // IL_0000: ldstr "foo" Context.IL.Append(PushCtorArguments(parameterizedCtorInfo.ResolveGenericParameters(typeref, Module), node)); } ctorInfo = ctorInfo ?? typedef.Methods.FirstOrDefault(md => md.IsConstructor && !md.HasParameters && !md.IsStatic); if (parameterizedCtorInfo != null && ctorInfo == null) { //there was a parameterized ctor, we didn't use it throw new BuildException(BuildExceptionCode.PropertyMissing, node, null, missingCtorParameter, typedef.FullName); } var ctorinforef = ctorInfo?.ResolveGenericParameters(typeref, Module); var factorymethodinforef = factoryMethodInfo?.ResolveGenericParameters(typeref, Module); var implicitOperatorref = typedef.Methods.FirstOrDefault(md => md.IsPublic && md.IsStatic && md.IsSpecialName && md.Name == "op_Implicit" && md.Parameters[0].ParameterType.FullName == "System.String"); if (!typedef.IsValueType && ctorInfo == null && factoryMethodInfo == null) { throw new BuildException(BuildExceptionCode.ConstructorDefaultMissing, node, null, typedef.FullName); } if (ctorinforef != null || factorymethodinforef != null || typedef.IsValueType) { VariableDefinition vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); ValueNode vnode = null; if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && vardef.VariableType.IsValueType) { //<Color>Purple</Color> Context.IL.Append(vnode.PushConvertedValue(Context, typeref, new ICustomAttributeProvider[] { typedef }, node.PushServiceProvider(Context), false, true)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (node.CollectionItems.Count == 1 && (vnode = node.CollectionItems.First() as ValueNode) != null && implicitOperatorref != null) { //<FileImageSource>path.png</FileImageSource> var implicitOperator = Module.ImportReference(implicitOperatorref); Context.IL.Emit(OpCodes.Ldstr, ((ValueNode)(node.CollectionItems.First())).Value as string); Context.IL.Emit(OpCodes.Call, implicitOperator); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (factorymethodinforef != null) { Context.IL.Emit(OpCodes.Call, Module.ImportReference(factorymethodinforef)); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (!typedef.IsValueType) { var ctor = Module.ImportReference(ctorinforef); // IL_0001: newobj instance void class [Xamarin.Forms.Core]Xamarin.Forms.Button::'.ctor'() // IL_0006: stloc.0 Context.IL.Emit(OpCodes.Newobj, ctor); Context.IL.Emit(OpCodes.Stloc, vardef); } else if (ctorInfo != null && node.Properties.ContainsKey(XmlName.xArguments) && !node.Properties.ContainsKey(XmlName.xFactoryMethod) && ctorInfo.MatchXArguments(node, typeref, Module, Context)) { // IL_0008: ldloca.s 1 // IL_000a: ldc.i4.1 // IL_000b: call instance void valuetype Test/Foo::'.ctor'(bool) var ctor = Module.ImportReference(ctorinforef); Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Append(PushCtorXArguments(ctor, node)); Context.IL.Emit(OpCodes.Call, ctor); } else { // IL_0000: ldloca.s 0 // IL_0002: initobj Test/Foo Context.IL.Emit(OpCodes.Ldloca, vardef); Context.IL.Emit(OpCodes.Initobj, Module.ImportReference(typedef)); } if (typeref.FullName == "Xamarin.Forms.Xaml.ArrayExtension") { var visitor = new SetPropertiesVisitor(Context); foreach (var cnode in node.Properties.Values.ToList()) { cnode.Accept(visitor, node); } foreach (var cnode in node.CollectionItems) { cnode.Accept(visitor, node); } markupProvider = new ArrayExtension(); var il = markupProvider.ProvideValue(node, Module, Context, out typeref); vardef = new VariableDefinition(typeref); Context.Variables[node] = vardef; Context.Body.Variables.Add(vardef); Context.IL.Append(il); Context.IL.Emit(OpCodes.Stloc, vardef); //clean the node as it has been fully exhausted foreach (var prop in node.Properties) { if (!node.SkipProperties.Contains(prop.Key)) { node.SkipProperties.Add(prop.Key); } } node.CollectionItems.Clear(); Context.IL.Append(RegisterSourceInfo(Context, node)); return; } Context.IL.Append(RegisterSourceInfo(Context, node)); } }
public void Visit(ValueNode node, INode parentNode) { Context.Values[node] = node.Value; }
public PostalAddress(INode node) : base(node) { }
public string GetName(INode node) { return(node.Name); }
public void Visit(MarkupNode node, INode parentNode) { //At this point, all MarkupNodes are expanded to ElementNodes }
public string GetTarget(INode node) { return(""); }
public bool SkipChildren(INode node, INode parentNode) => false;
public string Bind(INode node) { return(string.Format("<option value=\"{0}\">{1}</option>" + Environment.NewLine, node.Id, node.Name)); }
public string GetUrl(INode node) { return(""); }
public void JoinChildNode(INode a_nodeChild) { JoinChildNode(DEFAULT_OUTPUT_NAME, a_nodeChild); }
public bool IsOpen(INode node) { return(true); }
internal ArcroleReference(INode arcroleRefNode) : base(arcroleRefNode) { this.Uri = new Uri(arcroleRefNode.GetAttributeValue("arcroleURI")); }
private string getItemHtml(INode node, int depth) { return(string.Format("<div style='margin-left:{0}px;'>{1}</div>", (depth + 1) * 15, node.Name)); }
public bool hasProperty(INode property, INode value) { return(_model.ContainsTriple(_source, property, value)); }
public bool OnFrameReceived(ILink link, IFrame frame, INode parser) { var dev = link != null ? link.Device : parser; if (dev.Id == 2089) { STrace.Trace(typeof(DataLinkLayer).FullName, dev.Id, frame.PayloadAsString); } dev.LastPacketReceivedAt = DateTime.UtcNow; IMessage msg = null; // STrace.Debug(dev.GetType().FullName, dev.GetDeviceId(), "2Decode: " + frame.PayloadAsString); var sucess = dev.ExecuteOnGuard(() => msg = dev.Decode(frame), "Device decode", frame.PayloadAsString); if (!sucess) { return(false); } if (msg == null) { STrace.Debug(dev.GetType().FullName, dev.GetDeviceId(), String.Format("rx. {0}", Encoding.ASCII.GetString(frame.Payload))); return(false); } if (dev.ChecksCorrectIdFlag && (!ParserUtils.IsInvalidDeviceId(dev.GetDeviceId())) && (link != null) && (link.Device.GetDeviceId() != dev.GetDeviceId())) { STrace.Trace(dev.GetType().FullName, dev.GetDeviceId(), String.Format("Reporte ignorado por no coincidir Id Dispo: {0} con Id Link {1} Reporte: {2}", dev.GetDeviceId(), link.Device.GetDeviceId(), msg.GetPendingAsString())); return(false); } if (!msg.IsInvalidDeviceId()) //(!ParserUtils.IsInvalidDeviceId(dev.GetDeviceId())) { DataTransportLayer.DispatchMessage(dev, msg); } STrace.Debug(dev.GetType().FullName, dev.GetDeviceId(), String.Format("RX: '{0}'", Encoding.ASCII.GetString(frame.Payload))); if (!String.IsNullOrEmpty(msg.GetPendingAsString())) { STrace.Debug(dev.GetType().FullName, dev.GetDeviceId(), String.Format("TX: '{0}'", msg.GetPendingAsString())); } if (!String.IsNullOrEmpty(msg.GetPendingPostAsString())) { STrace.Debug(dev.GetType().FullName, dev.GetDeviceId(), String.Format("TX: '{0}'", msg.GetPendingPostAsString())); } var pending = msg.GetPending(); var pendingpost = msg.GetPendingPost(); if ((pending == null) && (pendingpost == null)) { return(false); } if (pending != null) { frame.Reuse(pending); if (pendingpost != null) { frame.PostSend(pendingpost); } } else { frame.Reuse(pendingpost); } return(true); }
public IEnumerable <Triple> listProperties(INode property) { return(_model.GetTriplesWithSubjectPredicate(_source, property)); }
public bool canAs(INode cls) { return(_model.ContainsTriple(_source, RDF.PropertyType, cls)); }
/// <see cref="BaseTreeCtrl.EnableMenuItems" /> protected override void EnableMenuItems(TreeNode clickedNode) { BrowseOptionsMI.Enabled = true; ShowReferencesMI.Enabled = true; SelectMI.Visible = m_allowPick; SelectSeparatorMI.Visible = m_allowPick; if (clickedNode != null) { // do nothing if an error is detected. if (m_browser.Session.KeepAliveStopped) { return; } SelectMI.Enabled = true; SelectItemMI.Enabled = true; SelectChildrenMI.Enabled = clickedNode.Nodes.Count > 0; BrowseRefreshMI.Enabled = true; ReferenceDescription reference = clickedNode.Tag as ReferenceDescription; if (reference != null) { BrowseMI.Enabled = (reference.NodeId != null && !reference.NodeId.IsAbsolute); ViewAttributesMI.Enabled = true; NodeId nodeId = ExpandedNodeId.ToNodeId(reference.NodeId, m_browser.Session.NamespaceUris); INode node = m_browser.Session.ReadNode(nodeId); byte accessLevel = 0; byte eventNotifier = 0; bool executable = false; VariableNode variableNode = node as VariableNode; if (variableNode != null) { accessLevel = variableNode.UserAccessLevel; } ObjectNode objectNode = node as ObjectNode; if (objectNode != null) { eventNotifier = objectNode.EventNotifier; } ViewNode viewNode = node as ViewNode; if (viewNode != null) { eventNotifier = viewNode.EventNotifier; } MethodNode methodNode = node as MethodNode; if (methodNode != null) { executable = methodNode.UserExecutable; } ReadMI.Visible = false; HistoryReadMI.Visible = false; WriteMI.Visible = false; HistoryUpdateMI.Visible = false; EncodingsMI.Visible = false; SubscribeMI.Visible = false; CallMI.Visible = false; if (accessLevel != 0) { ReadMI.Visible = true; HistoryReadMI.Visible = true; WriteMI.Visible = true; HistoryUpdateMI.Visible = true; EncodingsMI.Visible = true; SubscribeMI.Visible = m_SessionTreeCtrl != null; if ((accessLevel & (byte)AccessLevels.CurrentRead) != 0) { ReadMI.Enabled = true; EncodingsMI.Enabled = true; SubscribeMI.Enabled = true; SubscribeNewMI.Enabled = true; } if ((accessLevel & (byte)AccessLevels.CurrentWrite) != 0) { WriteMI.Enabled = true; EncodingsMI.Enabled = true; } if ((accessLevel & (byte)AccessLevels.HistoryRead) != 0) { HistoryReadMI.Enabled = true; } if ((accessLevel & (byte)AccessLevels.HistoryWrite) != 0) { HistoryUpdateMI.Enabled = true; } } if (eventNotifier != 0) { HistoryReadMI.Visible = true; HistoryUpdateMI.Visible = true; SubscribeMI.Visible = true; if ((eventNotifier & (byte)EventNotifiers.HistoryRead) != 0) { HistoryReadMI.Enabled = true; } if ((eventNotifier & (byte)EventNotifiers.HistoryWrite) != 0) { HistoryUpdateMI.Enabled = true; } SubscribeMI.Enabled = (eventNotifier & (byte)EventNotifiers.SubscribeToEvents) != 0; SubscribeNewMI.Enabled = SubscribeMI.Enabled; } if (methodNode != null) { CallMI.Visible = true; CallMI.Enabled = executable; } if (variableNode != null && EncodingsMI.Enabled) { ReferenceDescriptionCollection encodings = m_browser.Session.ReadAvailableEncodings(variableNode.NodeId); if (encodings.Count == 0) { EncodingsMI.Visible = false; } } if (SubscribeMI.Enabled) { while (SubscribeMI.DropDown.Items.Count > 1) { SubscribeMI.DropDown.Items.RemoveAt(SubscribeMI.DropDown.Items.Count - 1); } foreach (Subscription subscription in m_browser.Session.Subscriptions) { if (subscription.Created) { ToolStripItem item = SubscribeMI.DropDown.Items.Add(subscription.DisplayName); item.Click += new EventHandler(Subscription_Click); item.Tag = subscription; } } } } } }
public bool hasProperty(INode property) { return(_model.GetTriplesWithSubjectPredicate(_source, property).Any()); }
private (double weight, NodeDirection?Direction) ApplyWeightAndDirection(AStarNode nodeOne, INode nodeTwo) { var x1 = nodeOne.Row; var y1 = nodeOne.Col; var x2 = nodeTwo.Row; var y2 = nodeTwo.Col; if (x2 < x1 && y1 == y2) { switch (nodeOne.Direction) { case NodeDirection.Up: return(1, NodeDirection.Up); case NodeDirection.Right: return(2, NodeDirection.Up); case NodeDirection.Left: return(2, NodeDirection.Up); case NodeDirection.Down: return(3, NodeDirection.Up); } } else if (x2 > x1 && y1 == y2) { switch (nodeOne.Direction) { case NodeDirection.Up: return(3, NodeDirection.Down); case NodeDirection.Right: return(2, NodeDirection.Down); case NodeDirection.Left: return(2, NodeDirection.Down); case NodeDirection.Down: return(1, NodeDirection.Down); } } if (y2 < y1 && x1 == x2) { switch (nodeOne.Direction) { case NodeDirection.Up: return(2, NodeDirection.Left); case NodeDirection.Right: return(3, NodeDirection.Left); case NodeDirection.Left: return(1, NodeDirection.Left); case NodeDirection.Down: return(2, NodeDirection.Left); } } else if (y2 > y1 && x1 == x2) { switch (nodeOne.Direction) { case NodeDirection.Up: return(2, NodeDirection.Right); case NodeDirection.Right: return(1, NodeDirection.Right); case NodeDirection.Left: return(3, NodeDirection.Right); case NodeDirection.Down: return(2, NodeDirection.Right); } } return(default);
public IEnumerable <IResource> getObjects(INode property) { return(_model.GetTriplesWithSubjectPredicate(this, property).Select(t => Resource.Get(t.Object, _model))); }
public Comment(INode parent, string content) : base(parent) { this.content = content; }
protected override void VisitUnknownNode(INode node) { Range range = node.Range; throw CreateRewriteError(_module, node.Location.Start, $"'{_module.Content.Substring(range.Start, range.End - range.Start)}' is not supported currently."); }