Пример #1
0
        /// <summary>
        /// Determines whether the specified <see cref="object"/> is equal to the current <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.U4SECSItem"/>.
        /// </summary>
        /// <param name="obj">The <see cref="object"/> to compare with the current <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.U4SECSItem"/>.</param>
        /// <returns><c>true</c> if the specified <see cref="object"/> is equal to the current
        /// <see cref="T:com.CIMthetics.CSharpSECSTools.SECSItems.U4SECSItem"/>; otherwise, <c>false</c>.</returns>
	    public override bool Equals(Object obj)
	    {
	        if (this == obj)
	            return true;
	        if (obj == null)
	            return false;
	        if (GetType() != obj.GetType())
	            return false;
	        U4SECSItem other = (U4SECSItem) obj;
	        if (value != other.value)
	            return false;
	        return true;
	    }
Пример #2
0
        public override bool Equals(Object obj)
        {
            if (this == obj)
            {
                return(true);
            }
            if (obj == null)
            {
                return(false);
            }
            if (GetType() != obj.GetType())
            {
                return(false);
            }
            U4SECSItem other = (U4SECSItem)obj;

            if (value != other.value)
            {
                return(false);
            }
            return(true);
        }
Пример #3
0
        /// <summary>
        /// Generates a <c>SECSItem</c> from data in &quot;wire/transmission&quot; format.
        /// </summary>
        /// <returns>The resulting <c>SECSItem</c>.</returns>
        /// <param name="data">An array of bytes that is in wire/transmission format.</param>
        /// <param name="offset">The byte offset into <c>data</c> where the data for
        /// a <c>SECSITEM</c> starts.</param>
        public static SECSItem GenerateSECSItem(byte[] data, int offset)
        {
            SECSItem result = null;

            SECSItemFormatCode formatCode = SECSItemFormatCodeFunctions.GetSECSItemFormatCodeFromNumber((byte)((data[offset] >> 2) & 0x0000003F));
            int numberOfLengthBytes       = (data[offset] & 0x03);
            int incomingDataLength        = 0;

            switch (numberOfLengthBytes)
            {
            case 1:
            {
                byte[] temp = new byte[4];
                temp[0] = 0;
                temp[1] = 0;
                temp[2] = 0;
                temp[3] = data[offset + 1];

                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(temp);
                }

                incomingDataLength = BitConverter.ToInt32(temp, 0);
                break;
            }

            case 2:
            {
                byte[] temp = new byte[4];
                temp[0] = 0;
                temp[1] = 0;
                temp[2] = data[offset + 1];
                temp[3] = data[offset + 2];
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(temp);
                }

                incomingDataLength = BitConverter.ToInt32(temp, 0);
                break;
            }

            case 3:
            {
                byte[] temp = new byte[4];
                temp[0] = 0;
                temp[1] = data[offset + 1];
                temp[2] = data[offset + 2];
                temp[3] = data[offset + 3];
                if (BitConverter.IsLittleEndian)
                {
                    Array.Reverse(temp);
                }

                incomingDataLength = BitConverter.ToInt32(temp, 0);
                break;
            }
            }


            switch (formatCode)
            {
            case SECSItemFormatCode.L:
                result = new ListSECSItem(data, offset);
                break;

            case SECSItemFormatCode.B:
                result = new BinarySECSItem(data, offset);
                break;

            case SECSItemFormatCode.BO:
                if (incomingDataLength == 1)
                {
                    result = new BooleanSECSItem(data, offset);
                }
                else
                {
                    result = new BooleanArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.A:
                result = new ASCIISECSItem(data, offset);
                break;

            case SECSItemFormatCode.J8:
                break;

            case SECSItemFormatCode.C2:
                break;

            case SECSItemFormatCode.I8:
                if (incomingDataLength == 8)
                {
                    result = new I8SECSItem(data, offset);
                }
                else
                {
                    result = new I8ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.I1:
                if (incomingDataLength == 1)
                {
                    result = new I1SECSItem(data, offset);
                }
                else
                {
                    result = new I1ArraySECSItem(data, offset, 0);                             // Need to use this version because of method signature issues
                }
                break;

            case SECSItemFormatCode.I2:
                if (incomingDataLength == 2)
                {
                    result = new I2SECSItem(data, offset);
                }
                else
                {
                    result = new I2ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.I4:
                if (incomingDataLength == 4)
                {
                    result = new I4SECSItem(data, offset);
                }
                else
                {
                    result = new I4ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.F8:
                if (incomingDataLength == 8)
                {
                    result = new F8SECSItem(data, offset);
                }
                else
                {
                    result = new F8ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.F4:
                if (incomingDataLength == 4)
                {
                    result = new F4SECSItem(data, offset);
                }
                else
                {
                    result = new F4ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.U8:
                if (incomingDataLength == 8)
                {
                    result = new U8SECSItem(data, offset);
                }
                else
                {
                    result = new U8ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.U1:
                if (incomingDataLength == 1)
                {
                    result = new U1SECSItem(data, offset);
                }
                else
                {
                    result = new U1ArraySECSItem(data, offset, 0);                              // Remember to use the proper constructor for this case
                }
                break;

            case SECSItemFormatCode.U2:
                if (incomingDataLength == 2)
                {
                    result = new U2SECSItem(data, offset);
                }
                else
                {
                    result = new U2ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.U4:
                if (incomingDataLength == 4)
                {
                    result = new U4SECSItem(data, offset);
                }
                else
                {
                    result = new U4ArraySECSItem(data, offset);
                }
                break;

            case SECSItemFormatCode.UNDEFINED:
                break;

            case SECSItemFormatCode.HeaderOnly:
                break;

            default:
                break;
            }

            return(result);
        }