Example #1
0
        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));
        }
Example #2
0
        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));
        }
Example #3
0
        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);
        }
Example #4
0
        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;
        }
Example #5
0
        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);
            }
        }
Example #6
0
        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);
        }
Example #7
0
        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;
            }
        }
Example #8
0
        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);
        }
Example #9
0
 public static void Add <T>([NotNull] ComputationType computationType) => Add(typeof(T), computationType);