Example #1
0
        /// <summary>
        /// Reads object
        /// </summary>
        /// <param name="abstractHessianInput">Instance of AbstractHessianInput</param>
        /// <returns>Object that was read</returns>
        public override object ReadObject(AbstractHessianInput abstractHessianInput)
        {
            int intCode = abstractHessianInput.ReadListStart();

            switch (intCode)
            {
            case CHessianProtocolConstants.PROT_NULL:
                return(null);

            case CHessianProtocolConstants.PROT_REF_TYPE:
                return(abstractHessianInput.ReadRef());
            }
            int intLength = abstractHessianInput.ReadLength();

            return(ReadList(abstractHessianInput, intLength));
        }
Example #2
0
        /// <summary>
        /// Reads objects as list
        /// <see cref="ReadList(AbstractHessianInput,int)"/>
        /// </summary>
        /// <param name="abstractHessianInput">HessianInput - Instance</param>
        /// <returns>List instance</returns>
        public override object ReadObject(AbstractHessianInput abstractHessianInput)
        {
            int intCode = abstractHessianInput.ReadListStart();

            switch (intCode)
            {
            case CHessianInput.PROT_NULL:
                return(null);

            case CHessianInput.PROT_REF_TYPE:
                return(abstractHessianInput.ReadRef());
            }
            String strType   = abstractHessianInput.ReadType();
            int    intLength = abstractHessianInput.ReadLength();

            return(ReadList(abstractHessianInput, intLength));
        }
        //public new Type GetType()
        //{
        //    switch (m_intCode)
        //    {
        //        case BOOLEAN:
        //            return typeof(bool);
        //        case BYTE:
        //            return typeof(byte);
        //        case SHORT:
        //            return typeof(short);
        //        case INTEGER:
        //            return typeof(int);
        //        case LONG:
        //            return typeof(long);
        //        case FLOAT:
        //            return typeof(float);
        //        case DOUBLE:
        //            return typeof(double);
        //        case CHARACTER:
        //            return typeof(char);
        //        case STRING:
        //            return typeof(string);
        //        case DATE:
        //            return typeof(DateTime);
        //        case BOOLEAN_ARRAY:
        //            return typeof(bool[]);
        //        case BYTE_ARRAY:
        //            return typeof(byte[]);
        //        case SHORT_ARRAY:
        //            return typeof(short[]);
        //        case INTEGER_ARRAY:
        //            return typeof(int[]);
        //        case LONG_ARRAY:
        //            return typeof(long[]);
        //        case FLOAT_ARRAY:
        //            return typeof(float[]);
        //        case DOUBLE_ARRAY:
        //            return typeof(double[]);
        //        case CHARACTER_ARRAY:
        //            return typeof(char[]);
        //        case STRING_ARRAY:
        //            return typeof(string[]);
        //        case OBJECT_ARRAY:
        //            return typeof(object[]);
        //        default:
        //            throw new InvalidOperationException();
        //    }
        //}


        #region PUBLIC_METHODS
        /// <summary>
        /// Reads the basic (primitive & Date ) data types
        /// and arrays of them
        /// </summary>
        /// <param name="abstractHessianInput">Hessian Input instance</param>
        /// <exception cref="CHessianException"/>
        /// <returns>Read object</returns>
        public override object ReadObject(AbstractHessianInput abstractHessianInput)
        {
            switch (m_intCode)
            {
            case CSerializationConstants.NULL:
            {
                // hessian/3490
                abstractHessianInput.ReadObject();
                return(null);
            }

            case BOOLEAN:
                return(abstractHessianInput.ReadBoolean());

            case BYTE:
                return((byte)abstractHessianInput.ReadInt());

            case SBYTE:
                return((sbyte)abstractHessianInput.ReadInt());

            case FLOAT:
                return((float)abstractHessianInput.ReadDouble());

            case SHORT:
                return((short)abstractHessianInput.ReadInt());

            case INTEGER:
                return(abstractHessianInput.ReadInt());

            case LONG:
                return(abstractHessianInput.ReadLong());

            case DOUBLE:
                return(abstractHessianInput.ReadDouble());

            case STRING:
                return(abstractHessianInput.ReadString());

            case CHARACTER:
            {
                //int charResult = abstractHessianInput.ReadInt();
                //return (char)charResult;
                //Bei caucho ist hier ein Bug
                //TODO:Test
                string strResult = abstractHessianInput.ReadString();
                if (strResult == null || strResult.Length == 0)
                {
                    return(null);
                }
                else
                {
                    return(strResult[0]);
                }
            }

            case BOOLEAN_ARRAY:
            case SHORT_ARRAY:
            case INTEGER_ARRAY:
            case SBYTE_ARRAY:
            case LONG_ARRAY:
            case FLOAT_ARRAY:
            case DOUBLE_ARRAY:
            case STRING_ARRAY:
            {
                int code = abstractHessianInput.ReadListStart();

                switch (code)
                {
                case 'N':
                    return(null);

                case 0x10:
                case 0x11:
                case 0x12:
                case 0x13:
                case 0x14:
                case 0x15:
                case 0x16:
                case 0x17:
                case 0x18:
                case 0x19:
                case 0x1a:
                case 0x1b:
                case 0x1c:
                case 0x1d:
                case 0x1e:
                case 0x1f:
                    int length = code - 0x10;
                    abstractHessianInput.ReadInt();

                    return(ReadLengthList(abstractHessianInput, length));

                default:
                    String type = abstractHessianInput.ReadType();
                    length = abstractHessianInput.ReadLength();
                    return(ReadList(abstractHessianInput, length));
                }
            }

            case BYTE_ARRAY:
                return(abstractHessianInput.ReadBytes());

            case CHARACTER_ARRAY:
            {
                string strResult = abstractHessianInput.ReadString();

                if (strResult == null)
                {
                    return(null);
                }
                else
                {
                    int    intLength = strResult.Length;
                    char[] arrChars  = new char[intLength];
                    arrChars = strResult.ToCharArray();
                    return(arrChars);
                }
            }

            case DATE:
                long       javaTime  = abstractHessianInput.ReadUTCDate();
                const long timeShift = 62135596800000;
                DateTime   dt        = new DateTime((javaTime + timeShift) * 10000, DateTimeKind.Utc);
                dt = dt.ToLocalTime();     // der Einfachheit halber
                return(dt);

            default:
                throw new CHessianException("not supperted type for deserialization");
            }
        }