Example #1
0
        internal override void PutObject(object Value, long RecordNumber = 0, bool ContainedInVariant = true)
        {
            this.ValidateWriteable();
            if (Value == null)
            {
                this.PutEmpty(RecordNumber);
            }
            else
            {
                Type type = Value.GetType();
                if (type == null)
                {
                    throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedIOType1", new string[1]
                    {
                        "Empty"
                    })), 5);
                }
                if (type.IsArray)
                {
                    this.PutDynamicArray(RecordNumber, (Array)Value, true, -1);
                }
                else
                {
                    if (type.IsEnum)
                    {
                        type = Enum.GetUnderlyingType(type);
                    }
                    switch (Type.GetTypeCode(type))
                    {
                    case TypeCode.DBNull:
                        this.PutShort(RecordNumber, (short)1, false);
                        break;

                    case TypeCode.Boolean:
                        this.PutBoolean(RecordNumber, BooleanType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Char:
                        this.PutChar(RecordNumber, CharType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Byte:
                        this.PutByte(RecordNumber, ByteType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Int16:
                        this.PutShort(RecordNumber, ShortType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Int32:
                        this.PutInteger(RecordNumber, IntegerType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Int64:
                        this.PutLong(RecordNumber, LongType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Single:
                        this.PutSingle(RecordNumber, SingleType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Double:
                        this.PutDouble(RecordNumber, DoubleType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.Decimal:
                        this.PutDecimal(RecordNumber, DecimalType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.DateTime:
                        this.PutDate(RecordNumber, DateType.FromObject(Value), ContainedInVariant);
                        break;

                    case TypeCode.String:
                        this.PutVariantString(RecordNumber, Value.ToString());
                        break;

                    default:
                        if (type == typeof(Missing))
                        {
                            throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedIOType1", new string[1]
                            {
                                "Missing"
                            })), 5);
                        }
                        if (type.IsValueType && !ContainedInVariant)
                        {
                            this.PutRecord(RecordNumber, (ValueType)Value);
                            break;
                        }
                        if (ContainedInVariant && type.IsValueType)
                        {
                            throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_PutObjectOfValueType1", new string[1]
                            {
                                Utils.VBFriendlyName(type, Value)
                            })), 5);
                        }
                        throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedIOType1", new string[1]
                        {
                            Utils.VBFriendlyName(type, Value)
                        })), 5);
                    }
                }
            }
        }
Example #2
0
        /// <summary>Returns an <see langword="Integer" /> value that corresponds to the specified object. </summary>
        /// <param name="Value">Required. Object to convert to an <see langword="Integer" /> value.</param>
        /// <returns>The <see langword="Integer" /> value that corresponds to <paramref name="Value" />.</returns>
        public static int FromObject(object Value)
        {
            if (Value == null)
            {
                return(0);
            }
            IConvertible ValueInterface = Value as IConvertible;

            if (ValueInterface != null)
            {
                switch (ValueInterface.GetTypeCode())
                {
                case TypeCode.Boolean:
                    return(-(ValueInterface.ToBoolean((IFormatProvider)null) ? 1 : 0));

                case TypeCode.Byte:
                    if (Value is byte)
                    {
                        return((int)(byte)Value);
                    }
                    return((int)ValueInterface.ToByte((IFormatProvider)null));

                case TypeCode.Int16:
                    if (Value is short)
                    {
                        return((int)(short)Value);
                    }
                    return((int)ValueInterface.ToInt16((IFormatProvider)null));

                case TypeCode.Int32:
                    if (Value is int)
                    {
                        return((int)Value);
                    }
                    return(ValueInterface.ToInt32((IFormatProvider)null));

                case TypeCode.Int64:
                    if (Value is long)
                    {
                        return(checked ((int)(long)Value));
                    }
                    return(checked ((int)ValueInterface.ToInt64((IFormatProvider)null)));

                case TypeCode.Single:
                    if (Value is float)
                    {
                        return(checked ((int)Math.Round((double)(float)Value)));
                    }
                    return(checked ((int)Math.Round((double)ValueInterface.ToSingle((IFormatProvider)null))));

                case TypeCode.Double:
                    if (Value is double)
                    {
                        return(checked ((int)Math.Round((double)Value)));
                    }
                    return(checked ((int)Math.Round(ValueInterface.ToDouble((IFormatProvider)null))));

                case TypeCode.Decimal:
                    return(IntegerType.DecimalToInteger(ValueInterface));

                case TypeCode.String:
                    return(IntegerType.FromString(ValueInterface.ToString((IFormatProvider)null)));
                }
            }
            throw new InvalidCastException(Utils.GetResourceString("InvalidCast_FromTo", Utils.VBFriendlyName(Value), "Integer"));
        }
