private static void addFactory(UML.Extended.UMLModel model, SchemaBuilderFactory factory)
 {
     if (!instances.ContainsKey(model))
       {
       instances.Add(model, factory);
       }
 }

		/// <summary>
		/// creates a subset of the source model with only the properties and associations used in this schema
		/// </summary>
		/// <param name="destinationPackage">the package to create the subset in</param>
		public void createSubsetModel(UML.Classes.Kernel.Package destinationPackage)
		{
			//loop the elemets to create the subSetElements
			foreach (EASchemaElement schemaElement in this.elements) 
			{
				//only create subset elements for classes, not for datatypes
				if (schemaElement.sourceElement is UML.Classes.Kernel.Class)
				{
					schemaElement.createSubsetElement(destinationPackage);
					//Logger.log("after EASchema::creating single subset element");
				}
			}
			//Logger.log("after EASchema::creating subsetelements");
			// then loop them again to create the associations
			foreach (EASchemaElement schemaElement in this.elements) 
			{
				//only create subset elements for classes, not for datatypes
				if (schemaElement.sourceElement is UML.Classes.Kernel.Class)
				{
					schemaElement.createSubsetAssociations();
					//Logger.log("after EASchema::creating single subset association");
				}
				// and to resolve the attributes types to subset types if required
				schemaElement.resolveAttributetypes(this.schemaElements);
				//Logger.log("after EASchema::resolving attributes");
				//and add a dependency from the schemaElement to the type of the attributes
				schemaElement.addAttributeTypeDependencies();
				//Logger.log("after EASchema::adding attribuetypeDependencies");
			}

		}

		/// returns the singleton instance for the given model.
	    public static new EASchemaBuilderFactory getInstance(UML.UMLModel model){
	      EASchemaBuilderFactory factory = SBF.SchemaBuilderFactory.getInstance(model) as EASchemaBuilderFactory;
	      if( factory == null ) {
	      	factory = new EASchemaBuilderFactory((UTF_EA.Model)model);
	      }
	      return factory;
	    }

 getVisibility(UML.Classes.Kernel.VisibilityKind visibility) {
   switch( visibility ) {
     case UML.Classes.Kernel.VisibilityKind._private:   return "private";
     case UML.Classes.Kernel.VisibilityKind._protected: return "protected";
     case UML.Classes.Kernel.VisibilityKind._package:   return "package";
     case UML.Classes.Kernel.VisibilityKind._public:    return "public";
     default:                                           return "public";
   }
 }

 public static int getEAAggregationKind
   (UML.Classes.Kernel.AggregationKind aggregation)
 {
   switch(aggregation) {
     case UML.Classes.Kernel.AggregationKind.none:      return 0;
     case UML.Classes.Kernel.AggregationKind.shared:    return 1;
     case UML.Classes.Kernel.AggregationKind.composite: return 2;
     default:                                           return 0;
   }
 }

 /// translates the UML VisibilityKind to the string used in EA
 internal static String getEAVisibility
   (UML.Classes.Kernel.VisibilityKind visibility)
 {
   switch (visibility) {
     case UML.Classes.Kernel.VisibilityKind._private:   return "Private";
     case UML.Classes.Kernel.VisibilityKind._public:    return "Public";
     case UML.Classes.Kernel.VisibilityKind._protected: return "Protected";
     case UML.Classes.Kernel.VisibilityKind._package:   return "Package";
     default:                                           return "";
   }
 }

 internal static string getEAParameterDirectionKind
   ( UML.Classes.Kernel.ParameterDirectionKind UMLdirection )
 {
   switch (UMLdirection) {
   case UML.Classes.Kernel.ParameterDirectionKind._in:     return "in";
   case UML.Classes.Kernel.ParameterDirectionKind._out:    return "out";
   case UML.Classes.Kernel.ParameterDirectionKind._inout:  return "inout";
   case UML.Classes.Kernel.ParameterDirectionKind._return: return "return";
   default:                                                return "in";
   }
 }

		/// <summary>
		/// returns the SchemaElement that corresponds with the given UML element
		/// </summary>
		/// <param name="umlElement">the source UMLElement</param>
		/// <returns></returns>
		internal EASchemaElement getSchemaElementForUMLElement(UML.Classes.Kernel.Element umlElement)
		{
			EASchemaElement result = null;
			foreach (EASchemaElement schemaElement in this.elements) 
			{
				if (schemaElement.sourceElement.Equals(umlElement))
				{
					result = schemaElement;
				}
			}
			return result;
		}

 	/// <summary>
 	/// createas a new navigatorList based on the given list of UML Items
 	/// </summary>
 	/// <param name="items">the items to show</param>
 	public NavigatorList(List<UML.UMLItem> items, UML.UMLItem context):base()
     {
 		if (items.Count > 0)
 		{
 			this.context = context;
 			if (items[0] is UML.Diagrams.Diagram)
 			{
 				this.InitDiagrams(items.Cast<UML.Diagrams.Diagram>().ToList());
 			}
 			else
 			{
 				this.InitNamedElements(items);
 			}
 		}
 			
     }

 /// <summary>
 /// returns all tagged values that reference the given item
 /// </summary>
 /// <param name="parentItem"></param>
 /// <returns></returns>
 private List<UML.Extended.UMLItem>getDependentTaggedValues(UML.Extended.UMLItem parentItem)
 {
     List<UML.Extended.UMLItem> elementsToNavigate = new List<UML.Extended.UMLItem>();
     UML.Classes.Kernel.Element parentElement = parentItem as UML.Classes.Kernel.Element;
     if (parentElement != null)
     {
     foreach (UML.Profiles.TaggedValue taggedValue in parentElement.getReferencingTaggedValues())
     {
         //not for the "system" tagged values
         if (taggedValue.name != eaGUIDTagname
            && taggedValue.name != eaOperationGUIDTagName)
         {
             elementsToNavigate.Add(taggedValue);
         }
     }
     }
     return elementsToNavigate;
 }

   /// <summary>
   /// selects the implementation of the operation in the project browser, and opens all owned diagrams of the implementation.
   /// </summary>
   private List<UML.UMLItem> getImplementation(UML.UMLItem parentElement)
   {
   	List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
   	UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation(parentElement);
   	if (selectedOperation != null )
   	{
   		foreach ( UML.CommonBehaviors.BasicBehaviors.Behavior implementation in selectedOperation.methods)
   		{
   			//select the behavior in the project browser
	   		elementsToNavigate.AddRange(implementation.ownedDiagrams);
   		}
   	}
   	return elementsToNavigate;
   }

 /// <summary>
 /// Opens the type of the attribute
 /// </summary>
 private List<UML.UMLItem> getClassifier(UML.UMLItem parentElement)
 {
 		List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
 		UML.Classes.Kernel.Property selectedAttribute = parentElement as UML.Classes.Kernel.Property;
 		if (null != selectedAttribute)
 		{
 			elementsToNavigate.Add(selectedAttribute.type);
 		}
 		return elementsToNavigate;
 }

   /// <summary>
   /// Opens the parameters that use the selected element as type
   /// </summary>
   private List<UML.UMLItem> getParameters(UML.UMLItem parentElement)
   {
	   	List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
	   	UML.Classes.Kernel.Type selectedType = parentElement as UML.Classes.Kernel.Type;
	   	// get the parameters that use the selected classifier as type
	   	elementsToNavigate.AddRange(selectedType.getDependentTypedElements<UML.Classes.Kernel.Parameter>());
	   	return elementsToNavigate;
   }

   /// <summary>
   /// opens the CallOperationActions that call te selected operation
   /// </summary>
   private List<UML.UMLItem> getActions(UML.UMLItem parentElement)
   {
   	List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
   	UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation( parentElement);
   	if( selectedOperation != null)
   	{
		elementsToNavigate.AddRange(selectedOperation.getDependentCallOperationActions());
    }
	return elementsToNavigate;
   }

   /// <summary>
   /// Opens the types of the parameters of the selected operation
   /// </summary>
   private List<UML.UMLItem> getParameterTypes(UML.UMLItem parentElement)
   {
   		List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
	   	UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation(parentElement);
        if (selectedOperation != null)
        {
            HashSet<UML.Classes.Kernel.Parameter> parameters = selectedOperation.ownedParameters;
            foreach (UML.Classes.Kernel.Parameter parameter in parameters)
            {
                elementsToNavigate.Add(parameter.type);
            }
        }
	   	return elementsToNavigate;
   }

   /// <summary>
   /// Opens the attributes of that use the selected element as type
   /// </summary>
   private List<UML.UMLItem> getAttributes(UML.UMLItem parentElement)
   {
	   	List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
	   	UML.Classes.Kernel.Type selectedType = parentElement as UML.Classes.Kernel.Type;
	   	// get the attributes that use the selected Type as type
	   	elementsToNavigate.AddRange( selectedType.getDependentTypedElements<UML.Classes.Kernel.Property>());
	   	return elementsToNavigate;
   }

 /// <summary>
 /// get all using diagrams for the given element 
 /// currently only used for operations
 /// </summary>
 /// <param name="parentElement">the element</param>
 /// <returns>the diagrams using the given element</returns>
 private List<UML.UMLItem> getDiagrams(UML.UMLItem parentElement)
 {
     List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
 	UML.Classes.Kernel.Operation selectedOperation = this.getSelectedOperation(parentElement);
     
     if (selectedOperation != null)
     {
     	elementsToNavigate.AddRange( selectedOperation.getUsingDiagrams<UML.Diagrams.Diagram>());
     }
     return elementsToNavigate;
 }

   /// <summary>
   /// gets the operation for the parent element which can be
   /// - an operation itself
   /// - a message calling the operation
   /// - a parameter for an operation
   /// - a CallOperationAction
   /// </summary>
   /// <param name="parentElement">the element to get the operation from</param>
   /// <returns>the operation for this parent element</returns>
   private List<UML.UMLItem> getOperation(UML.UMLItem parentElement)
   {
   	   List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
   	   UML.Classes.Kernel.Operation calledOperation = null;
   	   if (parentElement is UML.Classes.Kernel.Parameter)
   	   {
   	   		calledOperation = ((UML.Classes.Kernel.Parameter)parentElement).operation;
   	   }
   	   else if (parentElement is UML.Actions.BasicActions.CallOperationAction)
   	   {
   	   		calledOperation = ((UML.Actions.BasicActions.CallOperationAction)parentElement).operation;
   	   }
   	   else
   	   {
   	   		calledOperation = this.getSelectedOperation(parentElement);
   	   }
	   if (null != calledOperation)
	   {
	   		elementsToNavigate.Add(calledOperation);
	   }
	   return elementsToNavigate;
   }

	private List<UML.UMLItem> getCompositeDiagram(UML.UMLItem parentElement)
	{
		List<UML.UMLItem> elementsToNavigate = new List<UML.UMLItem>();
   		UML.Classes.Kernel.Element selectedElement = parentElement as UML.Classes.Kernel.Element;
   		if (selectedElement != null)
   		{
   			UML.Diagrams.Diagram compositediagram = selectedElement.compositeDiagram;
   			if (compositediagram != null)
   			{
   				elementsToNavigate.Add(compositediagram);
   			}
   		}
   		return elementsToNavigate;
	}

 /// <summary>
 /// creates a list of menuoptions based on the names of tagged values that reference another UML item
 /// </summary>
 /// <param name="ownerElement">the owner of the tagged values</param>
 /// <returns>menuoptions for tagged values</returns>
 private static List<string> getTaggedValueMenuItems(UML.Classes.Kernel.Element ownerElement)
 {
 	List<string> menuItems = new List<string>();
 	foreach (UML.Profiles.TaggedValue taggedValue in ownerElement.taggedValues) 
 	{
 		if (taggedValue.tagValue is UML.UMLItem)
 		{
 			string menuName = taggedValueMenuName(taggedValue.name);
 			//we don't want the "system" tagged values ea_guid and operation_guid to show up in the navigator
 			if(menuName != taggedValueMenuName(eaGUIDTagname)
 			   && menuName != taggedValueMenuName(eaOperationGUIDTagName)
 			   && !menuItems.Contains(menuName))
 			{
 				menuItems.Add(menuName);
 			}
 		}
 	}
 	return menuItems;
 }