示例#1
0
        /// <summary>
        /// Returns the scalar type for the strings, decimals, uris, etc...
        /// </summary>
        /// <param name="type"></param>
        /// <param name="scalarType"></param>
        /// <returns></returns>
        public static bool TryGetBuiltInScalarType(
            Type type,
            [NotNullWhen(true)] out ScalarType?scalarType
            )
        {
            if (type == typeof(string))
            {
                scalarType = new StringType();
            }
            else if (type == typeof(decimal))
            {
                scalarType = new DecimalType();
            }
            else if (type == typeof(int))
            {
                scalarType = new IntType();
            }
            else if (type == typeof(bool))
            {
                scalarType = new BooleanType();
            }
            else if (type == typeof(float))
            {
                scalarType = new FloatType();
            }
            else if (type == typeof(Guid))
            {
                scalarType = new UuidType();
            }
            else if (type == typeof(DateTime))
            {
                scalarType = new DateTimeType();
            }
            else if (type == typeof(byte))
            {
                scalarType = new ByteType();
            }
            else if (type == typeof(Uri))
            {
                scalarType = new UrlType();
            }
            else if (type == typeof(long))
            {
                scalarType = new LongType();
            }
            else if (type == typeof(short))
            {
                scalarType = new ShortType();
            }
            else
            {
                scalarType = null;
            }

            return(scalarType is object);
        }
        private long ReturnWeight(string Weight)
        {
            object obj2 = null;

            for (long i = 1L; i <= Strings.Len(Weight); i += 1L)
            {
                obj2 = ObjectType.AddObj(obj2, Strings.Asc(Strings.Mid(Weight, (int)i, 1)));
            }
            return(LongType.FromObject(obj2));
        }
示例#3
0
        private static bool CanAppend(FluentEntityProperty <EntityColumnAttribute> property, object entity)
        {
            var id = 0L;

            if (property.Attribute.IsKey)
            {
                id = LongType.FromObject(property.Property.GetValue(entity) ?? 0L);
            }
            return(!property.Attribute.IsKey || id != 0L);
        }
        public void Implicit_SByte_Cast()
        {
            // arrange
            sbyte expected = 100;

            // act
            LongType actual = expected;

            // assert
            Assert.AreEqual(expected, (sbyte)actual);
        }
        public void Implicit_Int64_Cast()
        {
            // arrange
            long expected = 100;

            // act
            LongType actual = expected;

            // assert
            Assert.AreEqual(expected, (long)actual);
        }
        public void Implicit_Int16_Cast()
        {
            // arrange
            short expected = 100;

            // act
            LongType actual = expected;

            // assert
            Assert.AreEqual(expected, (short)actual);
        }
        public void Implicit_Int32_Cast()
        {
            // arrange
            int expected = 100;

            // act
            LongType actual = expected;

            // assert
            Assert.AreEqual(expected, (int)actual);
        }
示例#8
0
        public void ParseWithNumberStylesShouldReturnOptionLongNoneWhenStringIsNotExpectedHexNumber()
        {
            // Arrange
            var           s        = "1.0";
            Option <long> expected = None;

            // Act
            var result = LongType.Parse(s, NumberStyles.HexNumber);

            // Assert
            result.Should().Be(expected);
        }
示例#9
0
        public void ParseWithNumberStylesShouldReturnOptionLongNone()
        {
            // Arrange
            var           s        = "not a long";
            Option <long> expected = None;

            // Act
            var result = LongType.Parse(s, NumberStyles.Integer);

            // Assert
            result.Should().Be(expected);
        }
示例#10
0
        public void ParseWithNumberStylesShouldReturnOptionLongSome()
        {
            // Arrange
            var           s        = "1";
            Option <long> expected = Some(1L);

            // Act
            var result = LongType.Parse(s, NumberStyles.Number);

            // Assert
            result.Should().Be(expected);
        }
示例#11
0
        public void ParseShouldReturnOptionLongNone()
        {
            // Arrange
            var           s        = "not a long";
            Option <long> expected = None;

            // Act
            var result = LongType.Parse(s);

            // Assert
            result.Should().Be(expected);
        }
示例#12
0
        public void Operator_NotEqualTo()
        {
            // arrange
            long     value = 100L;
            LongType type  = value;

            // act
            bool actual = type != value;

            // assert
            Assert.IsFalse(actual);
        }
示例#13
0
        public void Implicit_ByteArray_Cast()
        {
            // arrange
            byte[] expected = new byte[] { 0, 0, 0, 0, 0, 0, 64, 128 };

            // act
            LongType actualType = expected;

            byte[] actual = actualType;

            // assert
            Assert.IsTrue(expected.SequenceEqual(actual));
        }
