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);
}
