public InputResourceBuffer([NotNull] Symbol label, [NotNull] ComputationType elementType, int index) : base(label, index)
{
if (index >= 128)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
ElementType = elementType ?? throw new ArgumentNullException(nameof(elementType));
}
public UnorderedAccessBuffer([NotNull] Symbol label, [NotNull] ComputationType elementType, int index) : base(label, index)
{
if (index >= 8)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
ElementType = elementType ?? throw new ArgumentNullException(nameof(elementType));
}
public object Convert([NotNull] object value, [NotNull] ComputationType targetType)
{
var result = TryConvert(value, targetType);
if (result.HasError)
{
throw new InvalidCastException(result.ErrorDescription);
}
return(result.Data);
}
public Declaration([NotNull] Symbol label, [NotNull] ComputationType type)
{
if (label == null)
{
throw new ArgumentNullException(nameof(label));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
Label = label;
Type = type;
}
public static void Add([NotNull] Type clrType, [NotNull] ComputationType computationType)
{
if (clrType == null)
{
throw new ArgumentNullException(nameof(clrType));
}
if (computationType == null)
{
throw new ArgumentNullException(nameof(computationType));
}
lock (mTypeLock)
{
mTypes.Add(clrType, computationType);
}
}
public bool AcceptsValueOf([NotNull] ComputationType other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
var otherDefaultValues = other.Deconstruct(other.GetDefaultValue());
var convertResult = Construct(otherDefaultValues);
if (convertResult.HasError)
{
return(false);
}
return(true);
}
public Literal([NotNull] object value, ComputationType type = null)
{
Value = value ?? throw new ArgumentNullException(nameof(value));
var computedType = ComputationTypeResolver.Find(value.GetType());
if (type != null)
{
if (type.AcceptsValueOf(computedType))
{
Type = type;
}
else
{
throw new ArgumentException($"\"{value}\" is not assignable to \"{type.Key}\"");
}
}
else
{
Type = computedType;
}
}
public Result <object> TryConvert([NotNull] object value, [NotNull] ComputationType targetType)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
if (targetType == null)
{
throw new ArgumentNullException(nameof(targetType));
}
var sourceValues = Deconstruct(value);
var convertResult = targetType.Construct(sourceValues);
if (convertResult.HasError)
{
return(Result.CreateError <Result <object> >($"Failed to convert \"{value}\" to \"{targetType.Key}\". {convertResult.ErrorDescription}".Trim()));
}
return(convertResult.Data);
}
public static void Add <T>([NotNull] ComputationType computationType) => Add(typeof(T), computationType);