示例#14
0
        public void ParseWithNumberStylesAndFormatProviderShouldReturnOptionLongNone()
        {
            // Arrange
            var             s = "p1$234";
            IFormatProvider formatProvider = new NumberFormatInfo()
            {
                PositiveSign = "p"
            };
            Option <long> expected = None;

            // Act
            var result = LongType.Parse(s, NumberStyles.Integer, formatProvider);

            // Assert
            result.Should().Be(expected);
        }
示例#15
0
        private void Populate()
        {
            IntegerType c1 = new IntegerType("id", "id");
            Border      b1 = c1.Border;

            stackPanel.Children.Add(b1);

            StringType c2 = new StringType("First Name", "First Name");
            Border     b2 = c2.Border;

            stackPanel.Children.Add(b2);

            StringType c3 = new StringType("Last Name", "Last Name");
            Border     b3 = c3.Border;

            stackPanel.Children.Add(b3);

            RadioType c4 = new RadioType("Gender", "Male", "Female");
            Border    b4 = c4.Border;

            stackPanel.Children.Add(b4);

            LongType c5 = new LongType("Phone No.", "Phone No");
            Border   b5 = c5.Border;

            stackPanel.Children.Add(b5);

            DateType c9 = new DateType("Date", System.DateTime.Now);
            Border   b9 = c9.Border;

            stackPanel.Children.Add(b9);

            FloatType c6 = new FloatType("Salary", "Salary");
            Border    b6 = c6.Border;

            stackPanel.Children.Add(b6);

            IntegerType c7 = new IntegerType("Roll no", "Roll No");
            Border      b7 = c7.Border;

            stackPanel.Children.Add(b7);

            StringType c8 = new StringType("Address", "Address");
            Border     b8 = c8.Border;

            stackPanel.Children.Add(b8);
        }
示例#16
0
        public void ParseWithFormatProviderShouldReturnOptionLongSome()
        {
            // Arrange
            var             s = "p1234";
            IFormatProvider formatProvider = new NumberFormatInfo()
            {
                PositiveSign = "p"
            };

            Option <long> expected = Some(1234L);

            // Act
            var result = LongType.Parse(s, formatProvider);

            // Assert
            result.Should().Be(expected);
        }
        /// <summary>
        /// Tipos básicos não possuem transformações especiais.
        /// </summary>
        /// <param name="valueTypes"></param>
        /// <returns></returns>
        private static TypeBase GetTypeFromValue(TypeRef valueTypes)
        {
            if (valueTypes == null)
            {
                return(null);
            }

            switch (valueTypes.AsString().ToLower())
            {
            case "byte[]":
            case "string":
                return(StringType.Create());

            case "int":
                return(IntegerType.Create());

            case "int?":
                return(IntegerType.CreateNullable());

            case "datetime":
                return(DateType.Create());

            case "datetime?":
                return(DateType.CreateNullable());

            case "long":
                return(LongType.Create());

            case "long?":
                return(LongType.CreateNullable());

            case "bool":
                return(BoolType.Create());

            case "bool?":
                return(BoolType.CreateNullable());

            default:
                throw new ArgumentOutOfRangeException("valueTypes", "Não foi possível determinar o tipo da propriedade!");
            }
        }
示例#18
0
        public static String Oct(Object Number)
        {
            if (Number == null)
            {
                throw new ArgumentNullException("Number");
            }
            switch (ObjectType.GetTypeCode(Number))
            {
            case TypeCode.Byte:
                return(Oct(ByteType.FromObject(Number)));

            case TypeCode.Int16:
                return(Oct(ShortType.FromObject(Number)));

            case TypeCode.Boolean:
            case TypeCode.Char:
            case TypeCode.SByte:
            case TypeCode.UInt16:
            case TypeCode.Int32:
                return(Oct(IntegerType.FromObject(Number)));

            case TypeCode.Int64:
                return(Oct(LongType.FromObject(Number)));

            case TypeCode.UInt32:
            case TypeCode.UInt64:
            case TypeCode.Single:
            case TypeCode.Double:
            case TypeCode.Decimal:
                return(Oct(LongType.FromObject(Number)));

            case TypeCode.String:
                return(Oct(LongType.FromString
                               (StringType.FromObject(Number))));
            }
            throw new ArgumentException(S._("VB_InvalidNumber"), "Number");
        }
示例#19
0
 public void FromString_NotSupported(string value, long expected)
 {
     Assert.Throws <InvalidCastException>(() => LongType.FromString(value));
 }
示例#20
0
 public PropertyAnonymousInnerClass(ProjectDBUtil outerInstance)
 {
     this.outerInstance = outerInstance;
     lType = new LongType();
 }
 public static void AddLong(this CompositeType type, LongType value)
 {
     type.Add(value);
 }
示例#22
0
 public void FromObject_ThrowsOverflowException(object value)
 {
     Assert.Throws <OverflowException>(() => LongType.FromObject(value));
 }
