Пример #1
0
        public static MSG_SET_READER_CONFIG FromString(string str)
        {
            XmlDocument xmlDocument = new XmlDocument();

            xmlDocument.LoadXml(str);
            XmlNode             documentElement = (XmlNode)xmlDocument.DocumentElement;
            XmlNamespaceManager nsmgr           = new XmlNamespaceManager(documentElement.OwnerDocument.NameTable);

            nsmgr.AddNamespace("", "http://www.llrp.org/ltk/schema/core/encoding/xml/1.0");
            nsmgr.AddNamespace("llrp", "http://www.llrp.org/ltk/schema/core/encoding/xml/1.0");
            MSG_SET_READER_CONFIG msgSetReaderConfig = new MSG_SET_READER_CONFIG();

            try
            {
                msgSetReaderConfig.MSG_ID = Convert.ToUInt32(XmlUtil.GetNodeAttrValue(documentElement, "MessageID"));
            }
            catch
            {
            }
            string nodeValue = XmlUtil.GetNodeValue(documentElement, "ResetToFactoryDefault");

            msgSetReaderConfig.ResetToFactoryDefault = (bool)Util.ParseValueTypeFromString(nodeValue, "u1", "");
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "ReaderEventNotificationSpec", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.ReaderEventNotificationSpec = PARAM_ReaderEventNotificationSpec.FromXmlNode(xmlNodes[0]);
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "AntennaProperties", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.AntennaProperties = new PARAM_AntennaProperties[xmlNodes.Count];
                        for (int i = 0; i < xmlNodes.Count; ++i)
                        {
                            msgSetReaderConfig.AntennaProperties[i] = PARAM_AntennaProperties.FromXmlNode(xmlNodes[i]);
                        }
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "AntennaConfiguration", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.AntennaConfiguration = new PARAM_AntennaConfiguration[xmlNodes.Count];
                        for (int i = 0; i < xmlNodes.Count; ++i)
                        {
                            msgSetReaderConfig.AntennaConfiguration[i] = PARAM_AntennaConfiguration.FromXmlNode(xmlNodes[i]);
                        }
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "ROReportSpec", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.ROReportSpec = PARAM_ROReportSpec.FromXmlNode(xmlNodes[0]);
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "AccessReportSpec", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.AccessReportSpec = PARAM_AccessReportSpec.FromXmlNode(xmlNodes[0]);
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "KeepaliveSpec", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.KeepaliveSpec = PARAM_KeepaliveSpec.FromXmlNode(xmlNodes[0]);
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "GPOWriteData", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.GPOWriteData = new PARAM_GPOWriteData[xmlNodes.Count];
                        for (int i = 0; i < xmlNodes.Count; ++i)
                        {
                            msgSetReaderConfig.GPOWriteData[i] = PARAM_GPOWriteData.FromXmlNode(xmlNodes[i]);
                        }
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "GPIPortCurrentState", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.GPIPortCurrentState = new PARAM_GPIPortCurrentState[xmlNodes.Count];
                        for (int i = 0; i < xmlNodes.Count; ++i)
                        {
                            msgSetReaderConfig.GPIPortCurrentState[i] = PARAM_GPIPortCurrentState.FromXmlNode(xmlNodes[i]);
                        }
                    }
                }
            }
            catch
            {
            }
            try
            {
                XmlNodeList xmlNodes = XmlUtil.GetXmlNodes(documentElement, "EventsAndReports", nsmgr);
                if (xmlNodes != null)
                {
                    if (xmlNodes.Count != 0)
                    {
                        msgSetReaderConfig.EventsAndReports = PARAM_EventsAndReports.FromXmlNode(xmlNodes[0]);
                    }
                }
            }
            catch
            {
            }
            try
            {
                ArrayList nodeCustomChildren = XmlUtil.GetXmlNodeCustomChildren(documentElement, nsmgr);
                if (nodeCustomChildren != null)
                {
                    for (int index = 0; index < nodeCustomChildren.Count; ++index)
                    {
                        ICustom_Parameter customParameter = CustomParamDecodeFactory.DecodeXmlNodeToCustomParameter((XmlNode)nodeCustomChildren[index]);
                        if (customParameter != null)
                        {
                            msgSetReaderConfig.AddCustomParameter(customParameter);
                        }
                    }
                }
            }
            catch
            {
            }
            return(msgSetReaderConfig);
        }
