ATMLCommonLibrary.utils.ParamField.Parse C# (CSharp) Method

        public void Parse(String strParamField)
        {
            strParamField = strParamField.ToUpper();
            if (strParamField.Contains(strRange))
            {
                HasRange = true;
                if (strParamField.Contains(strContinuous) || strParamField.Contains(strBy))
                {
                    if (strParamField.Contains(strContinuous))
                    {
                        HasContinuous = true;
                        HasBy = false;
                    }
                    else
                    {
                        HasBy = true;
                        HasContinuous = false;
                    }
                }
                else
                {
                    HasContinuous = false;
                    HasBy = false;
                }
            }
            else
            {
                HasRange = false;
                HasContinuous = false;
                HasBy = false;
            }

            if (strParamField.Contains(strErrlmt))
            {
                HasErrlmt = true;
            }
            else
            {
                HasErrlmt = false;
            }

            if (HasRange)
            {
                Base = null;
                BaseFrom = new Param();
                BaseTo = new Param();

                tmpStr =
                    strParamField.Substring((strParamField.IndexOf(strRange) + strRange.Length),
                        strParamField.IndexOf(strTo) - (strParamField.IndexOf(strRange) + strRange.Length)).Trim();
                BaseFrom.Parse(tmpStr);

                if (HasContinuous || HasBy)
                {
                    if (HasContinuous)
                    {
                        tmpStr =
                            strParamField.Substring((strParamField.IndexOf(strTo) + strTo.Length),
                                strParamField.IndexOf(strContinuous) - (strParamField.IndexOf(strTo) + strTo.Length))
                                .Trim();
                    }
                    else // this.HasBy
                    {
                        tmpStr =
                            strParamField.Substring((strParamField.IndexOf(strTo) + strTo.Length),
                                strParamField.IndexOf(strBy) - (strParamField.IndexOf(strTo) + strTo.Length)).Trim();
                    }
                }
                else
                {
                    tmpStr = strParamField.Substring(strParamField.IndexOf(strTo) + strTo.Length).Trim();
                }
                BaseTo.Parse(tmpStr);

                if (HasBy)
                {
                    By = new Param();
                    if (HasErrlmt)
                    {
                        tmpStr =
                            strParamField.Substring((strParamField.IndexOf(strBy) + strBy.Length),
                                strParamField.IndexOf(strErrlmt) - (strParamField.IndexOf(strBy) + strBy.Length)).Trim();
                    }
                    else
                    {
                        tmpStr = strParamField.Substring(strParamField.IndexOf(strBy) + strBy.Length).Trim();
                    }
                    By.Parse(tmpStr);
                }
                else
                {
                    By = null;
                }
            }
            else
            {
                Base = new Param();
                BaseFrom = null;
                BaseTo = null;

                if (HasErrlmt)
                {
                    tmpStr = strParamField.Substring(0, strParamField.IndexOf(strErrlmt)).Trim();
                }
                else
                {
                    tmpStr = strParamField.Trim();
                }
                Base.Parse(tmpStr);
            }

            if (HasErrlmt)
            {
                ErrlmtPlus = new Param();
                ErrlmtMinus = new Param();

                tmpErrlmt = strParamField.Substring(strParamField.IndexOf(strErrlmt) + strErrlmt.Length).Trim();
                if (tmpErrlmt.Contains(strPlusMinus) || (tmpErrlmt.Contains(strPlus) && tmpErrlmt.Contains(strMinus)))
                {
                    if (tmpErrlmt.Contains(strPlusMinus))
                    {
                        tmpStr = tmpErrlmt.Substring(tmpErrlmt.IndexOf(strPlusMinus) + strPlusMinus.Length).Trim();
                        ErrlmtPlus.Parse(tmpStr);
                        ErrlmtMinus.Parse(tmpStr);
                    }
                    else if (tmpErrlmt.IndexOf(strPlus) < tmpErrlmt.IndexOf(strMinus))
                    {
                        tmpStr =
                            tmpErrlmt.Substring((tmpErrlmt.IndexOf(strPlus) + strPlus.Length),
                                tmpErrlmt.IndexOf(strMinus) - (tmpErrlmt.IndexOf(strPlus) + strPlus.Length)).Trim();
                        ErrlmtPlus.Parse(tmpStr);
                        tmpStr = tmpErrlmt.Substring(tmpErrlmt.IndexOf(strMinus) + strMinus.Length).Trim();
                        ErrlmtMinus.Parse(tmpStr);
                    }
                    else // tmpErrlmt.IndexOf(strMinus) < tmpErrlmt.IndexOf(strPlus)
                    {
                        tmpStr =
                            tmpErrlmt.Substring((tmpErrlmt.IndexOf(strMinus) + strMinus.Length),
                                tmpErrlmt.IndexOf(strPlus) - (tmpErrlmt.IndexOf(strMinus) + strMinus.Length)).Trim();
                        ErrlmtMinus.Parse(tmpStr);
                        tmpStr = tmpErrlmt.Substring(tmpErrlmt.IndexOf(strPlus) + strPlus.Length).Trim();
                        ErrlmtPlus.Parse(tmpStr);
                    }
                }
            }
            else
            {
                ErrlmtPlus = null;
                ErrlmtMinus = null;
            }
        }