RFID.RFIDInterface.PacketData.Parse_Fields C# (CSharp) Method

Parse_Fields() private static method

Parses a buffer that hold a packet data and updates the packet structure with data from the buffer.
private static Parse_Fields ( PacketBase obj, byte buffer, int offset, int size ) : int
obj PacketBase
buffer byte
offset int
size int
return int
        private static int Parse_Fields(PacketBase obj, byte[] buffer, int offset, int size)
        {
            int offsetLimit = offset + size;

            if (offsetLimit > buffer.Length)
                throw new rfidInvalidPacketException(rfidErrorCode.PacketDataTooSmall, buffer, 0);

            foreach (System.Reflection.FieldInfo info in obj.GetType().GetFields())
            {
                #region Parse Tracing code
            #if false
                if (info.FieldType.IsArray)
                {
                    System.Diagnostics.Debug.WriteLine(String.Format("ParseMessage:: {0}: {1}", info.FieldType.Name, info.Name), "TRACE");
                }
                else
                {
                    System.Diagnostics.Debug.WriteLine(String.Format("ParseMessage:: {0} {1}: {2} = {3}", info.IsInitOnly ? "RO" : "", info.FieldType.Name, info.Name, info.GetValue(obj).ToString()), "TRACE");
                }
            #endif
                #endregion

                switch (info.FieldType.Name)
                {

                case "Byte[]":
                    int arraySize  = 0;
                    if (info.GetValue(obj) != null) // This is for fixed length byte arrays (none right now)
                    {
                        arraySize = ((byte[])info.GetValue(obj)).Length;
                        if (offset + arraySize > offsetLimit)
                            return -1;
                        byte[] newArray = new byte[arraySize];
                        for (int i = 0; i < arraySize; i++)
                            newArray[i] = buffer[offset+i];

                        // Reverse the array if it has tag data
                        if (info.Name == "inventory_data")
                            Array.Reverse(newArray);

                        info.SetValue(obj, newArray);
                    }
                    else
                    {
                        // Variable length array (assume the rest of the packet is the data)
                        arraySize  = buffer.Length - offset;
                        byte[] newArray = new byte[arraySize];
                        for (int i = 0; i < arraySize; i++)
                            newArray[i] = buffer[offset+i];

                        info.SetValue(obj, newArray);
                    }
                    offset += arraySize;
                    //				binaryWriter.Write((byte[])info.GetValue(obj), 0, arraySize);
                    break;

                case "Byte":
                    if (offset + 1 > offsetLimit)
                        return -1;

                    if (info.IsInitOnly)
                    {
                        if ((byte)info.GetValue(obj) != (byte)buffer[offset])
                            throw new rfidInvalidPacketFieldException(info.Name, info.GetValue(obj).ToString(), buffer[offset].ToString());
                    }
                    else
                    {
                        info.SetValue(obj, buffer[offset]);
                    }
                    offset += 1;
                    break;

                case "UInt16":
                    if (offset + 2 > offsetLimit)
                        return -1;

                    if (info.IsInitOnly)
                    {
                        if ((UInt16)info.GetValue(obj) != Parse_UInt16(buffer, offset))
                            throw new rfidInvalidPacketFieldException(info.Name, info.GetValue(obj).ToString(), Parse_UInt16(buffer, offset).ToString());
                    }
                    else
                    {
                        info.SetValue(obj, Parse_UInt16(buffer, offset));
                    }
                    offset += 2;
                    break;

                case "UInt32":
                    if (offset + 4 > offsetLimit)
                        return -1;

                    if (info.IsInitOnly)
                    {
                        if ((UInt32)info.GetValue(obj) != Parse_UInt32(buffer, offset))
                            throw new rfidInvalidPacketFieldException(info.Name, info.GetValue(obj).ToString(), Parse_UInt32(buffer, offset).ToString());
                    }
                    else
                    {
                        info.SetValue(obj, Parse_UInt32(buffer, offset));
                    }
                    offset += 4;
                    break;

                case "String":
                    int strlen = Find_String_Length(obj, info);
                    if (offset + 12 > offsetLimit)
                        return -1;
                    info.SetValue(obj, Parse_String(buffer, offset, strlen));
                    offset += strlen;
                    break;

                //					case "Char[]":
                //						binaryWriter.Write((char[])info.GetValue(obj));
                //						break;

                default:
                    throw new ApplicationException("Parse_Fields Error " + info.Name + "(" + info.FieldType.Name + ") is an unsupported type.");
                }
            }
            return offset;
        }