Пример #2
0
        public static MSG_SET_READER_CONFIG FromBitArray(
            ref BitArray bit_array,
            ref int cursor,
            int length)
        {
            if (cursor > length)
            {
                return((MSG_SET_READER_CONFIG)null);
            }
            ArrayList             arrayList1         = new ArrayList();
            MSG_SET_READER_CONFIG msgSetReaderConfig = new MSG_SET_READER_CONFIG();

            cursor += 6;
            if ((int)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 10) != (int)msgSetReaderConfig.msgType)
            {
                cursor -= 16;
                return((MSG_SET_READER_CONFIG)null);
            }
            msgSetReaderConfig.msgLen = (uint)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 32);
            msgSetReaderConfig.msgID  = (uint)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 32);
            if (cursor > length)
            {
                throw new Exception("Input data is not a complete LLRP message");
            }
            int    field_len = 1;
            object obj;

            Util.ConvertBitArrayToObj(ref bit_array, ref cursor, out obj, typeof(bool), field_len);
            msgSetReaderConfig.ResetToFactoryDefault = (bool)obj;
            cursor += 7;
            msgSetReaderConfig.ReaderEventNotificationSpec = PARAM_ReaderEventNotificationSpec.FromBitArray(ref bit_array, ref cursor, length);
            ArrayList arrayList2 = new ArrayList();
            PARAM_AntennaProperties antennaProperties;

            while ((antennaProperties = PARAM_AntennaProperties.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList2.Add((object)antennaProperties);
            }
            if (arrayList2.Count > 0)
            {
                msgSetReaderConfig.AntennaProperties = new PARAM_AntennaProperties[arrayList2.Count];
                for (int index = 0; index < arrayList2.Count; ++index)
                {
                    msgSetReaderConfig.AntennaProperties[index] = (PARAM_AntennaProperties)arrayList2[index];
                }
            }
            ArrayList arrayList3 = new ArrayList();
            PARAM_AntennaConfiguration antennaConfiguration;

            while ((antennaConfiguration = PARAM_AntennaConfiguration.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList3.Add((object)antennaConfiguration);
            }
            if (arrayList3.Count > 0)
            {
                msgSetReaderConfig.AntennaConfiguration = new PARAM_AntennaConfiguration[arrayList3.Count];
                for (int index = 0; index < arrayList3.Count; ++index)
                {
                    msgSetReaderConfig.AntennaConfiguration[index] = (PARAM_AntennaConfiguration)arrayList3[index];
                }
            }
            msgSetReaderConfig.ROReportSpec     = PARAM_ROReportSpec.FromBitArray(ref bit_array, ref cursor, length);
            msgSetReaderConfig.AccessReportSpec = PARAM_AccessReportSpec.FromBitArray(ref bit_array, ref cursor, length);
            msgSetReaderConfig.KeepaliveSpec    = PARAM_KeepaliveSpec.FromBitArray(ref bit_array, ref cursor, length);
            ArrayList          arrayList4 = new ArrayList();
            PARAM_GPOWriteData paramGpoWriteData;

            while ((paramGpoWriteData = PARAM_GPOWriteData.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList4.Add((object)paramGpoWriteData);
            }
            if (arrayList4.Count > 0)
            {
                msgSetReaderConfig.GPOWriteData = new PARAM_GPOWriteData[arrayList4.Count];
                for (int index = 0; index < arrayList4.Count; ++index)
                {
                    msgSetReaderConfig.GPOWriteData[index] = (PARAM_GPOWriteData)arrayList4[index];
                }
            }
            ArrayList arrayList5 = new ArrayList();
            PARAM_GPIPortCurrentState portCurrentState;

            while ((portCurrentState = PARAM_GPIPortCurrentState.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList5.Add((object)portCurrentState);
            }
            if (arrayList5.Count > 0)
            {
                msgSetReaderConfig.GPIPortCurrentState = new PARAM_GPIPortCurrentState[arrayList5.Count];
                for (int index = 0; index < arrayList5.Count; ++index)
                {
                    msgSetReaderConfig.GPIPortCurrentState[index] = (PARAM_GPIPortCurrentState)arrayList5[index];
                }
            }
            msgSetReaderConfig.EventsAndReports = PARAM_EventsAndReports.FromBitArray(ref bit_array, ref cursor, length);
            int  num;
            bool flag;

            do
            {
                num  = cursor;
                flag = false;
                ICustom_Parameter customParameter = CustomParamDecodeFactory.DecodeCustomParameter(ref bit_array, ref cursor, length);
                if (customParameter != null && msgSetReaderConfig.AddCustomParameter(customParameter))
                {
                    flag = true;
                }
            }while (flag);
            cursor = num;
            return(msgSetReaderConfig);
        }
        public static MSG_GET_READER_CONFIG_RESPONSE FromBitArray(
            ref BitArray bit_array,
            ref int cursor,
            int length)
        {
            if (cursor > length)
            {
                return((MSG_GET_READER_CONFIG_RESPONSE)null);
            }
            ArrayList arrayList1 = new ArrayList();
            MSG_GET_READER_CONFIG_RESPONSE readerConfigResponse = new MSG_GET_READER_CONFIG_RESPONSE();

            cursor += 6;
            if ((int)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 10) != (int)readerConfigResponse.msgType)
            {
                cursor -= 16;
                return((MSG_GET_READER_CONFIG_RESPONSE)null);
            }
            readerConfigResponse.msgLen         = (uint)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 32);
            readerConfigResponse.msgID          = (uint)(ulong)Util.CalculateVal(ref bit_array, ref cursor, 32);
            readerConfigResponse.LLRPStatus     = PARAM_LLRPStatus.FromBitArray(ref bit_array, ref cursor, length);
            readerConfigResponse.Identification = PARAM_Identification.FromBitArray(ref bit_array, ref cursor, length);
            ArrayList arrayList2 = new ArrayList();
            PARAM_AntennaProperties antennaProperties;

            while ((antennaProperties = PARAM_AntennaProperties.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList2.Add((object)antennaProperties);
            }
            if (arrayList2.Count > 0)
            {
                readerConfigResponse.AntennaProperties = new PARAM_AntennaProperties[arrayList2.Count];
                for (int index = 0; index < arrayList2.Count; ++index)
                {
                    readerConfigResponse.AntennaProperties[index] = (PARAM_AntennaProperties)arrayList2[index];
                }
            }
            ArrayList arrayList3 = new ArrayList();
            PARAM_AntennaConfiguration antennaConfiguration;

            while ((antennaConfiguration = PARAM_AntennaConfiguration.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList3.Add((object)antennaConfiguration);
            }
            if (arrayList3.Count > 0)
            {
                readerConfigResponse.AntennaConfiguration = new PARAM_AntennaConfiguration[arrayList3.Count];
                for (int index = 0; index < arrayList3.Count; ++index)
                {
                    readerConfigResponse.AntennaConfiguration[index] = (PARAM_AntennaConfiguration)arrayList3[index];
                }
            }
            readerConfigResponse.ReaderEventNotificationSpec = PARAM_ReaderEventNotificationSpec.FromBitArray(ref bit_array, ref cursor, length);
            readerConfigResponse.ROReportSpec                = PARAM_ROReportSpec.FromBitArray(ref bit_array, ref cursor, length);
            readerConfigResponse.AccessReportSpec            = PARAM_AccessReportSpec.FromBitArray(ref bit_array, ref cursor, length);
            readerConfigResponse.LLRPConfigurationStateValue = PARAM_LLRPConfigurationStateValue.FromBitArray(ref bit_array, ref cursor, length);
            readerConfigResponse.KeepaliveSpec               = PARAM_KeepaliveSpec.FromBitArray(ref bit_array, ref cursor, length);
            ArrayList arrayList4 = new ArrayList();
            PARAM_GPIPortCurrentState portCurrentState;

            while ((portCurrentState = PARAM_GPIPortCurrentState.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList4.Add((object)portCurrentState);
            }
            if (arrayList4.Count > 0)
            {
                readerConfigResponse.GPIPortCurrentState = new PARAM_GPIPortCurrentState[arrayList4.Count];
                for (int index = 0; index < arrayList4.Count; ++index)
                {
                    readerConfigResponse.GPIPortCurrentState[index] = (PARAM_GPIPortCurrentState)arrayList4[index];
                }
            }
            ArrayList          arrayList5 = new ArrayList();
            PARAM_GPOWriteData paramGpoWriteData;

            while ((paramGpoWriteData = PARAM_GPOWriteData.FromBitArray(ref bit_array, ref cursor, length)) != null)
            {
                arrayList5.Add((object)paramGpoWriteData);
            }
            if (arrayList5.Count > 0)
            {
                readerConfigResponse.GPOWriteData = new PARAM_GPOWriteData[arrayList5.Count];
                for (int index = 0; index < arrayList5.Count; ++index)
                {
                    readerConfigResponse.GPOWriteData[index] = (PARAM_GPOWriteData)arrayList5[index];
                }
            }
            readerConfigResponse.EventsAndReports = PARAM_EventsAndReports.FromBitArray(ref bit_array, ref cursor, length);
            int  num;
            bool flag;

            do
            {
                num  = cursor;
                flag = false;
                ICustom_Parameter customParameter = CustomParamDecodeFactory.DecodeCustomParameter(ref bit_array, ref cursor, length);
                if (customParameter != null && readerConfigResponse.AddCustomParameter(customParameter))
                {
                    flag = true;
                }
            }while (flag);
            cursor = num;
            return(readerConfigResponse);
        }