void Compile()

in edge-hub/core/src/Microsoft.Azure.Devices.Edge.Hub.Amqp/UriPathTemplate.cs [81:177]
83 lines of code
13 McCabe index (conditional complexity)

        void Compile(string template)
        {
            var templateParts = new List<TemplatePart>();
            var patternStringBuilder = new StringBuilder();
            this.variablesName = new List<string>();

            int initialCapacity = 0;

            int length = template.Length;
            int index = 0;

            while (index < length)
            {
                int varStartIndex = template.IndexOf(VariablePlaceholderStartCharacter, index);
                if (varStartIndex != -1)
                {
                    int varEndIndex = template.IndexOf(VariablePlaceholderEndCharacter, varStartIndex + 1);
                    if (varEndIndex == -1)
                    {
                        throw new InvalidOperationException("Variable definition is never closed.");
                    }

                    string varDefinition = template.Substring(varStartIndex + 1, varEndIndex - varStartIndex - 1);

                    if (varDefinition.IndexOf(VariablePlaceholderStartCharacter) != -1)
                    {
                        throw new InvalidOperationException("Variable definition syntax is invalid in template definition.");
                    }

                    int eqIndex = varDefinition.IndexOf(VariableNameValueSeparator);
                    int nameOffset;
                    if (varDefinition[0] == WildcardCharacter)
                    {
                        if (varEndIndex < length - 1)
                        {
                            throw new InvalidOperationException("Wildcard variable can only be used at the end of the template.");
                        }

                        nameOffset = 1;
                    }
                    else
                    {
                        nameOffset = 0;
                    }

                    string varName;
                    if (eqIndex == -1)
                    {
                        varName = nameOffset == 0 ? varDefinition : varDefinition.Substring(nameOffset);
                    }
                    else
                    {
                        varName = varDefinition.Substring(nameOffset, eqIndex);
                    }

                    string varDefaultValue = eqIndex == -1 ? null : varDefinition.Substring(eqIndex + 1);

                    if (varStartIndex > index)
                    {
                        int partLength = varStartIndex - index;
                        templateParts.Add(new TemplatePart(template.Substring(index, partLength)));
                        patternStringBuilder.Append(Regex.Escape(template.Substring(index, partLength)));
                        initialCapacity += partLength;
                    }

                    templateParts.Add(new TemplatePart(varName, varDefaultValue));
                    this.variablesName.Add(varName);
                    patternStringBuilder.Append("([^/]*)");
                    initialCapacity += EstimatedVariableValueLength;
                    index = varEndIndex + 1;
                }
                else
                {
                    int partLength = length - index;
                    string part = template.Substring(index, partLength);
                    templateParts.Add(new TemplatePart(part));
                    // don't escape wildcard if it is at the end of the template
                    if (part.EndsWith(WildcardCharacter.ToString()) && index + partLength == length)
                    {
                        patternStringBuilder.Append(Regex.Escape(part.Substring(0, partLength - 1)));
                        patternStringBuilder.Append(PeriodCharacter.ToString() + WildcardCharacter.ToString());
                    }
                    else
                    {
                        patternStringBuilder.Append(Regex.Escape(part));
                    }

                    initialCapacity += partLength;
                    index = length;
                }
            }

            this.parts = templateParts.ToArray();
            this.projectedLength = initialCapacity;
            patternStringBuilder.Append("$");
            this.pattern = new Regex(patternStringBuilder.ToString(), RegexOptions.Compiled | RegexOptions.IgnoreCase);
        }