internal static object ParseCommandId(ExtensionNode codon) { string id = codon.Id; if (id.StartsWith("@")) { return(id.Substring(1)); } return(id); /* Type enumType = null; * string typeName = id; * * int i = id.LastIndexOf ("."); * if (i != -1) * typeName = id.Substring (0,i); * * enumType = codon.Addin.GetType (typeName); * * if (enumType == null) * enumType = Type.GetType (typeName); * * if (enumType == null) * enumType = typeof(Command).Assembly.GetType (typeName); * * if (enumType == null || !enumType.IsEnum) * throw new InvalidOperationException ("Could not find an enum type for the command '" + id + "'."); * * try { * return Enum.Parse (enumType, id.Substring (i+1)); * } catch { * throw new InvalidOperationException ("Could not find an enum value for the command '" + id + "'."); * }*/ }
public void TestGetExtensionNode() { ExtensionNode writer = AddinManager.GetExtensionNode("/SimpleApp/Writers/HelloWorldExtension.HelloWorldWriter"); Assert.IsNotNull(writer, "t1"); Assert.IsTrue(writer is TypeExtensionNode, "t2"); Assert.AreEqual(0, writer.ChildNodes.Count, "t3"); Assert.IsNotNull(writer.Addin, "t3"); Assert.AreEqual("SimpleApp.HelloWorldExtension", writer.Addin.Id, "t4"); Assert.IsTrue(writer.HasId, "t5"); Assert.AreEqual("HelloWorldExtension.HelloWorldWriter", writer.Id, "t6"); Assert.AreEqual("/SimpleApp/Writers/HelloWorldExtension.HelloWorldWriter", writer.Path, "t7"); TypeExtensionNode tn = (TypeExtensionNode)writer; object ob = tn.CreateInstance() as IWriter; Assert.IsNotNull(ob, "t8"); ob = tn.CreateInstance(typeof(IWriter)) as IWriter; Assert.IsNotNull(ob, "t9"); try { ob = tn.CreateInstance(typeof(string)) as IWriter; } catch (InvalidOperationException) { } }
public void TestGetExtensionPointRootNode() { ExtensionNode node = AddinManager.GetExtensionNode("/SimpleApp/Writers"); Assert.IsNotNull(node, "root node is null"); Assert.AreEqual(4, node.ChildNodes.Count, "Node count"); }
protected override void OnChildNodeRemoved(ExtensionNode node) { PolicyResourceNode res = (PolicyResourceNode)node; polSet.RemoveAll(res.AddedKeys); base.OnChildNodeRemoved(node); }
private TExtension findReceiveBridge(ExtensionNode input) { //finds the extension that the receiveBridge belongs to TExtension result = null; int extensionCounter = 0; while (extensionCounter < this.terminal.extensionLength() && result == null) { int receiveCoutner = 0; while (receiveCoutner < this.terminal.extensionAt(extensionCounter).ReceiveNodes.Length&& result == null) { if (input.Equals(this.terminal.extensionAt(extensionCounter).ReceiveNodes[receiveCoutner])) { result = this.terminal.extensionAt(extensionCounter); } receiveCoutner++; } extensionCounter++; } return(result); }
public int StartApplication(string appId, string[] parameters) { ExtensionNode node = AddinManager.GetExtensionNode("/MonoDevelop/Core/Applications/" + appId); if (node == null) { throw new InstallException("Application not found: " + appId); } ApplicationExtensionNode apnode = node as ApplicationExtensionNode; if (apnode == null) { throw new Exception("Invalid node type"); } IApplication app = (IApplication)apnode.CreateInstance(); try { return(app.Run(parameters)); } catch (Exception ex) { Console.WriteLine(ex.Message); LoggingService.LogFatalError(ex.ToString()); return(-1); } }
/// <summary> /// Scan a single assembly for extensions marked by ExtensionAttribute. /// For each extension, create an ExtensionNode and link it to the /// correct ExtensionPoint. /// </summary> private void FindExtensionsInAssembly(string assemblyName) { var module = AssemblyDefinition.ReadAssembly(assemblyName).MainModule; foreach (var type in module.GetTypes()) { foreach (var attr in type.CustomAttributes) { if (attr.AttributeType.FullName == "NUnit.Engine.Extensibility.ExtensionAttribute") { var node = new ExtensionNode(assemblyName, type.FullName); foreach (var x in attr.Properties) { switch (x.Name) { case "Path": node.Path = x.Argument.Value as string; break; case "Description": node.Description = x.Argument.Value as string; break; } } _extensions.Add(node); ExtensionPoint ep; if (node.Path == null) { ep = DeduceExtensionPointFromType(type); if (ep == null) { string msg = string.Format( "Unable to deduce ExtensionPoint for Type {0}. Specify Path on ExtensionAttribute to resolve.", type.FullName); throw new NUnitEngineException(msg); } node.Path = ep.Path; } else { ep = GetExtensionPoint(node.Path); if (ep == null) { string msg = string.Format( "Unable to locate ExtensionPoint for Type {0}. The Path {1} cannot be found.", type.FullName, node.Path); throw new NUnitEngineException(msg); } } ep.Install(node); } } } }
protected override void Visit(ExtensionNode node) { Nodes.Add(node); PushFrame(new List <Node>(), new TFrameData()); Accept(node.Body); node.Body = Nodes; PopFrame(); }
protected override void OnChildNodeRemoved(ExtensionNode node) { PolicyResourceNode res = (PolicyResourceNode)node; using (System.IO.StreamReader reader = res.GetStream()) polSet.RemoveSerializedPolicies(reader); base.OnChildNodeRemoved(node); }
protected override void Visit(ExtensionNode node) { this.Nodes.Add(node); this.PushFrame(new List <Node>(), Activator.CreateInstance <TFrameData>()); base.Accept(node.Body); node.Body = this.Nodes; this.PopFrame(); }
public void TestGetUnknownExtensionNode() { ExtensionNode node = AddinManager.GetExtensionNode("/SimpleApp/Writers/Unknown"); Assert.IsNull(node, "t1"); node = AddinManager.GetExtensionNode("/SimpleApp/Writers/SomeFile/Unknown"); Assert.IsNull(node, "t2"); }
internal static object ParseCommandId(ExtensionNode codon) { string id = codon.Id; if (id.StartsWith("@")) { return((object)id.Substring(1)); } return((object)id); }
protected override void Visit(ExtensionNode extensionNode) { var extensionChunk = new ExtensionChunk { Extension = extensionNode.Extension, Position = Locate(extensionNode) }; Chunks.Add(extensionChunk); using (new Frame(this, extensionChunk.Body)) extensionNode.Extension.VisitNode(this, extensionNode.Body, Chunks); }
public bool removeSendBridge(ExtensionNode send) { bool result = this.sendNodes.Remove(send); if (result) { this.OnSendBridgeRemove?.Invoke(); } return(result); }
public bool removeReceiveBridge(ExtensionNode rec) { bool result = this.receiveNodes.Remove(rec); if (result) { this.OnReceiveBridgeRemove?.Invoke(); } return(result); }
protected override void Visit(ExtensionNode node) { ExtensionNode item = new ExtensionNode(node.Element, node.Extension); this.PushFrame(); this._frame.Nodes = item.Body; base.Accept(node.Body); this.PopFrame(); this.Nodes.Add(item); }
protected override void Visit(ExtensionNode extensionNode) { ExtensionChunk item = new ExtensionChunk { Extension = extensionNode.Extension, Position = this.Locate(extensionNode) }; this.Chunks.Add(item); using (new Frame(this, item.Body)) { extensionNode.Extension.VisitNode(this, extensionNode.Body, this.Chunks); } }
protected override void Visit(ExtensionNode node) { var reconstructed = new ExtensionNode(node.Element, node.Extension); PushFrame(); _frame.Nodes = reconstructed.Body; Accept(node.Body); PopFrame(); Nodes.Add(reconstructed); }
internal static object ParseCommandId(ExtensionNode codon) { string id = codon.Id; if (id.StartsWith("@", StringComparison.Ordinal)) { return(id.Substring(1)); } else { return(id); } }
protected override void Visit(ElementNode node) { if (this.IsContainingElement(node.Name, node.Namespace)) { this.PushSpecial(node); if (node.IsEmptyElement) { this.PopSpecial(node.Name); } } else if (this.IsNonContainingElement(node.Name, node.Namespace)) { this.PushSpecial(node); this.PopSpecial(node.Name); } else { ISparkExtension extension; if (this.TryCreateExtension(node, out extension)) { ExtensionNode item = new ExtensionNode(node, extension); this.Nodes.Add(item); if (!node.IsEmptyElement) { this._extensionNodes.Push(item); this._stack.Push(this.Nodes); this._nodes = item.Body; } } else if (this.IsPartialFileElement(node.Name, node.Namespace)) { List <AttributeNode> attributeNodes = new List <AttributeNode>(node.Attributes) { new AttributeNode("file", "_" + NameUtility.GetName(node.Name)) }; ElementNode element = new ElementNode("use", attributeNodes, node.IsEmptyElement) { OriginalNode = node }; this.PushSpecial(element); if (node.IsEmptyElement) { this.PopSpecial("use"); } } else { this.Add(node); } } }
public void TestInit() { var r = new ExtensionNode(); r.Key = "0a0c".HexToBytes(); var b = new BranchNode(); var l1 = new ExtensionNode(); l1.Key = new byte[] { 0x01 }; var l2 = new ExtensionNode(); l2.Key = new byte[] { 0x09 }; var v1 = new LeafNode(); v1.Value = "abcd".HexToBytes(); var v2 = new LeafNode(); v2.Value = "2222".HexToBytes(); var v3 = new LeafNode(); v3.Value = Encoding.ASCII.GetBytes("hello"); var h1 = new HashNode(); h1.Hash = v3.GetHash(); var l3 = new ExtensionNode(); l3.Next = h1; l3.Key = "0e".HexToBytes(); r.Next = b; b.Children[0] = l1; l1.Next = v1; b.Children[9] = l2; l2.Next = v2; b.Children[10] = l3; root = r; var store = new MemoryStore(); var db = new MPTDb(store); this.rootHash = root.GetHash(); db.Put(r); db.Put(b); db.Put(l1); db.Put(l2); db.Put(l3); db.Put(v1); db.Put(v2); db.Put(v3); this.mptdb = store; }
static void RemoveRule(ExtensionNode extNode) { if (extNode is CategoryNode) { foreach (ExtensionNode child in extNode.ChildNodes) { RemoveRule(child); } return; } var node = (AnalysisRuleAddinNode)extNode; rulesByInput.Remove(node.Input, node); }
public void TestGetProof() { var r = new ExtensionNode(); r.Key = "0a0c".HexToBytes(); var b = new BranchNode(); var l1 = new ExtensionNode(); l1.Key = new byte[] { 0x01 }; var l2 = new ExtensionNode(); l2.Key = new byte[] { 0x09 }; var v1 = new LeafNode(); v1.Value = "abcd".HexToBytes(); var v2 = new LeafNode(); v2.Value = "2222".HexToBytes(); var v3 = new LeafNode(); v3.Value = Encoding.ASCII.GetBytes("hello"); var h1 = new HashNode(); h1.Hash = v3.GetHash(); var l3 = new ExtensionNode(); l3.Next = h1; l3.Key = "0e".HexToBytes(); r.Next = b; b.Children[0] = l1; l1.Next = v1; b.Children[9] = l2; l2.Next = v2; b.Children[10] = l3; var mpt = new MPTTrie(rootHash, mptdb); Assert.AreEqual(r.GetHash().ToString(), mpt.GetRoot().ToString()); var result = mpt.GetProof("ac01".HexToBytes(), out HashSet <byte[]> proof); Assert.IsTrue(result); Assert.AreEqual(4, proof.Count); Assert.IsTrue(proof.Contains(b.Encode())); Assert.IsTrue(proof.Contains(r.Encode())); Assert.IsTrue(proof.Contains(l1.Encode())); Assert.IsTrue(proof.Contains(v1.Encode())); }
public bool CanLoadFrom(string path) { ExtensionNode node = GetNodeForPath(path); if (node != null) { var loader = node.ExtensionObject as IProjectLoader; if (loader.CanLoadFrom(path)) { return(true); } } return(false); }
public void TestDataExtensionWithAttribute() { ExtensionNodeList nodes = AddinManager.GetExtensionNodes("/SimpleApp/DataExtensionWithAttribute"); Assert.AreEqual(2, nodes.Count, "Node count"); ExtensionNode <SimpleExtensionAttribute> n1 = nodes [0] as ExtensionNode <SimpleExtensionAttribute>; ExtensionNode <SimpleExtensionAttribute> n2 = nodes [1] as ExtensionNode <SimpleExtensionAttribute>; Assert.IsNotNull(n1); Assert.IsNotNull(n2); Assert.AreEqual("test3", n1.Data.Name, "t1"); Assert.AreEqual(true, n1.Data.Value, "t2"); Assert.AreEqual("test4", n2.Data.Name, "t1"); Assert.AreEqual(false, n2.Data.Value, "t2"); }
private IProject LoadFrom(string path) { ExtensionNode node = GetNodeForPath(path); if (node != null) { var loader = node.ExtensionObject as IProjectLoader; if (loader.CanLoadFrom(path)) { return(loader.LoadFrom(path)); } } return(null); }
protected override void Visit(ElementNode node) { ISparkExtension extension; if (IsContainingElement(node.Name, node.Namespace)) { PushSpecial(node); if (node.IsEmptyElement) { PopSpecial(node.Name); } } else if (IsNonContainingElement(node.Name, node.Namespace)) { PushSpecial(node); PopSpecial(node.Name); } else if (TryCreateExtension(node, out extension)) { ExtensionNode extensionNode = new ExtensionNode(node, extension); Nodes.Add(extensionNode); if (!node.IsEmptyElement) { _extensionNodes.Push(extensionNode); _stack.Push(Nodes); _nodes = extensionNode.Body; } } else if (IsPartialFileElement(node.Name, node.Namespace)) { var attributes = new List <AttributeNode>(node.Attributes); attributes.Add(new AttributeNode("file", "_" + NameUtility.GetName(node.Name))); var useFile = new ElementNode("use", attributes, node.IsEmptyElement) { OriginalNode = node }; PushSpecial(useFile); if (node.IsEmptyElement) { PopSpecial("use"); } } else { Add(node); } }
public void TestExtensionWithChildren() { ExtensionNodeList nodes = AddinManager.GetExtensionNodes("/SimpleApp/NodeWithChildren"); Assert.AreEqual(2, nodes.Count, "Node count"); ExtensionNode n1 = nodes [0]; ExtensionNode n2 = nodes [1]; Assert.AreEqual("node1", n1.Id, "t1"); Assert.AreEqual(3, n1.ChildNodes.Count, "n1 node count"); Assert.AreEqual("child1", n1.ChildNodes[0].Id, "t1.1"); Assert.AreEqual("child1.1", n1.ChildNodes[1].Id, "t1.2"); Assert.AreEqual("child2", n1.ChildNodes[2].Id, "t1.3"); Assert.AreEqual("node2", n2.Id, "t2"); }
public void TestTryDelete() { var r1 = new ExtensionNode(); r1.Key = "0a0c0001".HexToBytes(); var r = new ExtensionNode(); r.Key = "0a0c".HexToBytes(); var b = new BranchNode(); r.Next = b; var l1 = new ExtensionNode(); l1.Key = new byte[] { 0x01 }; var v1 = new LeafNode(); v1.Value = "abcd".HexToBytes(); l1.Next = v1; b.Children[0] = l1; var l2 = new ExtensionNode(); l2.Key = new byte[] { 0x09 }; var v2 = new LeafNode(); v2.Value = "2222".HexToBytes(); l2.Next = v2; b.Children[9] = l2; r1.Next = v1; Assert.AreEqual("0xdea3ab46e9461e885ed7091c1e533e0a8030b248d39cbc638962394eaca0fbb3", r1.GetHash().ToString()); Assert.AreEqual("0x93e8e1ffe2f83dd92fca67330e273bcc811bf64b8f8d9d1b25d5e7366b47d60d", r.GetHash().ToString()); var mpt = new MPTTrie(rootHash, mptdb); var result = true; result = mpt.TryGet("ac99".HexToBytes(), out byte[] value); Assert.IsTrue(result); result = mpt.TryDelete("ac99".HexToBytes()); Assert.IsTrue(result); result = mpt.TryDelete("acae".HexToBytes()); Assert.IsTrue(result); Assert.AreEqual("0xdea3ab46e9461e885ed7091c1e533e0a8030b248d39cbc638962394eaca0fbb3", mpt.GetRoot().ToString()); }
static void AddRule(ExtensionNode extNode) { if (extNode is CategoryNode) { foreach (ExtensionNode child in extNode.ChildNodes) { AddRule(child); } return; } if (extNode is AnalysisRuleAddinNode) { var node = (AnalysisRuleAddinNode)extNode; rulesByInput.Add(node.Input, node); } }
public Addin Read(Assembly ass, string manifest) { var a = new Addin(); var xml = new XmlDocument(); xml.LoadXml(manifest); string ns = xml.DocumentElement.NamespaceURI; foreach (XmlNode c in xml.FirstChild.ChildNodes) { if (c.Name == "meta") { foreach (XmlNode meta in c.ChildNodes) { switch (meta.Name) { case "author": a.Author = meta.InnerText; break; case "version": a.Version = meta.InnerText; break; case "name": a.Name = meta.InnerText; break; case "icon": a.IconPath = meta.InnerText; break; } } } else if (c.Name == "extension") { var en = new ExtensionNode(); en.Path = c.Attributes["path"].Value; foreach (XmlNode cc in c.ChildNodes) { if (cc.Name == "command") { string cls = cc.Attributes["class"].Value.Replace("{namespace}", ns); en.Commands.Add(cls, Activator.CreateInstance(ass.GetType(cls))); } else { var ec = new ExtensionCommand { Name = cc.Name }; ec.atts = cc.Attributes; ec.reference = cc; en.Nodes.Add(ec); } } a.ExtensionNodes.Add(en); } else if (c.Name == "dependencies") { foreach (XmlNode dc in c.ChildNodes) { if (dc.Name == "dependency") { if (File.Exists(dc.Attributes["path"].Value)) { a.Dependencies.Add(File.ReadAllBytes(dc.Attributes["path"].Value)); } else { throw new AddinException( "Dependency '" + dc.Attributes["path"].Value + "' does not exist!"); } } } } } return a; }