public override bool TryHandleEnter( QueryableSortContext context, ISortField field, ISortEnumValue?sortEnumValue, EnumValueNode valueNode, [NotNullWhen(true)] out ISyntaxVisitorAction?action) { if (sortEnumValue is null) { context.ReportError( ErrorHelper.CreateNonNullError(field, valueNode, context)); action = null !; return(false); } if (context.Instance.Peek() is QueryableFieldSelector fieldSelector) { context.Operations.Enqueue( HandleOperation( context, fieldSelector, field, sortEnumValue)); action = SyntaxVisitor.Continue; return(true); } throw new InvalidOperationException( DataResources.QueryableSortHandler_InvalidSelector); }
void ParseEnum(FileNode filenode, MessageNode msgNode) { var node = new EnumNode(); ParseCommentAndEOL(node); // message的头注释 Consume(TokenType.Enum); MarkLocation(node); node.Name = FetchToken(TokenType.Identifier, "require enum type name").Value; _tool.CheckDuplicate(node.Loc, filenode.Package, node.Name); if (_fileNode.IsTopScope()) { filenode.AddEnum(node); } else { msgNode.Add(node); } _fileNode.AddSymbol(filenode.Package, node.Name, node); TryConsume(TokenType.EOL); ParseCommentAndEOL(node); Consume(TokenType.LBrace); TryConsume(TokenType.EOL); while (CurrToken.Type != TokenType.RBrace) { var valueNode = new EnumValueNode(); // 字段的头注释 ParseCommentAndEOL(valueNode); MarkLocation(valueNode); valueNode.Name = FetchToken(TokenType.Identifier, "require enum name").Value; CheckDuplicate(node, _lexer.Loc, valueNode.Name); Consume(TokenType.Assign); valueNode.Number = FetchToken(TokenType.Number, "require enum value").ToInteger(); Consume(TokenType.SemiColon); node.AddValue(valueNode); // 尾注释 ParseTrailingComment(valueNode); ParseCommentAndEOL(valueNode); } Consume(TokenType.RBrace); TryConsume(TokenType.EOL); }
private ClassNode ReadClass(Type parameterType, AssemblyNode assembly, ActionNode actionNode, Type[] parents) { var parameterTypeName = Regex.Replace(parameterType.Name, "`.*", ""); ClassNode classNode; if (assembly.Classes.ContainsKey(parameterTypeName)) { classNode = assembly.Classes[parameterTypeName]; } else { classNode = new ClassNode { Version = actionNode.Version, Documentation = documentation.GetDocumentation(parameterType), KoName = parameterTypeName, Name = Regex.Replace(parameterTypeName, @"View(Model)?$", string.Empty) }; if (parameterType.GetTypeInfo().IsEnum) { var enumNames = parameterType.GetTypeInfo().GetEnumNames(); var enumValues = parameterType.GetTypeInfo().GetEnumValues(); classNode.Values = new List <EnumValueNode>(); for (var i = 0; i < enumValues.Length; i++) { var enumValue = new EnumValueNode { Name = enumNames[i], Value = Convert.ToInt32(enumValues.GetValue(i)), Documentation = documentation.GetDocumentation(parameterType, enumNames[i]) }; classNode.Values.Add(enumValue); } } else { if (parents.All(x => x != parameterType)) { classNode.Properties = ReadProperties(parameterType, parents, assembly, actionNode); } if (parameterType.GetTypeInfo().IsGenericTypeDefinition) { classNode.GenericParameters = parameterType.GetGenericArguments().Select(x => x.Name).ToList(); } var jsonAttribute = parameterType.GetTypeInfo().GetCustomAttribute <JsonAttribute>(); if (jsonAttribute != null) { classNode.HasObservable = jsonAttribute.Observable; } } assembly.Classes[classNode.KoName] = classNode; } return(classNode); }
public virtual bool TryHandleEnter( TContext context, ISortField field, ISortEnumValue?sortValue, EnumValueNode node, [NotNullWhen(true)] out ISyntaxVisitorAction?action) { action = null; return(false); }
public void ParseResult_Should_Parse_String(string stringValue) { // arrange GeoJsonTypeSerializer serializer = GeoJsonTypeSerializer.Default; // act IValueNode resultValue = serializer.ParseResult(stringValue); // assert EnumValueNode enumValue = Assert.IsType <EnumValueNode>(resultValue); Assert.Equal(stringValue, enumValue.Value); }
public void ParseResult_Should_Parse_NameString(string stringValue) { // arrange var type = new Mock <IType>(); GeoJsonTypeSerializer serializer = GeoJsonTypeSerializer.Default; // act IValueNode resultValue = serializer.ParseResult( type.Object, new NameString(stringValue)); // assert EnumValueNode enumValue = Assert.IsType <EnumValueNode>(resultValue); Assert.Equal(stringValue, enumValue.Value); }
public void VisitEnumValue(EnumValueNode node) { if (!_context.EnumInfo.TryGetValue(node.Declaration.Name, out EnumDeclarationInfo info)) { throw new InvalidOperationException("Enumeration declaration name not known by semantic context."); } IType?type = _typeManager.GetType(info.Enum.Name, PointerMode.NotAPointer); if (type == null) { throw new InvalidOperationException($"Enum with name {info.Enum.Name} is not registered with the type system."); } SetAndCacheType(node, type); }
public void ParseValue_Should_Parse_EnumValue( GeoJsonGeometryType value, string stringValue) { // arrange var type = new Mock <IType>(); GeoJsonTypeSerializer serializer = GeoJsonTypeSerializer.Default; // act IValueNode resultValue = serializer.ParseValue(type.Object, value); // assert EnumValueNode enumValue = Assert.IsType <EnumValueNode>(resultValue); Assert.Equal(stringValue, enumValue.Value); }
/// <summary> /// Processes the queue as far as it needs to to generate a fully qualiffied /// <see cref="SyntaxNode" /> based on its ruleset. /// </summary> /// <param name="tokenStream">The token stream.</param> /// <returns>LexicalToken.</returns> public SyntaxNode MakeNode(TokenStream tokenStream) { SyntaxNode node; if (tokenStream.Match <NullToken>()) { node = ValueMakerFactory.CreateMaker(tokenStream.ActiveToken).MakeNode(tokenStream); } else { tokenStream.MatchOrThrow <NameToken>(); node = new EnumValueNode(tokenStream.Location, tokenStream.ActiveToken.Text); tokenStream.Next(); } return(node); }
private ListValueNode RebuildListValue( ListType type, ListValueNode listValue) { if (type.ElementType.IsEnumType() && listValue.Items.Count > 0 && listValue.Items[0] is StringValueNode) { IValueNode[] items = new IValueNode[listValue.Items.Count]; for (int i = 0; i < items.Length; i++) { items[i] = listValue.Items[i]; if (items[i] is StringValueNode s) { items[i] = new EnumValueNode(s.Value); } } return(new ListValueNode(items)); } if (type.ElementType.IsInputObjectType() && type.ElementType.NamedType() is InputObjectType iot) { IValueNode[] items = new IValueNode[listValue.Items.Count]; for (int i = 0; i < items.Length; i++) { if (listValue.Items[i].IsNull()) { items[i] = NullValueNode.Default; } else { items[i] = RebuildValue(iot, listValue.Items[i]); } } return(new ListValueNode(items)); } return(listValue); }
protected override ISyntaxVisitorAction OnOperationEnter( TContext context, ISortField field, ISortEnumValue?sortValue, EnumValueNode valueNode) { if (sortValue?.Handler is ISortOperationHandler <TContext, T> handler && handler.TryHandleEnter( context, field, sortValue, valueNode, out ISyntaxVisitorAction? action)) { return(action); } return(SyntaxVisitor.Skip); }
/// <inheritdoc/> public override bool TryHandleEnter( Neo4JSortVisitorContext context, ISortField field, ISortEnumValue?sortValue, EnumValueNode node, [NotNullWhen(true)] out ISyntaxVisitorAction?action) { if (sortValue is null) { context.ReportError(ErrorHelper.CreateNonNullError(field, node, context)); action = null !; return(false); } context.Operations .Enqueue(new Neo4JSortDefinition(context.Path.Peek(), _sortDirection)); action = SyntaxVisitor.Continue; return(true); }
private void CoerceVariableValue( IReadOnlyDictionary <string, IValueNode> variableValues, ref Variable variable) { if (!variableValues.TryGetValue(variable.Name, out IValueNode variableValue)) { variableValue = variable.DefaultValue ?? new NullValueNode(); } // TODO : this is a workaround for the serialization issue with enum values. // once fixed this has to be removed. if (variable.Type is EnumType && variableValue is StringValueNode v) { variableValue = new EnumValueNode(v.Value); } variable = variable.WithValue(variableValue); CheckForNullValueViolation(in variable); CheckForInvalidValueType(in variable); }
public override void Print(EnumValueNode node, StringBuilder sb, PrintOption opt, params object[] values) { var maxNameLength = (int)values[0]; sb.Append(opt.MakeIndentSpace()); sb.Append(node.Name.PadRight(maxNameLength)); sb.AppendFormat(" = {0}", node.Number); sb.Append(";"); var commentSpace = " ".PadLeft(3 - node.Number.ToString().Length); sb.Append(commentSpace); if (!string.IsNullOrEmpty(node.TrailingComment)) { sb.AppendFormat("//{0}", node.TrailingComment); } sb.Append("\n"); }
public void VisitEnumValue(EnumValueNode node) { EnumValueVisitor?.Visit(node); }
public void VisitEnumValue(EnumValueNode node) { VisitPreOrder(node); VisitPostOrder(node); }
public void VisitEnumValue(EnumValueNode node) { Print($"EnumValue (Declaration.Name = {node.Declaration.Name})"); }
protected abstract ISyntaxVisitorAction OnOperationEnter( TContext context, ISortField field, ISortEnumValue?sortEnumValue, EnumValueNode enumValueNode);
public virtual void VisitEnumValue(EnumValueNode node) { VisitDefaultExpression(node); }
public void VisitEnumValue(EnumValueNode node) { }
public void VisitEnumValue(EnumValueNode node) { int value = _semanticContext.EnumInfo[node.Declaration.Name].Value; _functionBuilder.AddInstruction(OpCode.PUSHWORD, value); }
/// <summary> /// Initializes a new instance of the <see cref="QueryEnumInputValue" /> class. /// </summary> /// <param name="value">The value parsed from a query document.</param> public QueryEnumInputValue(EnumValueNode value) : base(value) { this.Value = value.Value; }
public EnumValueNodeViewModel(EnumValueNode graphItemObject, Invert.Core.GraphDesigner.DiagramViewModel diagramViewModel) : base(graphItemObject, diagramViewModel) { }
protected virtual void VisitEnumValue(EnumValueNode node) { }
protected override void VisitEnumValue( EnumValueNode node, Action <object> setValue) { setValue(node.Value); }
public void VisitEnumValue(EnumValueNode node) { int value = _genContext.SemanticContext.EnumInfo[node.Declaration.Name].Value; _visitedValue = Value.ConstInt(_genContext.Context.Int32Type, (ulong)value, true); }