source: branches/SimulationCore/HeuristicLab.SimulationCore.Dsl/Dsl/GeneratedCode/DomainModel.cs @ 11142

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using DslModeling = global::Microsoft.VisualStudio.Modeling;
using DslDesign = global::Microsoft.VisualStudio.Modeling.Design;
using DslDiagrams = global::Microsoft.VisualStudio.Modeling.Diagrams;
namespace HeuristicLab.SimulationCore
{
  /// <summary>
  /// DomainModel HLSimDomainModel
  /// Description for HeuristicLab.SimulationCore.HLSim
  /// </summary>
  [DslDesign::DisplayNameResource("HeuristicLab.SimulationCore.HLSimDomainModel.DisplayName", typeof(global::HeuristicLab.SimulationCore.HLSimDomainModel), "HeuristicLab.SimulationCore.GeneratedCode.DomainModelResx")]
  [DslDesign::DescriptionResource("HeuristicLab.SimulationCore.HLSimDomainModel.Description", typeof(global::HeuristicLab.SimulationCore.HLSimDomainModel), "HeuristicLab.SimulationCore.GeneratedCode.DomainModelResx")]
  [global::System.CLSCompliant(true)]
  [DslModeling::DependsOnDomainModel(typeof(global::Microsoft.VisualStudio.Modeling.CoreDomainModel))]
  [DslModeling::DependsOnDomainModel(typeof(global::Microsoft.VisualStudio.Modeling.Diagrams.CoreDesignSurfaceDomainModel))]
  [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Generated code.")]
  [DslModeling::DomainObjectId("e76b5f9b-81a1-45f0-ac20-8a25077fff36")]
  public partial class HLSimDomainModel : DslModeling::DomainModel
  {
    #region Constructor, domain model Id
  
    /// <summary>
    /// HLSimDomainModel domain model Id.
    /// </summary>
    public static readonly global::System.Guid DomainModelId = new global::System.Guid(0xe76b5f9b, 0x81a1, 0x45f0, 0xac, 0x20, 0x8a, 0x25, 0x07, 0x7f, 0xff, 0x36);
  
    /// <summary>
    /// Constructor.
    /// </summary>
    /// <param name="store">Store containing the domain model.</param>
    public HLSimDomainModel(DslModeling::Store store)
      : base(store, DomainModelId)
    {
      // Call the partial method to allow any required serialization setup to be done.
      this.InitializeSerialization(store);    
    }
    
  
    ///<Summary>
    /// Defines a partial method that will be called from the constructor to
    /// allow any necessary serialization setup to be done.
    ///</Summary>
    ///<remarks>
    /// For a DSL created with the DSL Designer wizard, an implementation of this 
    /// method will be generated in the GeneratedCode\SerializationHelper.cs class.
    ///</remarks>
    partial void InitializeSerialization(DslModeling::Store store);
  
  
    #endregion
    #region Domain model reflection
      
    /// <summary>
    /// Gets the list of generated domain model types (classes, rules, relationships).
    /// </summary>
    /// <returns>List of types.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Generated code.")] 
    protected sealed override global::System.Type[] GetGeneratedDomainModelTypes()
    {
      return new global::System.Type[]
      {
        typeof(SimulationModel),
        typeof(Activity),
        typeof(Action),
        typeof(SimulationModelHasActivities),
        typeof(SimulationModelHasActions),
        typeof(ActivityReferencesTriggers),
        typeof(ActionReferencesListeners),
        typeof(HLSimDiagram),
        typeof(Trigger),
        typeof(Listener),
        typeof(ActivityShape),
        typeof(ActionShape),
        typeof(global::HeuristicLab.SimulationCore.FixUpDiagram),
        typeof(global::HeuristicLab.SimulationCore.ConnectorRolePlayerChanged),
      };
    }
    /// <summary>
    /// Gets the list of generated domain properties.
    /// </summary>
    /// <returns>List of property data.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Generated code.")] 
    protected sealed override DomainMemberInfo[] GetGeneratedDomainProperties()
    {
      return new DomainMemberInfo[]
      {
        new DomainMemberInfo(typeof(SimulationModel), "ModelType", SimulationModel.ModelTypeDomainPropertyId, typeof(SimulationModel.ModelTypePropertyHandler)),
        new DomainMemberInfo(typeof(Activity), "Name", Activity.NameDomainPropertyId, typeof(Activity.NamePropertyHandler)),
        new DomainMemberInfo(typeof(Action), "Name", Action.NameDomainPropertyId, typeof(Action.NamePropertyHandler)),
      };
    }
    /// <summary>
    /// Gets the list of generated domain roles.
    /// </summary>
    /// <returns>List of role data.</returns>
    protected sealed override DomainRolePlayerInfo[] GetGeneratedDomainRoles()
    {
      return new DomainRolePlayerInfo[]
      {
        new DomainRolePlayerInfo(typeof(SimulationModelHasActivities), "SimulationModel", SimulationModelHasActivities.SimulationModelDomainRoleId),
        new DomainRolePlayerInfo(typeof(SimulationModelHasActivities), "Activity", SimulationModelHasActivities.ActivityDomainRoleId),
        new DomainRolePlayerInfo(typeof(SimulationModelHasActions), "SimulationModel", SimulationModelHasActions.SimulationModelDomainRoleId),
        new DomainRolePlayerInfo(typeof(SimulationModelHasActions), "Action", SimulationModelHasActions.ActionDomainRoleId),
        new DomainRolePlayerInfo(typeof(ActivityReferencesTriggers), "Activity", ActivityReferencesTriggers.ActivityDomainRoleId),
        new DomainRolePlayerInfo(typeof(ActivityReferencesTriggers), "Action", ActivityReferencesTriggers.ActionDomainRoleId),
        new DomainRolePlayerInfo(typeof(ActionReferencesListeners), "Action", ActionReferencesListeners.ActionDomainRoleId),
        new DomainRolePlayerInfo(typeof(ActionReferencesListeners), "Activity", ActionReferencesListeners.ActivityDomainRoleId),
      };
    }
    #endregion
    #region Factory methods
    private static global::System.Collections.Generic.Dictionary<global::System.Type, int> createElementMap;
  
    /// <summary>
    /// Creates an element of specified type.
    /// </summary>
    /// <param name="partition">Partition where element is to be created.</param>
    /// <param name="elementType">Element type which belongs to this domain model.</param>
    /// <param name="propertyAssignments">New element property assignments.</param>
    /// <returns>Created element.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Generated code.")] 
    public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
    {
      if (elementType == null) throw new global::System.ArgumentNullException("elementType");
  
      if (createElementMap == null)
      {
        createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(8);
        createElementMap.Add(typeof(SimulationModel), 0);
        createElementMap.Add(typeof(Activity), 1);
        createElementMap.Add(typeof(Action), 2);
        createElementMap.Add(typeof(HLSimDiagram), 3);
        createElementMap.Add(typeof(Trigger), 4);
        createElementMap.Add(typeof(Listener), 5);
        createElementMap.Add(typeof(ActivityShape), 6);
        createElementMap.Add(typeof(ActionShape), 7);
      }
      int index;
      if (!createElementMap.TryGetValue(elementType, out index))
      {
        // construct exception error message    
        string exceptionError = string.Format(
                global::System.Globalization.CultureInfo.CurrentCulture,
                global::HeuristicLab.SimulationCore.HLSimDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
                elementType.Name);
        throw new global::System.ArgumentException(exceptionError, "elementType");
      }
      switch (index)
      {
        case 0: return new SimulationModel(partition, propertyAssignments);
        case 1: return new Activity(partition, propertyAssignments);
        case 2: return new Action(partition, propertyAssignments);
        case 3: return new HLSimDiagram(partition, propertyAssignments);
        case 4: return new Trigger(partition, propertyAssignments);
        case 5: return new Listener(partition, propertyAssignments);
        case 6: return new ActivityShape(partition, propertyAssignments);
        case 7: return new ActionShape(partition, propertyAssignments);
        default: return null;
      }
    }
  
    private static global::System.Collections.Generic.Dictionary<global::System.Type, int> createElementLinkMap;
  
    /// <summary>
    /// Creates an element link of specified type.
    /// </summary>
    /// <param name="partition">Partition where element is to be created.</param>
    /// <param name="elementLinkType">Element link type which belongs to this domain model.</param>
    /// <param name="roleAssignments">List of relationship role assignments for the new link.</param>
    /// <param name="propertyAssignments">New element property assignments.</param>
    /// <returns>Created element link.</returns>
    [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
    public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
    {
      if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
      if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
  
      if (createElementLinkMap == null)
      {
        createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(4);
        createElementLinkMap.Add(typeof(SimulationModelHasActivities), 0);
        createElementLinkMap.Add(typeof(SimulationModelHasActions), 1);
        createElementLinkMap.Add(typeof(ActivityReferencesTriggers), 2);
        createElementLinkMap.Add(typeof(ActionReferencesListeners), 3);
      }
      int index;
      if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
      {
        // construct exception error message
        string exceptionError = string.Format(
                global::System.Globalization.CultureInfo.CurrentCulture,
                global::HeuristicLab.SimulationCore.HLSimDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
                elementLinkType.Name);
        throw new global::System.ArgumentException(exceptionError, "elementLinkType");
      
      }
      switch (index)
      {
        case 0: return new SimulationModelHasActivities(partition, roleAssignments, propertyAssignments);
        case 1: return new SimulationModelHasActions(partition, roleAssignments, propertyAssignments);
        case 2: return new ActivityReferencesTriggers(partition, roleAssignments, propertyAssignments);
        case 3: return new ActionReferencesListeners(partition, roleAssignments, propertyAssignments);
        default: return null;
      }
    }
    #endregion
    #region Resource manager
    
    private static global::System.Resources.ResourceManager resourceManager;
    
    /// <summary>
    /// The base name of this model's resources.
    /// </summary>
    public const string ResourceBaseName = "HeuristicLab.SimulationCore.GeneratedCode.DomainModelResx";
    
    /// <summary>
    /// Gets the DomainModel's ResourceManager. If the ResourceManager does not already exist, then it is created.
    /// </summary>
    public override global::System.Resources.ResourceManager ResourceManager
    {
      [global::System.Diagnostics.DebuggerStepThrough]
      get
      {
        return HLSimDomainModel.SingletonResourceManager;
      }
    }
  
    /// <summary>
    /// Gets the Singleton ResourceManager for this domain model.
    /// </summary>
    public static global::System.Resources.ResourceManager SingletonResourceManager
    {
      [global::System.Diagnostics.DebuggerStepThrough]
      get
      {
        if (HLSimDomainModel.resourceManager == null)
        {
          HLSimDomainModel.resourceManager = new global::System.Resources.ResourceManager(ResourceBaseName, typeof(HLSimDomainModel).Assembly);
        }
        return HLSimDomainModel.resourceManager;
      }
    }
    #endregion
    #region Copy/Remove closures
    /// <summary>
    /// CopyClosure cache
    /// </summary>
    private static DslModeling::IElementVisitorFilter copyClosure;
    /// <summary>
    /// DeleteClosure cache
    /// </summary>
    private static DslModeling::IElementVisitorFilter removeClosure;
    /// <summary>
    /// Returns an IElementVisitorFilter that corresponds to the ClosureType.
    /// </summary>
    /// <param name="type">closure type</param>
    /// <param name="rootElements">collection of root elements</param>
    /// <returns>IElementVisitorFilter or null</returns>
    public override DslModeling::IElementVisitorFilter GetClosureFilter(DslModeling::ClosureType type, global::System.Collections.Generic.ICollection<DslModeling::ModelElement> rootElements)
    {
      switch (type)
      {
        case DslModeling::ClosureType.CopyClosure:
          return HLSimDomainModel.CopyClosure;
        case DslModeling::ClosureType.DeleteClosure:
          return HLSimDomainModel.DeleteClosure;
      }
      return base.GetClosureFilter(type, rootElements);
    }
    /// <summary>
    /// CopyClosure cache
    /// </summary>
    private static DslModeling::IElementVisitorFilter CopyClosure
    {
      get
      {
        // Incorporate all of the closures from the models we extend
        if (HLSimDomainModel.copyClosure == null)
        {
          DslModeling::ChainingElementVisitorFilter copyFilter = new DslModeling::ChainingElementVisitorFilter();
          copyFilter.AddFilter(new HLSimCopyClosure());
          copyFilter.AddFilter(new DslModeling::CoreCopyClosure());
          copyFilter.AddFilter(new DslDiagrams::CoreDesignSurfaceCopyClosure());
          
          HLSimDomainModel.copyClosure = copyFilter;
        }
        return HLSimDomainModel.copyClosure;
      }
    }
    /// <summary>
    /// DeleteClosure cache
    /// </summary>
    private static DslModeling::IElementVisitorFilter DeleteClosure
    {
      get
      {
        // Incorporate all of the closures from the models we extend
        if (HLSimDomainModel.removeClosure == null)
        {
          DslModeling::ChainingElementVisitorFilter removeFilter = new DslModeling::ChainingElementVisitorFilter();
          removeFilter.AddFilter(new HLSimDeleteClosure());
          removeFilter.AddFilter(new DslModeling::CoreDeleteClosure());
          removeFilter.AddFilter(new DslDiagrams::CoreDesignSurfaceDeleteClosure());
    
          HLSimDomainModel.removeClosure = removeFilter;
        }
        return HLSimDomainModel.removeClosure;
      }
    }
    #endregion
    #region Diagram rule helpers
    /// <summary>
    /// Enables rules in this domain model related to diagram fixup for the given store.
    /// If diagram data will be loaded into the store, this method should be called first to ensure
    /// that the diagram behaves properly.
    /// </summary>
    public static void EnableDiagramRules(DslModeling::Store store)
    {
      if(store == null) throw new global::System.ArgumentNullException("store");
      
      DslModeling::RuleManager ruleManager = store.RuleManager;
      ruleManager.EnableRule(typeof(global::HeuristicLab.SimulationCore.FixUpDiagram));
      ruleManager.EnableRule(typeof(global::HeuristicLab.SimulationCore.ConnectorRolePlayerChanged));
    }
    
    /// <summary>
    /// Disables rules in this domain model related to diagram fixup for the given store.
    /// </summary>
    public static void DisableDiagramRules(DslModeling::Store store)
    {
      if(store == null) throw new global::System.ArgumentNullException("store");
      
      DslModeling::RuleManager ruleManager = store.RuleManager;
      ruleManager.DisableRule(typeof(global::HeuristicLab.SimulationCore.FixUpDiagram));
      ruleManager.DisableRule(typeof(global::HeuristicLab.SimulationCore.ConnectorRolePlayerChanged));
    }
    #endregion
  }
    
  #region Copy/Remove closure classes
  /// <summary>
  /// Remove closure visitor filter
  /// </summary>
  [global::System.CLSCompliant(true)]
  public partial class HLSimDeleteClosure : HLSimDeleteClosureBase, DslModeling::IElementVisitorFilter
  {
    /// <summary>
    /// Constructor
    /// </summary>
    public HLSimDeleteClosure() : base()
    {
    }
  }
  
  /// <summary>
  /// Base class for remove closure visitor filter
  /// </summary>
  [global::System.CLSCompliant(true)]
  public partial class HLSimDeleteClosureBase : DslModeling::IElementVisitorFilter
  {
    /// <summary>
    /// DomainRoles
    /// </summary>
    private global::System.Collections.Specialized.HybridDictionary domainRoles;
    /// <summary>
    /// Constructor
    /// </summary>
    public HLSimDeleteClosureBase()
    {
      #region Initialize DomainData Table
      DomainRoles.Add(global::HeuristicLab.SimulationCore.SimulationModelHasActivities.ActivityDomainRoleId, true);
      DomainRoles.Add(global::HeuristicLab.SimulationCore.SimulationModelHasActions.ActionDomainRoleId, true);
      #endregion
    }
    /// <summary>
    /// Called to ask the filter if a particular relationship from a source element should be included in the traversal
    /// </summary>
    /// <param name="walker">ElementWalker that is traversing the model</param>
    /// <param name="sourceElement">Model Element playing the source role</param>
    /// <param name="sourceRoleInfo">DomainRoleInfo of the role that the source element is playing in the relationship</param>
    /// <param name="domainRelationshipInfo">DomainRelationshipInfo for the ElementLink in question</param>
    /// <param name="targetRelationship">Relationship in question</param>
    /// <returns>Yes if the relationship should be traversed</returns>
    public virtual DslModeling::VisitorFilterResult ShouldVisitRelationship(DslModeling::ElementWalker walker, DslModeling::ModelElement sourceElement, DslModeling::DomainRoleInfo sourceRoleInfo, DslModeling::DomainRelationshipInfo domainRelationshipInfo, DslModeling::ElementLink targetRelationship)
    {
      return DslModeling::VisitorFilterResult.Yes;
    }
    /// <summary>
    /// Called to ask the filter if a particular role player should be Visited during traversal
    /// </summary>
    /// <param name="walker">ElementWalker that is traversing the model</param>
    /// <param name="sourceElement">Model Element playing the source role</param>
    /// <param name="elementLink">Element Link that forms the relationship to the role player in question</param>
    /// <param name="targetDomainRole">DomainRoleInfo of the target role</param>
    /// <param name="targetRolePlayer">Model Element that plays the target role in the relationship</param>
    /// <returns></returns>
    public virtual DslModeling::VisitorFilterResult ShouldVisitRolePlayer(DslModeling::ElementWalker walker, DslModeling::ModelElement sourceElement, DslModeling::ElementLink elementLink, DslModeling::DomainRoleInfo targetDomainRole, DslModeling::ModelElement targetRolePlayer)
    {
      if (targetDomainRole == null) throw new global::System.ArgumentNullException("targetDomainRole");
      return this.DomainRoles.Contains(targetDomainRole.Id) ? DslModeling::VisitorFilterResult.Yes : DslModeling::VisitorFilterResult.DoNotCare;
    }
    /// <summary>
    /// DomainRoles
    /// </summary>
    private global::System.Collections.Specialized.HybridDictionary DomainRoles
    {
      get
      {
        if (this.domainRoles == null)
        {
          this.domainRoles = new global::System.Collections.Specialized.HybridDictionary();
        }
        return this.domainRoles;
      }
    }
  
  }
  /// <summary>
  /// Copy closure visitor filter
  /// </summary>
  [global::System.CLSCompliant(true)]
  public partial class HLSimCopyClosure : HLSimCopyClosureBase, DslModeling::IElementVisitorFilter
  {
    /// <summary>
    /// Constructor
    /// </summary>
    public HLSimCopyClosure() : base()
    {
    }
  }
  /// <summary>
  /// Base class for copy closure visitor filter
  /// </summary>
  [global::System.CLSCompliant(true)]
  public partial class HLSimCopyClosureBase : DslModeling::CopyClosureFilter, DslModeling::IElementVisitorFilter
  {
    /// <summary>
    /// Constructor
    /// </summary>
    public HLSimCopyClosureBase():base()
    {
    }
  }
  #endregion
    
}