public NodeDescriptor(HtmlNode node, NodeKind kind) { if (node == null) throw new ArgumentNullException(nameof(node)); Node = node; Kind = kind; }
/// <summary> /// create a new node /// </summary> public TreeNode(NodeKind kind, int LineNum,TokenType Type, int currentLevelNum, string Scope) : this() { this.NodeKind = kind; this.LineNum = LineNum; this.Type = Type; this.LevelNum = currentLevelNum; this.Scope = Scope; }
/// <summary> /// 产生普通节点 /// </summary> /// <param name="kind"></param> /// <param name="type"></param> /// <param name="tID"></param> /// <param name="Linenum"></param> /// <param name="scope"></param> public TreeNode(NodeKind kind, TokenType type, string name, int Linenum, string scope) : this() { this.NodeKind = kind; this.Type = type; this.Name = name; this.LineNum = Linenum; this.Scope = scope; }
public Node(NodeKind kind, Cursor cursor) { /** \note The node ids are 1-based to make it easier to detect errors. */ _id = _nodes.Count + 1; _nodes[_id] = this; _kind = kind; // Make a deep copy of the position so as to protect it from unwanted side-effects. _cursor = new Cursor(cursor); }
public Routine( NodeKind kind, Cursor cursor, SymbolDefinition name, Profile profile, Block block ) : base(kind, cursor, name) { _profile = profile; _profile.Above = this; _block = block; _block.Above = this; }
public string Get( string sourceText, NodeKind nodeKind = NodeKind.CompilationUnit, bool openCurlyOnNewLine = false, bool closeCurlyOnNewLine = false, bool preserveOriginalWhitespace = false, bool keepRedundantApiCalls = false, bool avoidUsingStatic = false) { string responseText = "Quoter is currently down for maintenance. Please check back later."; if (string.IsNullOrEmpty(sourceText)) { responseText = "Please specify the source text."; } else if (sourceText.Length > 2000) { responseText = "Only strings shorter than 2000 characters are supported; your input string is " + sourceText.Length + " characters long."; } else { try { var quoter = new Quoter { OpenParenthesisOnNewLine = openCurlyOnNewLine, ClosingParenthesisOnNewLine = closeCurlyOnNewLine, UseDefaultFormatting = !preserveOriginalWhitespace, RemoveRedundantModifyingCalls = !keepRedundantApiCalls, ShortenCodeWithUsingStatic = !avoidUsingStatic }; responseText = quoter.Quote(sourceText, nodeKind); } catch (Exception ex) { responseText = ex.ToString(); } } Response.Headers.Add("Cache-Control", new[] { "no-cache" }); Response.Headers.Add("Pragma", new[] { "no-cache" }); Response.Headers.Add("Expires", new[] { "-1" }); Response.Headers.Add("Access-Control-Allow-Origin", new[] { "*" }); Response.Headers.Add("Access-Control-Allow-Headers", new[] { "Content-Type" }); return responseText; }
public HttpResponseMessage Get( string sourceText, NodeKind nodeKind = NodeKind.CompilationUnit, bool openCurlyOnNewLine = false, bool closeCurlyOnNewLine = false, bool preserveOriginalWhitespace = false, bool keepRedundantApiCalls = false, bool avoidUsingStatic = false) { string responseText = "Quoter is currently down for maintenance. Please check back later."; if (string.IsNullOrEmpty(sourceText)) { responseText = "Please specify the source text."; } else if (sourceText.Length > 2000) { responseText = "Only strings shorter than 2000 characters are supported; your input string is " + sourceText.Length + " characters long."; } else { try { var quoter = new Quoter { OpenParenthesisOnNewLine = openCurlyOnNewLine, ClosingParenthesisOnNewLine = closeCurlyOnNewLine, UseDefaultFormatting = !preserveOriginalWhitespace, RemoveRedundantModifyingCalls = !keepRedundantApiCalls, ShortenCodeWithUsingStatic = !avoidUsingStatic }; responseText = quoter.Quote(sourceText, nodeKind); } catch (Exception ex) { responseText = ex.ToString(); } } responseText = HttpUtility.HtmlEncode(responseText); var response = new HttpResponseMessage(HttpStatusCode.OK); response.Content = new StringContent(responseText, Encoding.UTF8, "text/html"); return response; }
private static bool VerifyCanGetAttributes(NodeKind kind) { return(kind == NodeKind.Column || kind == NodeKind.LocalColumn || kind == NodeKind.PrimaryKey); }
public Node(NodeKind kind) { this.kind = kind; }
private void AddNodeFromGUI(NodeKind kind, float x, float y) { string nodeName = AssetBundleGraphSettings.DEFAULT_NODE_NAME[kind] + nodes.Where(node => node.Kind == kind).ToList().Count; NodeGUI newNode = new NodeGUI(new NodeData(nodeName, kind, x, y)); Undo.RecordObject(this, "Add " + AssetBundleGraphSettings.DEFAULT_NODE_NAME[kind] + " Node"); AddNodeGUI(newNode); }
public CssDeclaration(string name, CssValue value, NodeKind kind) : base(kind) { Info = CssProperty.Get(name); Value = value; }
public Identity(SyntaxReference reference, Compilation compilation, NodeKind kind, Frame frame = null, string manualIdentifier = null) : this(reference.GetSymbol(compilation), kind, frame, manualIdentifier) { }
/* * Create NodeData from JSON */ public NodeData(Dictionary<string, object> jsonData) { m_name = jsonData[NODE_NAME] as string; m_id = jsonData[NODE_ID]as string; m_kind = AssetBundleGraphSettings.NodeKindFromString(jsonData[NODE_KIND] as string); var pos = jsonData[NODE_POS] as Dictionary<string, object>; m_x = (float)Convert.ToDouble(pos[NODE_POS_X]); m_y = (float)Convert.ToDouble(pos[NODE_POS_Y]); var inputs = jsonData[NODE_INPUTPOINTS] as List<object>; var outputs = jsonData[NODE_OUTPUTPOINTS] as List<object>; m_inputPoints = new List<ConnectionPointData>(); m_outputPoints = new List<ConnectionPointData>(); foreach(var obj in inputs) { var pDic = obj as Dictionary<string, object>; m_inputPoints.Add(new ConnectionPointData(pDic, this, true)); } foreach(var obj in outputs) { var pDic = obj as Dictionary<string, object>; m_outputPoints.Add(new ConnectionPointData(pDic, this, false)); } switch (m_kind) { case NodeKind.IMPORTSETTING_GUI: // nothing to do break; case NodeKind.PREFABBUILDER_GUI: case NodeKind.MODIFIER_GUI: { if(jsonData.ContainsKey(NODE_SCRIPT_CLASSNAME)) { m_scriptClassName = jsonData[NODE_SCRIPT_CLASSNAME] as string; } if(jsonData.ContainsKey(NODE_SCRIPT_INSTANCE_DATA)) { m_scriptInstanceData = new SerializableMultiTargetString(jsonData[NODE_SCRIPT_INSTANCE_DATA] as Dictionary<string, object>); } } break; case NodeKind.LOADER_GUI: { m_loaderLoadPath = new SerializableMultiTargetString(jsonData[NODE_LOADER_LOAD_PATH] as Dictionary<string, object>); } break; case NodeKind.FILTER_GUI: { var filters = jsonData[NODE_FILTER] as List<object>; m_filter = new List<FilterEntry>(); for(int i=0; i<filters.Count; ++i) { var f = filters[i] as Dictionary<string, object>; var keyword = f[NODE_FILTER_KEYWORD] as string; var keytype = f[NODE_FILTER_KEYTYPE] as string; var pointId = f[NODE_FILTER_POINTID] as string; var point = m_outputPoints.Find(p => p.Id == pointId); UnityEngine.Assertions.Assert.IsNotNull(point, "Output point not found for " + keyword); m_filter.Add(new FilterEntry(keyword, keytype, point)); } } break; case NodeKind.GROUPING_GUI: { m_groupingKeyword = new SerializableMultiTargetString(jsonData[NODE_GROUPING_KEYWORD] as Dictionary<string, object>); } break; case NodeKind.BUNDLECONFIG_GUI: { m_bundleConfigBundleNameTemplate = new SerializableMultiTargetString(jsonData[NODE_BUNDLECONFIG_BUNDLENAME_TEMPLATE] as Dictionary<string, object>); m_variants = new List<Variant>(); if(jsonData.ContainsKey(NODE_BUNDLECONFIG_VARIANTS)){ var variants = jsonData[NODE_BUNDLECONFIG_VARIANTS] as List<object>; for(int i=0; i<variants.Count; ++i) { var v = variants[i] as Dictionary<string, object>; var name = v[NODE_BUNDLECONFIG_VARIANTS_NAME] as string; var pointId = v[NODE_BUNDLECONFIG_VARIANTS_POINTID] as string; var point = m_inputPoints.Find(p => p.Id == pointId); UnityEngine.Assertions.Assert.IsNotNull(point, "Input point not found for " + name); m_variants.Add(new Variant(name, point)); } } } break; case NodeKind.BUNDLEBUILDER_GUI: { m_bundleBuilderEnabledBundleOptions = new SerializableMultiTargetInt(jsonData[NODE_BUNDLEBUILDER_ENABLEDBUNDLEOPTIONS] as Dictionary<string, object>); } break; case NodeKind.EXPORTER_GUI: { m_exporterExportPath = new SerializableMultiTargetString(jsonData[NODE_EXPORTER_EXPORT_PATH] as Dictionary<string, object>); } break; default: throw new ArgumentOutOfRangeException (); } }
public AssignmentNode(NodeKind kind, SyntaxTreeNode syntaxTreeNode, string contentPart) : base(kind, syntaxTreeNode, contentPart) { }
private IEnumerable<int> LeftBoundaryNodesOfANode(int i, NodeKind nodeKind) { return FillLeftTopAndBottomVerts(NodeLayer(i), layerArrays.X[i], nodeKind); }
public static bool Has(this NodeKind @this, NodeKind nodeKind) { return (@this & nodeKind) == nodeKind; }
public void KindIsCorrect(string text, NodeKind kind) { Assert.Equal(kind, CssUnitInfo.Get(text).Kind); }
public Marker(NodeKind nodeKind, ISymbol symbol, string name, bool navigationSuggested) : this(nodeKind, symbol.ContainingType.GetFullyQualifiedMetadataName(), name, navigationSuggested, false) { }
public Node(NodeKind kind, T nodeInfo = default(T)) { NodeKind = kind; NodeInfo = nodeInfo; }
private static string ConvertValue(object value, out NodeKind kind) { if (value == null) { kind = NodeKind.Null; return(""); } string val; #if DATETIME_AS_TIMESTAMPS // convert dates to unix timestamps if (value.GetType() == typeof(DateTime)) { val = ToTimestamp(((DateTime)value)).ToString(); kind = NodeKind.Numeric; } else #endif if (value is int) { val = ((int)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is uint) { val = ((uint)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is long) { val = ((long)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is ulong) { val = ((ulong)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is byte) { val = ((byte)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is sbyte) { val = ((sbyte)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is short) { val = ((short)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is ushort) { val = ((ushort)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is float) { val = ((float)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is double) { val = ((double)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is decimal) { val = ((decimal)value).ToString(CultureInfo.InvariantCulture); kind = NodeKind.Numeric; } else if (value is bool) { val = ((bool)value) ? "true" : "false"; kind = NodeKind.Boolean; } else { val = value.ToString(); kind = NodeKind.String; } return(val); }
public Node(AstNode astNode, NodeKind kind) { AstNode = astNode; Kind = kind; ContainingStatement = astNode.GetParent <Statement>(); }
public Node(string n, NodeKind k, AttributeList a) { Name = n; Kind = k; Attributes = a; }
IEnumerable<int> FillRightTopAndBottomVerts(int[] layer, int vPosition, NodeKind nodeKind) { double t = 0, b = 0; if (nodeKind == NodeKind.Bottom) { b = Single.MaxValue;//we don't have bottom boundaries here since they will be cut off } else if (nodeKind == NodeKind.Top) { t = Single.MaxValue;//we don't have top boundaries here since they will be cut off } int v = layer[vPosition]; for (int i = vPosition + 1; i < layer.Length; i++) { int u = layer[i]; Anchor anchor = this.anchors[u]; if (anchor.TopAnchor > t) { if (!NodeUCanBeCrossedByNodeV(u, v)) { t = anchor.TopAnchor; if (anchor.BottomAnchor > b) b = anchor.BottomAnchor; yield return u; } } else if (anchor.BottomAnchor > b) { if (!NodeUCanBeCrossedByNodeV(u, v)) { b = anchor.BottomAnchor; if (anchor.TopAnchor > t) t = anchor.TopAnchor; yield return u; } } } }
private void ParseOutput() { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.LoadXml(_outputBuffer.ToString()); XmlNode entryNode = xmlDoc.SelectSingleNode("/info/entry"); if (entryNode == null) return; string foundValue; foundValue = getAttributeValue(entryNode, "revision"); if (!String.IsNullOrEmpty(foundValue)) { Revision = Int32.Parse(foundValue); } foundValue = getAttributeValue(entryNode, "kind"); if (!String.IsNullOrEmpty(foundValue)) { if (foundValue == Subversion.NodeKind.dir.ToString()) { m_eNodeKind = Subversion.NodeKind.dir; } else if (foundValue == Subversion.NodeKind.file.ToString()) { m_eNodeKind = Subversion.NodeKind.file; } else { Log.LogError("Unknown node kind: " + foundValue); } } string nodeText; nodeText = getNodeText(entryNode, "url"); if (!String.IsNullOrEmpty(nodeText)) { RepositoryPath = nodeText; } nodeText = getNodeText(entryNode, "repository/root"); if (!String.IsNullOrEmpty(nodeText)) { m_strRepositoryRoot = nodeText; } nodeText = getNodeText(entryNode, "repository/uuid"); if (!String.IsNullOrEmpty(nodeText)) { m_Guid = new Guid(nodeText); } XmlNode childNode; childNode = entryNode.SelectSingleNode("commit"); if (childNode != null) { foundValue = getAttributeValue(childNode, "revision"); if (!String.IsNullOrEmpty(foundValue)) { m_nLastChangedRev = Int32.Parse(foundValue); } nodeText = getNodeText(childNode, "author"); if (!String.IsNullOrEmpty(nodeText)) { m_strLastChangedAuthor = nodeText; } nodeText = getNodeText(childNode, "date"); if (!String.IsNullOrEmpty(nodeText)) { m_LastChangedDate = DateTime.Parse(nodeText); } } nodeText = getNodeText(entryNode, "wc-info/schedule"); if (!String.IsNullOrEmpty(nodeText)) { if (nodeText == Subversion.Schedule.normal.ToString()) { m_eSchedule = Subversion.Schedule.normal; } else { Log.LogError("Unknown schedule: " + nodeText); } } }
public StatementFactory Kind(NodeKind kind) { this.kind = kind; return(this); }
/// <summary> /// Reset all instance variables to their default (unset) state. /// </summary> private void ResetMemberVariables() { RepositoryPath = string.Empty; m_strRepositoryRoot = string.Empty; m_Guid = Guid.Empty; m_eNodeKind = Subversion.NodeKind.unknown; m_strLastChangedAuthor = string.Empty; m_nLastChangedRev = 0; m_LastChangedDate = DateTime.Now; m_eSchedule = Subversion.Schedule.unknown; }
public Reference(NodeKind kind, Cursor cursor, string symbol) : base(kind, cursor) { _symbol = symbol; }
private SyntaxKind GetBinaryExpressionKind(NodeKind nodeKind) { switch (nodeKind) { case NodeKind.PlusToken: return(SyntaxKind.AddExpression); case NodeKind.MinusToken: return(SyntaxKind.SubtractExpression); case NodeKind.AsteriskToken: return(SyntaxKind.MultiplyExpression); case NodeKind.SlashToken: return(SyntaxKind.DivideExpression); case NodeKind.PercentToken: return(SyntaxKind.ModuloExpression); case NodeKind.LessThanLessThanToken: return(SyntaxKind.LeftShiftExpression); case NodeKind.GreaterThanGreaterThanToken: case NodeKind.GreaterThanGreaterThanGreaterThanToken: return(SyntaxKind.RightShiftExpression); case NodeKind.BarBarToken: return(SyntaxKind.LogicalOrExpression); case NodeKind.AmpersandAmpersandToken: return(SyntaxKind.LogicalAndExpression); case NodeKind.BarToken: return(SyntaxKind.BitwiseOrExpression); case NodeKind.AmpersandToken: return(SyntaxKind.BitwiseAndExpression); case NodeKind.CaretToken: return(SyntaxKind.ExclusiveOrExpression); case NodeKind.EqualsEqualsToken: case NodeKind.EqualsEqualsEqualsToken: return(SyntaxKind.EqualsExpression); case NodeKind.ExclamationEqualsToken: case NodeKind.ExclamationEqualsEqualsToken: return(SyntaxKind.NotEqualsExpression); case NodeKind.LessThanToken: return(SyntaxKind.LessThanExpression); case NodeKind.LessThanEqualsToken: return(SyntaxKind.LessThanOrEqualExpression); case NodeKind.GreaterThanToken: return(SyntaxKind.GreaterThanExpression); case NodeKind.GreaterThanEqualsToken: return(SyntaxKind.GreaterThanOrEqualExpression); case NodeKind.InstanceOfKeyword: case NodeKind.IsKeyword: return(SyntaxKind.IsExpression); case NodeKind.AsKeyword: return(SyntaxKind.AsExpression); //case NodeKind.QuestionQuestionToken: // return SyntaxKind.CoalesceExpression; default: return(SyntaxKind.None); } //InKeyword in //LessThanSlashToken </ //EqualsGreaterThanToken => //AsteriskAsteriskToken ** //PlusPlusToken ++ //MinusMinusToken -- //GreaterThanGreaterThanGreaterThanToken >>> //ExclamationToken ^ //TildeToken ~ //QuestionToken ? //ColonToken : //AtToken @ }
/// <summary> /// Given the input C# code <paramref name="sourceText"/> returns the C# source code of /// Roslyn API calls that recreate the syntax tree for the input code. /// </summary> /// <param name="sourceText">A C# souce text</param> /// <param name="nodeKind">What kind of C# syntax node should the input be parsed as</param> /// <returns>A C# expression that describes calls to the Roslyn syntax API necessary to recreate /// the syntax tree for the source text.</returns> public string Quote(string sourceText, NodeKind nodeKind) { return Quote(Parse(sourceText, nodeKind)); }
private BoundBinaryOperator(NodeKind nodeKind, BoundBinaryOperatorKind kind, Type operandType, Type resultType) : this(nodeKind, kind, operandType, operandType, resultType) { }
public Node (AstNode astNode, NodeKind kind) { AstNode = astNode; Kind = kind; ContainingStatement = astNode.GetParent<Statement> (); }
private BoundBinaryOperator(NodeKind nodeKind, BoundBinaryOperatorKind kind, Type type) : this(nodeKind, kind, type, type, type) { }
public CssUnit(string name, NodeKind kind) { Name = name; Kind = kind; }
public TypeNode(NodeKind kind) : base(kind) { }
internal CssUnitInfo(string name, NodeKind kind, CssUnitFlags flags = CssUnitFlags.None) { Name = name; Kind = kind; Flags = flags; }
public CssRule(RuleType type, NodeKind kind) : base(kind) { Type = type; }
public Op(TokenKind tokenKind, NodeKind nodeKind) { this.tokenKind = tokenKind; this.nodeKind = nodeKind; }
public static INavigatableMarker CreateNavigatableMarker(NodeKind nodeKind, ISymbol containingType, string symbolName, bool navigationSuggested = true) { return(SymbolNodeBase.CreateMarker(nodeKind, containingType, symbolName, navigationSuggested)); }
public ErrorNodeSuggestionHandlerBase(NodeKind kind) : base(kind) { }
/// <summary> /// Constructs an <see cref="NpgsqlTsQuery"/>. /// </summary> /// <param name="kind"></param> protected NpgsqlTsQuery(NodeKind kind) => Kind = kind;
IEnumerable<int> FillLeftTopAndBottomVerts(int[] layer, int vPosition, NodeKind nodeKind) { double t = 0, b = 0; if (nodeKind == NodeKind.Top) t = Single.MaxValue; //there are no top vertices - they are cut down by the top boundaryCurve curve else if (nodeKind == NodeKind.Bottom) b = Single.MaxValue; //there are no bottom vertices - they are cut down by the top boundaryCurve curve int v = layer[vPosition]; for (int i = vPosition - 1; i >= 0; i--) { int u = layer[i]; Anchor anchor = this.anchors[u]; if (anchor.TopAnchor > t + ApproximateComparer.DistanceEpsilon) { if (!NodeUCanBeCrossedByNodeV(u, v)) { t = anchor.TopAnchor; b = Math.Max(b, anchor.BottomAnchor); yield return u; } } else if (anchor.BottomAnchor > b + ApproximateComparer.DistanceEpsilon) { if (!NodeUCanBeCrossedByNodeV(u, v)) { t = Math.Max(t, anchor.TopAnchor); b = anchor.BottomAnchor; yield return u; } } } }
private IEnumerable <int> LeftBoundaryNodesOfANode(int i, NodeKind nodeKind) { return(FillLeftTopAndBottomVerts(NodeLayer(i), layerArrays.X[i], nodeKind)); }
public ExpressionParseResultBuilderFactory StatementKind(NodeKind kind) { this.statementKind = kind; return(this); }
/// <summary> /// Given the input C# code <paramref name="sourceText"/> returns the C# source code of /// Roslyn API calls that recreate the syntax tree for the input code. /// </summary> /// <param name="sourceText">A C# souce text</param> /// <param name="nodeKind">What kind of C# syntax node should the input be parsed as</param> /// <returns>A C# expression that describes calls to the Roslyn syntax API necessary to recreate /// the syntax tree for the source text.</returns> public string Quote(string sourceText, NodeKind nodeKind) { return(Quote(Parse(sourceText, nodeKind))); }
public IActionResult Get( string sourceText, NodeKind nodeKind = NodeKind.CompilationUnit, bool openCurlyOnNewLine = false, bool closeCurlyOnNewLine = false, bool preserveOriginalWhitespace = false, bool keepRedundantApiCalls = false, bool avoidUsingStatic = false, bool generateLINQPad = false) { string prefix = null; string responseText = "Quoter is currently down for maintenance. Please check back later."; if (string.IsNullOrEmpty(sourceText)) { responseText = "Please specify the source text."; } else if (sourceText.Length > 2000) { responseText = "Only strings shorter than 2000 characters are supported; your input string is " + sourceText.Length + " characters long."; } else { try { var quoter = new Quoter { OpenParenthesisOnNewLine = openCurlyOnNewLine, ClosingParenthesisOnNewLine = closeCurlyOnNewLine, UseDefaultFormatting = !preserveOriginalWhitespace, RemoveRedundantModifyingCalls = !keepRedundantApiCalls, ShortenCodeWithUsingStatic = !avoidUsingStatic }; responseText = quoter.QuoteText(sourceText, nodeKind); } catch (Exception ex) { responseText = ex.ToString(); prefix = "Congratulations! You've found a bug in Quoter! Please open an issue at <a href=\"https://github.com/KirillOsenkov/RoslynQuoter/issues/new\" target=\"_blank\">https://github.com/KirillOsenkov/RoslynQuoter/issues/new</a> and paste the code you've typed above and this stack:"; } } if (generateLINQPad) { var linqpadFile = $@"<Query Kind=""Expression""> <NuGetReference>Microsoft.CodeAnalysis.Compilers</NuGetReference> <NuGetReference>Microsoft.CodeAnalysis.CSharp</NuGetReference> <Namespace>static Microsoft.CodeAnalysis.CSharp.SyntaxFactory</Namespace> <Namespace>Microsoft.CodeAnalysis.CSharp.Syntax</Namespace> <Namespace>Microsoft.CodeAnalysis.CSharp</Namespace> <Namespace>Microsoft.CodeAnalysis</Namespace> </Query> {responseText} "; var responseBytes = Encoding.UTF8.GetBytes(linqpadFile); return(File(responseBytes, "application/octet-stream", "Quoter.linq")); } responseText = HttpUtility.HtmlEncode(responseText); if (prefix != null) { responseText = "<div class=\"error\"><p>" + prefix + "</p><p>" + responseText + "</p><p><br/>P.S. Sorry!</p></div>"; } return(Ok(responseText)); }
public Node(NodeKind kind, long index) : this(kind, PayloadKind.Index) { indexPayload = index; }
public Node FindAbove(NodeKind kind) { Node first = this; while (first != null) { if (first.Kind == kind) return first; first = first.Above; } throw new System.Exception("Search for " + kind.ToString() + " node failed"); }
public Definition(NodeKind kind, Cursor cursor, SymbolDefinition name) : base(kind, cursor) { _name = name; _name.Above = this; }
public CssValue(NodeKind kind) : base(kind) { }
/* * Create NodeData from JSON */ public NodeData(Dictionary <string, object> jsonData) { m_name = jsonData[NODE_NAME] as string; m_id = jsonData[NODE_ID] as string; m_kind = AssetBundleGraphSettings.NodeKindFromString(jsonData[NODE_KIND] as string); var pos = jsonData[NODE_POS] as Dictionary <string, object>; m_x = (float)Convert.ToDouble(pos[NODE_POS_X]); m_y = (float)Convert.ToDouble(pos[NODE_POS_Y]); var inputs = jsonData[NODE_INPUTPOINTS] as List <object>; var outputs = jsonData[NODE_OUTPUTPOINTS] as List <object>; m_inputPoints = new List <ConnectionPointData>(); m_outputPoints = new List <ConnectionPointData>(); foreach (var obj in inputs) { var pDic = obj as Dictionary <string, object>; m_inputPoints.Add(new ConnectionPointData(pDic, this, true)); } foreach (var obj in outputs) { var pDic = obj as Dictionary <string, object>; m_outputPoints.Add(new ConnectionPointData(pDic, this, false)); } switch (m_kind) { case NodeKind.IMPORTSETTING_GUI: // nothing to do break; case NodeKind.PREFABBUILDER_GUI: case NodeKind.MODIFIER_GUI: { if (jsonData.ContainsKey(NODE_SCRIPT_CLASSNAME)) { m_scriptClassName = jsonData[NODE_SCRIPT_CLASSNAME] as string; } if (jsonData.ContainsKey(NODE_SCRIPT_INSTANCE_DATA)) { m_scriptInstanceData = new SerializableMultiTargetString(_SafeGet(jsonData, NODE_SCRIPT_INSTANCE_DATA)); } } break; case NodeKind.LOADER_GUI: { m_loaderLoadPath = new SerializableMultiTargetString(_SafeGet(jsonData, NODE_LOADER_LOAD_PATH)); } break; case NodeKind.FILTER_GUI: { var filters = jsonData[NODE_FILTER] as List <object>; m_filter = new List <FilterEntry>(); for (int i = 0; i < filters.Count; ++i) { var f = filters[i] as Dictionary <string, object>; var keyword = f[NODE_FILTER_KEYWORD] as string; var keytype = f[NODE_FILTER_KEYTYPE] as string; var pointId = f[NODE_FILTER_POINTID] as string; var point = m_outputPoints.Find(p => p.Id == pointId); UnityEngine.Assertions.Assert.IsNotNull(point, "Output point not found for " + keyword); m_filter.Add(new FilterEntry(keyword, keytype, point)); } } break; case NodeKind.GROUPING_GUI: { m_groupingKeyword = new SerializableMultiTargetString(_SafeGet(jsonData, NODE_GROUPING_KEYWORD)); } break; case NodeKind.BUNDLECONFIG_GUI: { m_bundleConfigBundleNameTemplate = new SerializableMultiTargetString(_SafeGet(jsonData, NODE_BUNDLECONFIG_BUNDLENAME_TEMPLATE)); if (jsonData.ContainsKey(NODE_BUNDLECONFIG_USE_GROUPASVARIANTS)) { m_bundleConfigUseGroupAsVariants = Convert.ToBoolean(jsonData[NODE_BUNDLECONFIG_USE_GROUPASVARIANTS]); } m_variants = new List <Variant>(); if (jsonData.ContainsKey(NODE_BUNDLECONFIG_VARIANTS)) { var variants = jsonData[NODE_BUNDLECONFIG_VARIANTS] as List <object>; for (int i = 0; i < variants.Count; ++i) { var v = variants[i] as Dictionary <string, object>; var name = v[NODE_BUNDLECONFIG_VARIANTS_NAME] as string; var pointId = v[NODE_BUNDLECONFIG_VARIANTS_POINTID] as string; var point = m_inputPoints.Find(p => p.Id == pointId); UnityEngine.Assertions.Assert.IsNotNull(point, "Input point not found for " + name); m_variants.Add(new Variant(name, point)); } } } break; case NodeKind.BUNDLEBUILDER_GUI: { m_bundleBuilderEnabledBundleOptions = new SerializableMultiTargetInt(_SafeGet(jsonData, NODE_BUNDLEBUILDER_ENABLEDBUNDLEOPTIONS)); } break; case NodeKind.EXPORTER_GUI: { m_exporterExportPath = new SerializableMultiTargetString(_SafeGet(jsonData, NODE_EXPORTER_EXPORT_PATH)); m_exporterExportOption = new SerializableMultiTargetInt(_SafeGet(jsonData, NODE_EXPORTER_EXPORT_OPTION)); } break; default: throw new ArgumentOutOfRangeException(); } }
/* * Constructor used to create new node from GUI */ public NodeData(string name, NodeKind kind, float x, float y) { m_id = Guid.NewGuid().ToString(); m_name = name; m_x = x; m_y = y; m_kind = kind; m_inputPoints = new List<ConnectionPointData>(); m_outputPoints = new List<ConnectionPointData>(); // adding defalut input point. // Loader does not take input if(kind != NodeKind.LOADER_GUI) { m_inputPoints.Add(new ConnectionPointData(AssetBundleGraphSettings.DEFAULT_INPUTPOINT_LABEL, this, true)); } // adding default output point. // Filter and Exporter does not have output. if(kind != NodeKind.FILTER_GUI && kind != NodeKind.EXPORTER_GUI) { m_outputPoints.Add(new ConnectionPointData(AssetBundleGraphSettings.DEFAULT_OUTPUTPOINT_LABEL, this, false)); } switch(m_kind) { case NodeKind.PREFABBUILDER_GUI: case NodeKind.MODIFIER_GUI: m_scriptClassName = String.Empty; m_scriptInstanceData = new SerializableMultiTargetString(); break; case NodeKind.IMPORTSETTING_GUI: break; case NodeKind.FILTER_GUI: m_filter = new List<FilterEntry>(); break; case NodeKind.LOADER_GUI: m_loaderLoadPath = new SerializableMultiTargetString(); break; case NodeKind.GROUPING_GUI: m_groupingKeyword = new SerializableMultiTargetString(AssetBundleGraphSettings.GROUPING_KEYWORD_DEFAULT); break; case NodeKind.BUNDLECONFIG_GUI: m_bundleConfigBundleNameTemplate = new SerializableMultiTargetString(AssetBundleGraphSettings.BUNDLECONFIG_BUNDLENAME_TEMPLATE_DEFAULT); m_variants = new List<Variant>(); break; case NodeKind.BUNDLEBUILDER_GUI: m_bundleBuilderEnabledBundleOptions = new SerializableMultiTargetInt(); break; case NodeKind.EXPORTER_GUI: m_exporterExportPath = new SerializableMultiTargetString(); break; default: throw new AssetBundleGraphException("[FATAL]Unhandled nodekind. unimplmented:"+ m_kind); } }
public CssNode(NodeKind kind, CssNode parent = null) { Kind = kind; this.parent = parent; }
/// <summary> /// Given the input C# code <paramref name="sourceText"/> returns /// the syntax tree for the input code. /// </summary> /// <param name="sourceText">A C# souce text</param> /// <param name="nodeKind">What kind of C# syntax node should the input be parsed as</param> private static SyntaxNode Parse(string sourceText, NodeKind nodeKind) { switch (nodeKind) { case NodeKind.CompilationUnit: return SyntaxFactory.ParseCompilationUnit(sourceText); case NodeKind.Statement: return SyntaxFactory.ParseStatement(sourceText); case NodeKind.Expression: return SyntaxFactory.ParseExpression(sourceText); default: throw new InvalidOperationException(); } }
public FeatureTreeNodeInfo(int hvo, NodeKind kind) { iHvo = hvo; eKind = kind; }
IEnumerable<int> LeftFromTheNode(int[] layer, int vPosition, NodeKind nodeKind, double leftMostX, double rightMostX) { double t = 0, b = 0; if (nodeKind == NodeKind.Bottom) b = Single.MaxValue;//we don't have bottom boundaries here since they will be cut off else if (nodeKind == NodeKind.Top) t = Single.MaxValue;//we don't have top boundaries here since they will be cut off int v = layer[vPosition]; for (int i = vPosition - 1; i > -1; i--) { int u = layer[i]; if (NodeUCanBeCrossedByNodeV(u, v)) continue; Anchor anchor = anchors[u]; if (anchor.Right <= leftMostX) break; if (anchor.Left < rightMostX) { if (anchor.TopAnchor > t + ApproximateComparer.DistanceEpsilon) { t = anchor.TopAnchor; yield return u; } else if (anchor.BottomAnchor > b + ApproximateComparer.DistanceEpsilon) { b = anchor.BottomAnchor; yield return u; } } } }
public EntityHierarchyNodeId(NodeKind kind, int id, int version) => (Kind, Id, Version) = (kind, id, version);
private void Test(string sourceText, NodeKind nodeKind = NodeKind.CompilationUnit) { Test(sourceText, useDefaultFormatting: true, removeRedundantCalls: true, shortenCodeWithUsingStatic: false, nodeKind); Test(sourceText, useDefaultFormatting: false, removeRedundantCalls: true, shortenCodeWithUsingStatic: true, nodeKind); }
/* * Constructor used to create new node from GUI */ public NodeData(string name, NodeKind kind, float x, float y) { m_id = Guid.NewGuid().ToString(); m_name = name; m_x = x; m_y = y; m_kind = kind; m_inputPoints = new List <ConnectionPointData>(); m_outputPoints = new List <ConnectionPointData>(); // adding defalut input point. // Loader does not take input if (kind != NodeKind.LOADER_GUI) { m_inputPoints.Add(new ConnectionPointData(AssetBundleGraphSettings.DEFAULT_INPUTPOINT_LABEL, this, true)); } // adding default output point. // Filter and Exporter does not have output. if (kind != NodeKind.FILTER_GUI && kind != NodeKind.EXPORTER_GUI) { m_outputPoints.Add(new ConnectionPointData(AssetBundleGraphSettings.DEFAULT_OUTPUTPOINT_LABEL, this, false)); } switch (m_kind) { case NodeKind.PREFABBUILDER_GUI: case NodeKind.MODIFIER_GUI: m_scriptClassName = String.Empty; m_scriptInstanceData = new SerializableMultiTargetString(); break; case NodeKind.IMPORTSETTING_GUI: break; case NodeKind.FILTER_GUI: m_filter = new List <FilterEntry>(); break; case NodeKind.LOADER_GUI: m_loaderLoadPath = new SerializableMultiTargetString(); break; case NodeKind.GROUPING_GUI: m_groupingKeyword = new SerializableMultiTargetString(AssetBundleGraphSettings.GROUPING_KEYWORD_DEFAULT); break; case NodeKind.BUNDLECONFIG_GUI: m_bundleConfigBundleNameTemplate = new SerializableMultiTargetString(AssetBundleGraphSettings.BUNDLECONFIG_BUNDLENAME_TEMPLATE_DEFAULT); m_bundleConfigUseGroupAsVariants = false; m_variants = new List <Variant>(); break; case NodeKind.BUNDLEBUILDER_GUI: m_bundleBuilderEnabledBundleOptions = new SerializableMultiTargetInt(); break; case NodeKind.EXPORTER_GUI: m_exporterExportPath = new SerializableMultiTargetString(); m_exporterExportOption = new SerializableMultiTargetInt(); break; default: throw new AssetBundleGraphException("[FATAL]Unhandled nodekind. unimplmented:" + m_kind); } }
public NodeKindSuggestionHandler(NodeKind kind) { _kind = kind; }