Ejemplo n.º 1
0
        public static DbaseField Read(BinaryReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException(nameof(reader));
            }

            var name        = new DbaseFieldName(reader.ReadRightPaddedString(11, char.MinValue));
            var typeOfField = reader.ReadByte();

            if (!Enum.IsDefined(typeof(DbaseFieldType), typeOfField))
            {
                var values          = Enum.GetValues(typeof(DbaseFieldType));
                var supportedValues = string.Join(
                    ",",
                    Enumerable
                    .Range(0, values.Length)
                    .Select(index =>
                            values.GetValue(index).ToString() + "[" + ((byte)values.GetValue(index)).ToString() + "]")
                    );

                throw new DbaseFileHeaderException(
                          $"The field type {typeOfField} of field {name} is not supported ({supportedValues}).");
            }

            var fieldType    = (DbaseFieldType)typeOfField;
            var offset       = new ByteOffset(reader.ReadInt32());
            var length       = new DbaseFieldLength(reader.ReadByte());
            var decimalCount = new DbaseDecimalCount(reader.ReadByte());

            reader.ReadBytes(14);

            return(new DbaseField(name, fieldType, offset, length, decimalCount));
        }
Ejemplo n.º 2
0
        public void ToInt32ReturnsExpectedValue()
        {
            var value = Math.Abs(_fixture.Create <int>());
            var sut   = new ByteOffset(value);

            var result = sut.ToInt32();

            Assert.Equal(value, result);
        }
Ejemplo n.º 3
0
        public void LessThanOrEqualOperatorReturnsExpectedValue(int left, int right, bool expected)
        {
            var sut   = new ByteOffset(left);
            var other = new ByteOffset(right);

            var result = sut <= other;

            Assert.Equal(expected, result);
        }
Ejemplo n.º 4
0
        public void CompareToReturnsExpectedResult(int left, int right, int expected)
        {
            var sut   = new ByteOffset(left);
            var other = new ByteOffset(right);

            var result = sut.CompareTo(other);

            Assert.Equal(expected, result);
        }
Ejemplo n.º 5
0
        public DbaseField(DbaseFieldName name, DbaseFieldType fieldType, ByteOffset offset, DbaseFieldLength length,
                          DbaseDecimalCount decimalCount)
        {
            if (!Enum.IsDefined(typeof(DbaseFieldType), fieldType))
            {
                throw new ArgumentException(
                          $"The field type {fieldType} of field {name} is not supported.",
                          nameof(fieldType));
            }

            switch (fieldType)
            {
            case DbaseFieldType.Character:
                if (decimalCount.ToInt32() != 0)
                {
                    throw new ArgumentException(
                              $"The character field {name} decimal count ({decimalCount}) must be set to 0.",
                              nameof(decimalCount));
                }

                break;

            case DbaseFieldType.DateTime:
                if (length.ToInt32() != 15)
                {
                    throw new ArgumentException($"The datetime field {name} length ({length}) must be set to 15.",
                                                nameof(length));
                }

                if (decimalCount.ToInt32() != 0)
                {
                    throw new ArgumentException(
                              $"The datetime field {name} decimal count ({decimalCount}) must be set to 0.",
                              nameof(decimalCount));
                }

                break;

            case DbaseFieldType.Number:
                if (length > DbaseDouble.MaximumLength)
                {
                    throw new ArgumentException(
                              $"The number field {name} length ({length}) must be less than or equal to {DbaseDouble.MaximumLength}.",
                              nameof(length));
                }

                if (decimalCount.ToInt32() != 0)
                {
                    if (length < DbaseDouble.MinimumLength)
                    {
                        throw new ArgumentException(
                                  $"The number field {name} length ({length}) must be at least {DbaseDouble.MinimumLength}.",
                                  nameof(length));
                    }

                    if (decimalCount > DbaseDouble.MaximumDecimalCount)
                    {
                        throw new ArgumentException(
                                  $"The number field {name} decimal count ({decimalCount}) must be less than or equal to {DbaseDouble.MaximumDecimalCount}.",
                                  nameof(decimalCount));
                    }

                    if (decimalCount.ToInt32() > length.ToInt32() - 2)
                    {
                        throw new ArgumentException(
                                  $"The number field {name} decimal count ({decimalCount}) must be 2 less than its length ({length}).",
                                  nameof(decimalCount));
                    }
                }

                break;

            case DbaseFieldType.Float:
                if (length > DbaseSingle.MaximumLength)
                {
                    throw new ArgumentException(
                              $"The float field {name} length ({length}) must be less than or equal to {DbaseSingle.MaximumLength}.",
                              nameof(length));
                }

                if (decimalCount.ToInt32() != 0)
                {
                    if (length < DbaseSingle.MinimumLength)
                    {
                        throw new ArgumentException(
                                  $"The number field {name} length ({length}) must be at least {DbaseSingle.MinimumLength}.",
                                  nameof(length));
                    }

                    if (decimalCount > DbaseSingle.MaximumDecimalCount)
                    {
                        throw new ArgumentException(
                                  $"The float field {name} decimal count ({decimalCount}) must be less than or equal to {DbaseSingle.MaximumDecimalCount}.",
                                  nameof(decimalCount));
                    }

                    if (decimalCount.ToInt32() > length.ToInt32() - 2)
                    {
                        throw new ArgumentException(
                                  $"The float field {name} decimal count ({decimalCount}) must be 2 less than its length ({length}).",
                                  nameof(decimalCount));
                    }
                }

                break;

            case DbaseFieldType.Logical:
                if (decimalCount.ToInt32() != 0)
                {
                    throw new ArgumentException(
                              $"The logical field {name} decimal count ({decimalCount}) must be set to 0.",
                              nameof(decimalCount));
                }

                if (length.ToInt32() != 1)
                {
                    throw new ArgumentException(
                              $"The logical field {name} length ({length}) must be set to 1.",
                              nameof(length));
                }

                break;
            }

            Name         = name;
            FieldType    = fieldType;
            Offset       = offset;
            Length       = length;
            DecimalCount = decimalCount;

            if (FieldType == DbaseFieldType.Number || FieldType == DbaseFieldType.Float)
            {
                PositiveIntegerDigits =
                    DecimalCount.ToInt32() != 0
                        ? new DbaseIntegerDigits(
                        Length
                        .Minus(DecimalCount.ToLength())
                        .Minus(DecimalSeparatorLength)
                        .ToInt32()
                        )
                        : new DbaseIntegerDigits(Length.ToInt32());

                NegativeIntegerDigits =
                    PositiveIntegerDigits != new DbaseIntegerDigits(0)
                        ? PositiveIntegerDigits
                    .Minus(SignLength)
                        : new DbaseIntegerDigits(0);
            }
            else
            {
                PositiveIntegerDigits = new DbaseIntegerDigits(0);
                NegativeIntegerDigits = new DbaseIntegerDigits(0);
            }
        }
Ejemplo n.º 6
0
 public DbaseField At(ByteOffset offset) => new DbaseField(Name, FieldType, offset, Length, DecimalCount);
Ejemplo n.º 7
0
 public DbaseField At(ByteOffset offset)
 {
     return(new DbaseField(Name, FieldType, offset, Length, DecimalCount));
 }