public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is NullValueNode) { return(null); } if (literal is FloatValueNode floatLiteral && TryParseDecimal(floatLiteral.Value, out var d)) { return(d); } if (literal is IntValueNode intLiteral && TryParseDecimal(intLiteral.Value, out d)) { return(d); } throw new ScalarSerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral( Name, literal.GetType())); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is StringValueNode stringLiteral) { if (!NameUtils.IsValidName(stringLiteral.Value)) { throw new ScalarSerializationException( AbstractionResources.Type_Name_IsNotValid( stringLiteral.Value)); } return(new NameString(stringLiteral.Value)); } if (literal is NullValueNode) { return(null); } throw new ScalarSerializationException( TypeResources.Scalar_Cannot_ParseLiteral( Name, literal.GetType())); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is StringValueNode stringLiteral) { if (!MultiplierPathString.IsValidName(stringLiteral.Value)) { throw new ScalarSerializationException( string.Format(CultureInfo.InvariantCulture, AbstractionResources.Type_NameIsNotValid, stringLiteral.Value ?? "null")); } return(new MultiplierPathString(stringLiteral.Value)); } if (literal is NullValueNode) { return(null); } throw new ScalarSerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral( Name, literal.GetType())); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is StringValueNode stringLiteral) { return(stringLiteral.Value); } if (literal is IntValueNode intLiteral) { return(intLiteral.Value); } if (literal is NullValueNode) { return(null); } throw new ArgumentException( TypeResources.Scalar_Cannot_ParseLiteral( Name, literal.GetType()), nameof(literal)); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is NullValueNode) { return(null); } if (literal is FloatValueNode floatLiteral && TryParseDouble(floatLiteral.Value, out double d)) { return(d); } // Input coercion rules specify that float values can be coerced // from IntValueNode and FloatValueNode: // http://facebook.github.io/graphql/June2018/#sec-Float if (literal is IntValueNode intLiteral && TryParseDouble(intLiteral.Value, out d)) { return(d); } throw new ScalarSerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral( Name, literal.GetType())); }
public override object?ParseLiteral(IValueNode literal, bool withDefaults = true) { if (literal is null) { throw new ArgumentNullException(nameof(literal)); } if (literal is StringValueNode stringLiteral) { return(stringLiteral.Value); } if (literal is IntValueNode intLiteral) { return(intLiteral.Value); } if (literal is NullValueNode) { return(null); } throw new SerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral(Name, literal.GetType()), this); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is IntValueNode intLiteral && int.TryParse( intLiteral.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out int i) && i >= _min && i <= _max) { return(i); } if (literal is NullValueNode) { return(null); } throw new ScalarSerializationException( TypeResources.Scalar_Cannot_ParseLiteral( Name, literal.GetType())); }
public override object?ParseLiteral(IValueNode valueSyntax, bool withDefaults = true) { if (valueSyntax is null) { throw new ArgumentNullException(nameof(valueSyntax)); } if (valueSyntax is NullValueNode) { return(null); } if (valueSyntax is FloatValueNode floatLiteral) { return(ParseLiteral(floatLiteral)); } // Input coercion rules specify that float values can be coerced // from IntValueNode and FloatValueNode: // http://facebook.github.io/graphql/June2018/#sec-Float if (valueSyntax is IntValueNode intLiteral) { return(ParseLiteral(intLiteral)); } throw new SerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral(Name, valueSyntax.GetType()), this); }
public object?ParseLiteral(IValueNode valueSyntax, bool withDefaults = true) { if (valueSyntax is null) { throw new ArgumentNullException(nameof(valueSyntax)); } if (valueSyntax is EnumValueNode evn && _enumValues.TryGetValue(evn.Value, out IEnumValue? ev)) { return(ev.Value); } if (valueSyntax is StringValueNode svn && _enumValues.TryGetValue(svn.Value, out ev)) { return(ev.Value); } if (valueSyntax is NullValueNode) { return(null); } throw new SerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral(Name, valueSyntax.GetType()), this); }
public ISortEnumValue?ParseSortLiteral(IValueNode valueSyntax) { if (valueSyntax is null) { throw new ArgumentNullException(nameof(valueSyntax)); } if (valueSyntax is EnumValueNode evn && ValueLookup.TryGetValue(evn.Value, out IEnumValue? ev) && ev is ISortEnumValue sortEnumValue) { return(sortEnumValue); } if (valueSyntax is StringValueNode svn && NameLookup.TryGetValue(svn.Value, out ev) && ev is ISortEnumValue sortEnumValueOfString) { return(sortEnumValueOfString); } if (valueSyntax is NullValueNode) { return(null); } throw new SerializationException( string.Format( CultureInfo.InvariantCulture, DataResources.SortingEnumType_Cannot_ParseLiteral, Name, valueSyntax.GetType().Name), this); }
protected sealed override object?ParseLiteral(IValueNode valueSyntax, bool withDefaults) { if (valueSyntax is NullValueNode) { return(null); } if (valueSyntax.Kind != SyntaxKind.ListValue && InnerInputType !.IsInstanceOfType(valueSyntax)) { return(CreateList(new ListValueNode(valueSyntax), withDefaults)); } if (valueSyntax.Kind == SyntaxKind.ListValue) { if (_isNestedList) { if (IsInstanceOfType(valueSyntax)) { return(CreateList((ListValueNode)valueSyntax, withDefaults)); } } else { return(CreateList((ListValueNode)valueSyntax, withDefaults)); } } throw new SerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral(this.Print(), valueSyntax.GetType()), this); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is IntValueNode intLiteral) { return(int.Parse( intLiteral.Value, NumberStyles.Integer, CultureInfo.InvariantCulture)); } if (literal is NullValueNode) { return(null); } throw new ArgumentException( TypeResources.Scalar_Cannot_ParseLiteral( Name, literal.GetType()), nameof(literal)); }
public override object ParseLiteral(IValueNode literal) { if (literal == null) { throw new ArgumentNullException(nameof(literal)); } if (literal is FloatValueNode floatLiteral) { return(double.Parse( floatLiteral.Value, NumberStyles.Float, CultureInfo.InvariantCulture)); } // Input coercion rules specify that float values can be coerced // from IntValueNode and FloatValueNode: // http://facebook.github.io/graphql/June2018/#sec-Float if (literal is IntValueNode node) { return(double.Parse(node.Value, NumberStyles.Float, CultureInfo.InvariantCulture)); } if (literal is NullValueNode) { return(null); } throw new ArgumentException( TypeResources.Scalar_Cannot_ParseLiteral( Name, literal.GetType()), nameof(literal)); }
public override object ParseLiteral(IValueNode literal, bool withDefaults = true) { switch (literal) { case StringValueNode svn: return(svn.Value); case IntValueNode ivn: return(long.Parse(ivn.Value, CultureInfo.InvariantCulture)); case FloatValueNode fvn: return(decimal.Parse(fvn.Value, CultureInfo.InvariantCulture)); case BooleanValueNode bvn: return(bvn.Value); case ListValueNode lvn: return(_objectValueToDictConverter.Convert(lvn)); case ObjectValueNode ovn: return(_objectValueToDictConverter.Convert(ovn)); case NullValueNode _: return(null); default: throw new SerializationException( TypeResourceHelper.Scalar_Cannot_ParseLiteral(Name, literal.GetType()), this); } }
protected void LocalTime_ExpectParseResultToMatchNull() { // arrange ScalarType scalar = new LocalTimeType(); // act IValueNode result = scalar.ParseResult(null); // assert Assert.Equal(typeof(NullValueNode), result.GetType()); }
protected void Longitude_ExpectParseResultToMatchDouble() { // arrange ScalarType scalar = new LongitudeType(); const double valueSyntax = 179d; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void Latitude_ExpectParseResultToMatchInt() { // arrange ScalarType scalar = new LatitudeType(); const int valueSyntax = 89; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void UtcOffset_ExpectParseResultToMatchStringValue() { // arrange ScalarType scalar = new UtcOffsetType(); const string valueSyntax = "-02:00"; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void Longitude_ExpectParseValueToMatchType() { // arrange ScalarType scalar = CreateType <LongitudeType>(); const double valueSyntax = 74.3d; // act IValueNode result = scalar.ParseValue(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void LocalCurrency_ExpectParseResultToMatchStringValue() { // arrange ScalarType scalar = new LocalCurrencyType(); const string valueSyntax = "$9.99"; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void Longitude_ExpectParseResultToMatchNull() { // arrange ScalarType scalar = new LongitudeType(); object valueSyntax = null !; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(NullValueNode), result.GetType()); }
protected void UtcOffset_ExpectParseValueToMatchTimeSpan() { // arrange ScalarType scalar = CreateType <UtcOffsetType>(); var valueSyntax = new TimeSpan(0, 0, 0); // act IValueNode result = scalar.ParseValue(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void LocalCurrency_ExpectParseValueToMatchDecimal() { // arrange ScalarType scalar = CreateType <LocalCurrencyType>(); const decimal valueSyntax = 24.95m; // act IValueNode result = scalar.ParseValue(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void LocalTime_ExpectParseResultToMatchStringValue() { // arrange ScalarType scalar = new LocalTimeType(); const string valueSyntax = "2018-06-29T08:46:14+04:00"; // act IValueNode result = scalar.ParseResult(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
protected void LocalTime_ExpectParseValueToMatchDateTime() { // arrange ScalarType scalar = CreateType <LocalTimeType>(); var valueSyntax = new DateTime(2018, 6, 29, 8, 46, 14); // act IValueNode result = scalar.ParseValue(valueSyntax); // assert Assert.Equal(typeof(StringValueNode), result.GetType()); }
public void ParseSimpleValue( string value, object expectedValue, Type expectedNodeType) { // arrange // act IValueNode valueNode = ParseValue(value); // assert Assert.Equal(expectedNodeType, valueNode.GetType()); Assert.Equal(expectedValue, valueNode.Value); }
protected void ExpectParseValueToMatchType <TType>( object?valueSyntax, Type type) where TType : ScalarType { // arrange ScalarType scalar = CreateType <TType>(); // act IValueNode result = scalar.ParseValue(valueSyntax); // assert Assert.Equal(type, result.GetType()); }
public TValueNode ArgumentLiteral <TValueNode>(NameString name) where TValueNode : IValueNode { if (!Arguments.TryGetValue(name, out ArgumentValue? argument)) { throw ResolverContext_ArgumentDoesNotExist(_selection.SyntaxNode, Path, name); } IValueNode literal = argument.ValueLiteral !; if (literal is TValueNode castedLiteral) { return(castedLiteral); } throw ResolverContext_LiteralNotCompatible( _selection.SyntaxNode, Path, name, typeof(TValueNode), literal.GetType()); }
public T Argument <T>(NameString name) { if (typeof(IValueNode).IsAssignableFrom(typeof(T))) { IValueNode literal = ArgumentLiteral <IValueNode>(name); if (literal is T casted) { return(casted); } throw ResolverContext_LiteralNotCompatible( FieldSelection, Path, name, typeof(T), literal.GetType()); } return(ArgumentValue <T>(name)); }
public T ArgumentLiteral <T>(NameString name) where T : IValueNode { if (!Arguments.TryGetValue(name, out PreparedArgument? argument)) { throw ResolverContext_ArgumentDoesNotExist(FieldSelection, Path, name); } IValueNode literal = argument.ValueLiteral !; if (literal is T castedLiteral) { return(castedLiteral); } throw ResolverContext_LiteralNotCompatible( FieldSelection, Path, name, typeof(T), literal.GetType()); }