// ReSharper disable once InconsistentNaming
        private static bool PreprocessPatternXX99XX99XX(StreetAnalysisData data,
                                                        ICollection <StreetAnalysisData> deletions,
                                                        ICollection <StreetAnalysisData> additions)
        {
            var matchLow  = RegexXX99XX99XX.Match(data.PrimaryLowNumber);
            var matchHigh = RegexXX99XX99XX.Match(data.PrimaryHighNumber);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(false);                                   // not handled
            }
            ProcessAddress(
                data,
                deletions,
                additions,
                matchLow,
                matchHigh,
                "{0}{1}{2}{3}{4}{5}",
                AddressPart.CreateAlpha("alpha1"),
                AddressPart.CreateNumeric("number1"),
                AddressPart.CreateAlpha("alpha2"),
                AddressPart.CreateNumeric("number2"),
                AddressPart.CreateAlpha("alpha3"),
                AddressPart.CreateNumeric("number3"));

            return(true);
        }
        private static bool PreprocessFractionals(
            StreetAnalysisData data, ICollection <StreetAnalysisData> deletions,
            ICollection <StreetAnalysisData> additions)
        {
            var matchLow  = RegexFractional.Match(data.PrimaryLowNumber);
            var matchHigh = RegexFractional.Match(data.PrimaryHighNumber);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(false);                                   // not handled
            }
            // There are two special cases here:
            //   1. If any of prefix, number or suffix1 is not empty, the pattern
            //      needs a space before the fraction.
            //   2. If the numberLow is empty but numberHigh is not (like 1/2::2 1/2)
            //      we need to create an extra entry for 1/2::1/2 before we let the
            //      normal expansion handle the rest.

            var prefixHigh  = matchHigh.FirstCaptureOrEmpty("prefix");
            var numberLow   = matchLow.FirstCaptureOrEmpty("number");
            var numberHigh  = matchHigh.FirstCaptureOrEmpty("number");
            var suffix1High = matchHigh.FirstCaptureOrEmpty("suffix1");

            // Case 1
            string pattern;

            if ((prefixHigh.Length == 0) && (numberHigh.Length == 0) && (suffix1High.Length == 0))
            {
                pattern = "{0}{1}{2}{3}{4}";
            }
            else
            {
                pattern = "{0}{1}{2} {3}{4}";
            }

            // Case 2
            if ((numberLow.Length == 0) && (numberHigh.Length != 0))
            {
                var toAdd = data.Clone();
                toAdd.UpdateKey        += "-00";
                toAdd.PrimaryHighNumber = toAdd.PrimaryLowNumber;
                additions.Add(toAdd);
            }

            ProcessAddress(
                data,
                deletions,
                additions,
                matchLow,
                matchHigh,
                pattern,
                AddressPart.CreateAlpha("prefix"),
                AddressPart.CreateNumeric("number"),
                AddressPart.CreateAlpha("suffix1"),
                AddressPart.CreateFraction("fraction"),
                AddressPart.CreateAlpha("suffix2"));

            return(true);
        }
        // ReSharper disable once InconsistentNaming
        private static string IncrementAddressXXHyphenXX(string low, string high,
                                                         string oddEven, ref bool stop)
        {
            var matchLow  = RegexXXHyphenXX.Match(low);
            var matchHigh = RegexXXHyphenXX.Match(high);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(null);                                   // not handled
            }
            stop = true;

            return(IncrementAddressCommon(
                       matchLow,
                       matchHigh,
                       "{0}{1}-{2}{3}",
                       oddEven,
                       AddressPart.CreateNumeric("prenumber1"),
                       AddressPart.CreateAlpha("alpha1"),
                       AddressPart.CreateAlpha("alpha2"),
                       AddressPart.CreateNumeric("postnumber1")));
        }
        private static string IncrementAddressFractionals(string low, string high,
                                                          string oddEven, ref bool stop)
        {
            var matchLow  = RegexFractional.Match(low);
            var matchHigh = RegexFractional.Match(high);

            if (!matchLow.Success || !matchHigh.Success)
            {
                return(null);                                   // not handled
            }
            stop = true;

            var prefixHigh  = matchHigh.FirstCaptureOrEmpty("prefix");
            var numberHigh  = matchHigh.FirstCaptureOrEmpty("number");
            var suffix1High = matchHigh.FirstCaptureOrEmpty("suffix1");

            string pattern;

            if ((prefixHigh.Length == 0) && (numberHigh.Length == 0) && (suffix1High.Length == 0))
            {
                pattern = "{0}{1}{2}{3}{4}";
            }
            else
            {
                pattern = "{0}{1}{2} {3}{4}";
            }

            return(IncrementAddressCommon(
                       matchLow,
                       matchHigh,
                       pattern,
                       oddEven,
                       AddressPart.CreateAlpha("prefix"),
                       AddressPart.CreateNumeric("number"),
                       AddressPart.CreateAlpha("suffix1"),
                       AddressPart.CreateFraction("fraction"),
                       AddressPart.CreateAlpha("suffix2")));
        }