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