Subversion Repositories DevTools

      /// <summary>

      /// This processes a requirement tag for use when sorting requirements, in a way designed to overcome 

      /// the problem of sorting alphanumeric strings that contain outline numberig but that do not use

      /// leading zero's in that nunmbering, which distorts the sorting outcome in a way that is undesirable 

      /// for the human reader.

      /// The function will also work ok if the input string does not contain any numbering.

      /// The output of the function is to be used in compare operations by IComparer derived classes.

      /// </summary>

      /// <param name="sIn"></param>

      /// <param name="desiredFieldWidth"></param>

      /// <returns></returns>

      public static string OutlineNumberMunging(string sIn, int desiredFieldWidth)

      {

         // create a "fabric" filled with 0's into which we can serialise our resulting string

         const int max_str_len = 100;     // should easily be big enough for a requirement tag.

         string sOut = new string('0',max_str_len);   

         char[] sOutChArr = sOut.ToCharArray();

         int iIn = 0;

         int iOut = 0;

         while (iIn < sIn.Length && iOut < max_str_len)

         {

            if ( System.Char.IsNumber(sIn[iIn]) )

            {

               // Here we have to work out how long the number is, and determine how many leading

               // zeros to give it. We assume that the desired field width as given to us is always going 

               // to be sufficient for our needs here. If this is not the case, then the worse that can 

               // happen is that the number will have no leading zeros, and the sorting of tags may not

               // be perfect.

               int iLookAhead = iIn+1;

               while (iLookAhead < sIn.Length && System.Char.IsNumber(sIn[iLookAhead]))

               {

                  iLookAhead++;

               }

               int numberLength = iLookAhead - iIn;

               int numberOfLeadingZerosRequired = desiredFieldWidth - numberLength;

               // advance by the count of leading zeros required.

               if (numberOfLeadingZerosRequired > 0)

                  iOut += numberOfLeadingZerosRequired;

               // Serialise the number. We dont have to serialise the leading zero's because our char array 

               // was initialised with 0's to begin with.

               while(numberLength > 0 && iOut < max_str_len)

               {

                  sOutChArr[iOut++] = sIn[iIn++];  // serialise a char forming the number

                  numberLength--;

               }

            }

            else if (sIn[iIn] == '.')  // do not feed '.' chars through to the output because they can mess up the sorting of tags

            {

               iOut++;

               iIn++;

            }

            else

            {

               sOutChArr[iOut++] = sIn[iIn++];  // just serialise the char from input to output

            }

         }

         // If we did produce an output string, return it, else return the input unaltered.

         if (iOut > 0)

            return new string(sOutChArr); 

         else

            return sIn;

      }