示例#23
0
 public void FromString_ThrowsOverflowException(string value)
 {
     Assert.Throws <OverflowException>(() => LongType.FromString(value));
 }
示例#24
0
 public void FromString_ThrowsInvalidCastException(string value)
 {
     Assert.Throws <InvalidCastException>(() => LongType.FromString(value));
 }
示例#25
0
 public void FromString(string value, long expected)
 {
     Assert.Equal(expected, LongType.FromString(value));
 }
示例#26
0
        // Inner version of "Print" and "Write".
        private static void Print(File file, Object[] Output,
                                  CultureInfo culture, bool print)
        {
            NumberFormatInfo nfi = culture.NumberFormat;

            if (Output == null)
            {
                return;
            }
            bool first = true;

            foreach (Object obj in Output)
            {
                if (!first && !print)
                {
                    file.Write(",");
                }
                else
                {
                    first = false;
                }
                if (obj == null)
                {
                    if (!print)
                    {
                        file.Write("#NULL#");
                    }
                    continue;
                }
                if (obj is TabInfo)
                {
                    file.Tab((TabInfo)obj);
                    continue;
                }
                else if (obj is SpcInfo)
                {
                    file.Space((SpcInfo)obj);
                    continue;
                }
                else if (obj is char[])
                {
                    file.Write(new String((char[])obj));
                    continue;
                }
                else if (obj is ErrObject)
                {
                    if (print)
                    {
                        file.Write(String.Format("Error {0}",
                                                 ((ErrObject)obj).Number));
                    }
                    else
                    {
                        file.Write(String.Format("#ERROR {0}#",
                                                 ((ErrObject)obj).Number));
                    }
                    continue;
                }
                switch (ObjectType.GetTypeCode(obj))
                {
                case TypeCode.DBNull:
                {
                    if (print)
                    {
                        file.Write("Null");
                    }
                    else
                    {
                        file.Write("#NULL#");
                    }
                }
                break;

                case TypeCode.Boolean:
                {
                    bool b = BooleanType.FromObject(obj);
                    if (print)
                    {
                        file.Write(b.ToString(culture));
                    }
                    else if (b)
                    {
                        file.Write("#TRUE#");
                    }
                    else
                    {
                        file.Write("#FALSE#");
                    }
                }
                break;

                case TypeCode.Byte:
                {
                    byte by = ByteType.FromObject(obj);
                    file.Write(by.ToString(nfi));
                }
                break;

                case TypeCode.Int16:
                {
                    short s = ShortType.FromObject(obj);
                    file.Write(s.ToString(nfi));
                }
                break;

                case TypeCode.Int32:
                {
                    int i = IntegerType.FromObject(obj);
                    file.Write(i.ToString(nfi));
                }
                break;

                case TypeCode.Int64:
                {
                    long l = LongType.FromObject(obj);
                    file.Write(l.ToString(nfi));
                }
                break;

                case TypeCode.Single:
                {
                    float f = SingleType.FromObject(obj, nfi);
                    file.Write(f.ToString(nfi));
                }
                break;

                case TypeCode.Double:
                {
                    double d = DoubleType.FromObject(obj, nfi);
                    file.Write(d.ToString(nfi));
                }
                break;

                case TypeCode.Decimal:
                {
                    Decimal dc = DecimalType.FromObject(obj, nfi);
                    file.Write(dc.ToString(nfi));
                }
                break;

                case TypeCode.DateTime:
                {
                    DateTime dt = DateType.FromObject(obj);
                    if (print)
                    {
                        file.Write(StringType.FromDate(dt) + " ");
                    }
                    else
                    {
                        String format;
                        long   dayTicks = dt.Ticks % TimeSpan.TicksPerDay;
                        if (dt.Ticks == dayTicks)
                        {
                            format = "T";
                        }
                        else if (dayTicks == 0)
                        {
                            format = "d";
                        }
                        else
                        {
                            format = "F";
                        }
                        file.Write(dt.ToString
                                       (format, culture.DateTimeFormat));
                    }
                }
                break;

                case TypeCode.String:
                {
                    file.Write(StringType.FromObject(obj));
                }
                break;

                default:
                {
                    Utils.ThrowException(5);                                            // ArgumentException.
                }
                break;
                }
            }
        }
示例#27
0
 public void FromObject_ThrowsInvalidCastException(object value)
 {
     Assert.Throws <InvalidCastException>(() => LongType.FromObject(value));
 }
示例#28
0
 public void FromObject(object value, long expected)
 {
     Assert.Equal(expected, LongType.FromObject(value));
 }
示例#29
0
 public void FromObject_NotSupported(object value, long expected)
 {
     Assert.Throws <InvalidCastException>(() => LongType.FromObject(value));
 }