private IValueNode ReplaceVariable(
VariableNode variable,
IInputType type)
{
if (_variables.TryGetVariable(
variable.Name.Value,
out object v))
{
if (!type.ClrType.IsInstanceOfType(v) &&
!_typeConversion.TryConvert(
typeof(object),
type.ClrType,
v,
out v))
{
// TODO : resource
// TODO : path?
throw new QueryException(
ErrorBuilder.New()
.SetMessage(
"Unable to convert the specified " +
"variable value.")
.Build());
}
return(type.ParseValue(v));
}
return(type.ParseValue(null));
}
private static bool TryConvertLeafValue(
ITypeConversion converter,
IHasClrType leafType,
object value,
out object scalarValue)
{
try
{
if (value is null)
{
scalarValue = value;
return(true);
}
if (!leafType.ClrType.IsInstanceOfType(value))
{
return(converter.TryConvert(
typeof(object),
leafType.ClrType,
value,
out scalarValue));
}
scalarValue = value;
return(true);
}
catch
{
scalarValue = null;
return(false);
}
}
protected override void VisitObjectField(
ObjectFieldNode node,
ConverterContext context)
{
if (context.InputFields.TryGetField(
node.Name.Value, out InputField inputField))
{
var valueContext = new ConverterContext();
valueContext.InputType = inputField.Type;
valueContext.ClrType = inputField.ClrType;
VisitValue(node.Value, valueContext);
object value = (inputField.ClrType != null &&
!inputField.ClrType
.IsInstanceOfType(valueContext.Object) &&
_converter.TryConvert(
typeof(object), inputField.ClrType,
valueContext.Object, out object obj))
? obj
: valueContext.Object;
inputField.SetValue(context.Object, value);
}
}
internal object DeserializeArgument(
Argument argument,
IValueNode valueNode,
Type targetType)
{
if (argument == null)
{
throw new ArgumentNullException(nameof(argument));
}
if (valueNode == null)
{
throw new ArgumentNullException(nameof(valueNode));
}
var obj = argument.Type.ParseLiteral(valueNode);
if (targetType.IsInstanceOfType(obj))
{
return(obj);
}
if (_converter.TryConvert(typeof(object), targetType,
obj, out var o))
{
return(o);
}
throw new ArgumentException(
TypeResources.DirectiveType_UnableToConvert,
nameof(targetType));
}
private object Serialize(ExportedVariable exported, ITypeNode type)
{
if (_executor.Schema.TryGetType(
type.NamedType().Name.Value,
out INamedInputType inputType) &&
_typeConversion.TryConvert(
typeof(object),
inputType.ClrType,
exported.Value,
out var converted))
{
return(inputType.Serialize(converted));
}
throw SerializationError();
}
private IValueNode ReplaceVariable(
VariableNode variable,
IInputType type)
{
if (_variables.TryGetVariable(
variable.Name.Value,
out object v))
{
if (!type.ClrType.IsInstanceOfType(v) &&
!_typeConversion.TryConvert(
typeof(object),
type.ClrType,
v,
out v))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage(CoreResources.VarRewriter_CannotConvert)
.SetCode(ErrorCodes.Utilities.NoConverter)
.AddLocation(variable)
.Build());
}
return(type.ParseValue(v));
}
return(type.ParseValue(null));
}
private static IError CheckForNullFieldViolation(
InputObjectType type,
object value,
ISet <object> processed,
ITypeConversion converter,
Func <string, IError> createError)
{
if (!processed.Add(value))
{
return(null);
}
foreach (InputField field in type.Fields)
{
object obj = (type.ClrType != null &&
!type.ClrType.IsInstanceOfType(value) &&
converter.TryConvert(typeof(object), type.ClrType,
value, out object converted))
? converted
: value;
object fieldValue = field.GetValue(obj);
IError error = CheckForNullValueViolation(
field.Type, fieldValue, processed,
converter, createError);
if (error != null)
{
return(error);
}
}
return(null);
}
protected static bool TryConvertSerialized <T>(
object serialized,
ValueKind expectedKind,
out T value)
{
if (Scalars.TryGetKind(serialized, out ValueKind kind) &&
kind == expectedKind &&
_converter.TryConvert <object, T>(serialized, out T c))
{
value = c;
return(true);
}
value = default;
return(false);
}
private void VisitValue(
object obj,
Action <object> setValue,
ISet <object> processed)
{
if (obj is null)
{
setValue(null);
return;
}
switch (obj)
{
case string _:
case short _:
case ushort _:
case int _:
case uint _:
case long _:
case ulong _:
case float _:
case double _:
case decimal _:
case bool _:
setValue(obj);
return;
}
Type type = obj.GetType();
if (type.IsValueType && _converter.TryConvert(
type, typeof(string), obj, out object converted) &&
converted is string s)
{
setValue(s);
return;
}
else if (!typeof(IReadOnlyDictionary <string, object>).IsAssignableFrom(type) &&
obj is ICollection list)
{
VisitList(list, setValue, processed);
}
else
{
VisitObject(obj, setValue, processed);
}
}
public static bool TryConvert <TFrom, TTo>(
this ITypeConversion typeConversion,
TFrom source, out TTo converted)
{
if (typeConversion == null)
{
throw new ArgumentNullException(nameof(typeConversion));
}
if (typeConversion.TryConvert(
typeof(TFrom), typeof(TTo),
source, out object conv) &&
conv is TTo convcasted)
{
converted = convcasted;
return(true);
}
converted = default;
return(false);
}
private IValueNode ParseValue(object value, ISet <object> set)
{
if (value is null)
{
return(NullValueNode.Default);
}
switch (value)
{
case string s:
return(new StringValueNode(s));
case short s:
return(new IntValueNode(s));
case ushort s:
return(new IntValueNode(s));
case int i:
return(new IntValueNode(i));
case uint i:
return(new IntValueNode(i));
case long l:
return(new IntValueNode(l));
case ulong l:
return(new IntValueNode(l));
case float f:
return(new FloatValueNode(f));
case double d:
return(new FloatValueNode(d));
case decimal d:
return(new FloatValueNode(d));
case bool b:
return(new BooleanValueNode(b));
}
Type type = value.GetType();
if (type.IsValueType && _converter.TryConvert(
type, typeof(string), value, out object converted) &&
converted is string c)
{
return(new StringValueNode(c));
}
if (set.Add(value))
{
if (value is IReadOnlyDictionary <string, object> dict)
{
var fields = new List <ObjectFieldNode>();
foreach (KeyValuePair <string, object> field in dict)
{
fields.Add(new ObjectFieldNode(
field.Key,
ParseValue(field.Value, set)));
}
return(new ObjectValueNode(fields));
}
if (value is IReadOnlyList <object> list)
{
var valueList = new List <IValueNode>();
foreach (object element in list)
{
valueList.Add(ParseValue(element, set));
}
return(new ListValueNode(valueList));
}
return(ParseValue(_objectToDictConverter.Convert(value), set));
}
// TODO : resources
throw new ScalarSerializationException(
"Cycle in object graph detected.");
}