Example #3
0
        public bool Callback(FieldInfo field_info, ref object vValue)
        {
            Type fieldType = field_info.FieldType;

            if (fieldType == null)
            {
                throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", field_info.Name, "Empty")), 5);
            }
            if (fieldType.IsArray)
            {
                int      FixedStringLength = -1;
                object[] customAttributes1 = field_info.GetCustomAttributes(typeof(VBFixedArrayAttribute), false);
                VBFixedArrayAttribute fixedArrayAttribute = customAttributes1 == null || customAttributes1.Length == 0 ? (VBFixedArrayAttribute)null : (VBFixedArrayAttribute)customAttributes1[0];
                Type elementType = fieldType.GetElementType();
                if (elementType == typeof(string))
                {
                    object[] customAttributes2 = field_info.GetCustomAttributes(typeof(VBFixedStringAttribute), false);
                    FixedStringLength = customAttributes2 == null || customAttributes2.Length == 0 ? -1 : ((VBFixedStringAttribute)customAttributes2[0]).Length;
                }
                if (fixedArrayAttribute == null)
                {
                    this.m_oFile.PutDynamicArray(0L, (Array)vValue, false, FixedStringLength);
                }
                else
                {
                    this.m_oFile.PutFixedArray(0L, (Array)vValue, elementType, FixedStringLength, fixedArrayAttribute.FirstBound, fixedArrayAttribute.SecondBound);
                }
            }
            else
            {
                switch (Type.GetTypeCode(fieldType))
                {
                case TypeCode.DBNull:
                    throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", field_info.Name, "DBNull")), 5);

                case TypeCode.Boolean:
                    this.m_oFile.PutBoolean(0L, BooleanType.FromObject(vValue), false);
                    break;

                case TypeCode.Char:
                    this.m_oFile.PutChar(0L, CharType.FromObject(vValue), false);
                    break;

                case TypeCode.Byte:
                    this.m_oFile.PutByte(0L, ByteType.FromObject(vValue), false);
                    break;

                case TypeCode.Int16:
                    this.m_oFile.PutShort(0L, ShortType.FromObject(vValue), false);
                    break;

                case TypeCode.Int32:
                    this.m_oFile.PutInteger(0L, IntegerType.FromObject(vValue), false);
                    break;

                case TypeCode.Int64:
                    this.m_oFile.PutLong(0L, LongType.FromObject(vValue), false);
                    break;

                case TypeCode.Single:
                    this.m_oFile.PutSingle(0L, SingleType.FromObject(vValue), false);
                    break;

                case TypeCode.Double:
                    this.m_oFile.PutDouble(0L, DoubleType.FromObject(vValue), false);
                    break;

                case TypeCode.Decimal:
                    this.m_oFile.PutDecimal(0L, DecimalType.FromObject(vValue), false);
                    break;

                case TypeCode.DateTime:
                    this.m_oFile.PutDate(0L, DateType.FromObject(vValue), false);
                    break;

                case TypeCode.String:
                    string   s = vValue == null ? (string)null : vValue.ToString();
                    object[] customAttributes = field_info.GetCustomAttributes(typeof(VBFixedStringAttribute), false);
                    if (customAttributes == null || customAttributes.Length == 0)
                    {
                        this.m_oFile.PutStringWithLength(0L, s);
                        break;
                    }
                    int lengthToWrite = ((VBFixedStringAttribute)customAttributes[0]).Length;
                    if (lengthToWrite == 0)
                    {
                        lengthToWrite = -1;
                    }
                    this.m_oFile.PutFixedLengthString(0L, s, lengthToWrite);
                    break;

                default:
                    if (fieldType == typeof(object))
                    {
                        this.m_oFile.PutObject(vValue, 0L, true);
                        break;
                    }
                    if (fieldType == typeof(Exception))
                    {
                        throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", field_info.Name, "Exception")), 5);
                    }
                    if (fieldType == typeof(Missing))
                    {
                        throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", field_info.Name, "Missing")), 5);
                    }
                    throw ExceptionUtils.VbMakeException((Exception) new ArgumentException(Utils.GetResourceString("Argument_UnsupportedFieldType2", field_info.Name, fieldType.Name)), 5);
                }
            }
            bool flag = false;

            return(flag);
        }
Example #4
0
 internal override void Input(ref int Value)
 {
     Value = IntegerType.FromObject(this.InputNum(VariantType.Integer));
 }