Subversion Repositories DevTools

using System;
using System.Windows.Forms;
using System.Collections;
using System.IO;

namespace EA_ReqPro
{
   /// <summary>
   /// The EA_ElementSorter class has been created to allow an element collection belonging to a
   /// package to be sorted and traversed in the order implied by the view of those elements
   /// in the project browser. This is needed since the ordering of elements in the collections
   /// does not seem to match that of the project browser. Furthermore, an element can be in more
   /// than one collection, because elements themselves can have sub-elements and associated 
   /// collections yet such sub-elements also appear in the parent package collection. Confusing? 
   /// Until Sparx Systems changes the way it organises elements, we need to use this class to
   /// sort them and traverse them, unfortunately.
   /// </summary>
   public class EA_ElementSorter
        {
      private ArrayList sorted_elements;
      private ArrayList sorted_element_levels;
      private int i_sorted_elements;

      public EA_ElementSorter(EA.Package thePackage)
      {
         i_sorted_elements = 0;
         sorted_elements = new ArrayList();
         sorted_element_levels = new ArrayList();

         sortElements(thePackage); // this is where most of the work is done
      }

      /// <summary>
      /// Return the first element in the sorted and flattened list of EA elements
      /// </summary>
      /// <param name="theElement"></param>
      /// <param name="recurse_level"></param>
      /// <returns></returns>
      public bool getFirst(ref EA.Element theElement, ref int recurse_level)
      {
         i_sorted_elements = 0;
         if (i_sorted_elements < sorted_elements.Count)
         {
            theElement    = (EA.Element)sorted_elements[i_sorted_elements];
            recurse_level =  (int)sorted_element_levels[i_sorted_elements];
            return true;
         }
         return false;
      }

      /// <summary>
      /// Return the next element in the sorted and flattened list of EA elements
      /// </summary>
      /// <param name="theElement"></param>
      /// <param name="recurse_level"></param>
      /// <returns></returns>
      public bool getNext(ref EA.Element theElement, ref int recurse_level)
      {
         i_sorted_elements++;
         if (i_sorted_elements < sorted_elements.Count)
         {
            theElement    = (EA.Element)sorted_elements[i_sorted_elements];
            recurse_level =  (int)sorted_element_levels[i_sorted_elements];
            return true;
         }
         return false;
      }
   

      /// <summary>
      /// This function sorts elements that belong to a package so that they can be traversed
      /// in the order in which they appear in the project browser. This is necessary because
      /// the order in which the elements are encountered when parsing the database, bears little
      /// relationship to the order seen in the browser, and things get considerably more 
      /// complicated if elements have sub-elements in the browser, because it seems that due to 
      /// EA's internal organisation of collections, the sub-elements can be encountered more
      /// than once.
      /// This method creates an object hierarchy using the EA_ElementWrapper class and then
      /// traverses it to flatten it out into a  sorted array list of elements.
      /// </summary>
      /// <param name="thePackage"></param>
      /// <returns></returns>
      private void sortElements(EA.Package thePackage)
      {
         // Grab a hold of all the elements under this package. This will include sub-elements to elements
         // because even those sub-elements still belong to this package and its element collection.
         ArrayList unsorted_elements = new ArrayList();
         foreach(EA.Element theElement in thePackage.Elements)
         {
            unsorted_elements.Add(theElement);
         }
      
         // Begin to build a hierarchical representation of the elements, first by getting all the elements
         // that do not have a ParentID (ie. elements that are not themselves sub-elements of other elements).
         ArrayList element_wrappers = new ArrayList();

         int i;
         for (i = 0; i < unsorted_elements.Count; )
         {
            object obj = unsorted_elements[i];

            if ( ((EA.Element)obj).ParentID == 0 )
            {
               EA_ElementWrapper element_wrapper = new EA_ElementWrapper( (EA.Element)obj );
               element_wrappers.Add( element_wrapper );
               unsorted_elements.RemoveAt(i);
               continue;
            }
            i++;
         }
   
         // Now go through the remaining elements (if any), which will all be sub-elements of other elements
         // in order to pull them out of the unsorted list and place them at the correct place in the 
         // element hierarchy. Multiple passes of this will ensure that the unsorted element list is
         // eventually exhausted, but nevertheless, we protect against an infinite loop condition anyway.
         int lastCount = -1;  // variable to ensure loop is not infinite
         while (unsorted_elements.Count > 0 && lastCount != unsorted_elements.Count)
         {
            lastCount = unsorted_elements.Count;

            // Attempt to extract more unsorted elements and add them to the hiearchically sorted data
            for (i = 0; i < unsorted_elements.Count; )
            {
               object obj = unsorted_elements[i];

               // Try and find the correct place in the hiearchy where this unsorted element can be appended.
               EA_ElementWrapper found_element_wrapper = null;
               foreach(EA_ElementWrapper element_wrapper in element_wrappers)
               {
                  found_element_wrapper = findElementWrapper(element_wrapper, ((EA.Element)obj).ParentID );
                  if (found_element_wrapper != null)
                     break;
               }

               // If we found the correct place in the hierarchy, append it, and remove it from the 
               // unsorted element list.
               if (found_element_wrapper != null)
               {
                  EA_ElementWrapper element_wrapper = new EA_ElementWrapper( (EA.Element)obj );
                  found_element_wrapper.sub_elements.Add( element_wrapper );
                  unsorted_elements.RemoveAt(i);
                  continue;
               }

               i++;
            }
         }
         // TODO
         // What should we do if unsorted_elements.Count is still > 0?

         // Now flatten the hierarchically sorted results into a simple ArrayList.
         foreach(EA_ElementWrapper element_wrapper in element_wrappers)
         {
            parseElementWrapperForFlattening( element_wrapper, 0 );
         }
      }

      /// <summary>
      /// A recursive EA_ElementWrapper parser that builds a flattened list of EA elements
      /// </summary>
      /// <param name="element_wrapper"></param>
      /// <param name="recurse_level"></param>
      private void parseElementWrapperForFlattening(EA_ElementWrapper element_wrapper, int recurse_level)
      {
         sorted_elements.Add(element_wrapper.m_element);
         sorted_element_levels.Add(recurse_level);

         foreach(object obj in element_wrapper.sub_elements)
         {
            parseElementWrapperForFlattening( (EA_ElementWrapper)obj, recurse_level+1 );
         }
      }

      /// <summary>
      /// A recursive EA_ElementWrapper parser, that matches an object to a specified elementId
      /// </summary>
      /// <param name="thisElementWrapper"></param>
      /// <param name="elementId"></param>
      /// <returns></returns>
      private EA_ElementWrapper findElementWrapper(EA_ElementWrapper thisElementWrapper, int elementId)
      {
         // If this element wrapper itself is the target, then return it
         if (thisElementWrapper.m_element.ElementID == elementId)
         {
            return thisElementWrapper;
         }

         // otherwise, look through all this element's sub-elements, and each sub-element's sub-elements, etc, etc
         foreach (object obj in thisElementWrapper.sub_elements)
         {
            EA_ElementWrapper found = findElementWrapper( (EA_ElementWrapper)obj, elementId );
            if (found != null)
               return found;
         }
         return null;
      }

   }

   /// <summary>
   /// A wrapper class for an EA element that allows that element to be the holder of a collection
   /// of sub-elements. This allows us to build a hierarchical structure of elements that mirrors 
   /// the structure (aka. indentation) of elements as seen in the project browser, where elements
   /// are implied to be sub-elements to other elements etc. 
   /// </summary>
   public class EA_ElementWrapper
   {
      public EA.Element m_element;
      public ArrayList sub_elements;

      public EA_ElementWrapper(EA.Element element)
      {
         m_element = element;
         sub_elements = new ArrayList();
      }
   }
}