/// <summary> /// Recherche de la couche immédiatement en dessous /// </summary> /// <param name="layer">The layer.</param> /// <param name="potentialLayer">The potential layer.</param> /// <returns></returns> private static SoftwareLayer GetDownestLayer(SoftwareLayer layer, SoftwareLayer potentialLayer) { // Recherche du layerPackage en dessous if (layer is InterfaceLayer) { LayerPackage layerPackage = null; foreach (LayerPackage lp in layer.SoftwareComponent.LayerPackages) { if (lp.Level < ((InterfaceLayer)layer).Level) { if (layerPackage == null || layerPackage.Level < lp.Level) { layerPackage = lp; } } } if (layerPackage != null) { List <SoftwareLayer> layers = new List <SoftwareLayer>(); foreach (SoftwareLayer sl in layerPackage.Layers) { layers.Add(sl); } // TODO a voir - On retourne tjs le 1er layer if (layers.Count == 0) { return(null); } foreach (SoftwareLayer sl in layers) { if (sl == potentialLayer) { return(potentialLayer); } } return(layers[0]); } } else { // Recherche de la couche d'interface ISortedLayer theLayer = null; foreach (AbstractLayer al in layer.SoftwareComponent.Layers) { ISortedLayer sl = al as ISortedLayer; if (sl != null && sl.Level < ((Layer)layer).Level) { if (theLayer == null || theLayer.Level < sl.Level) { theLayer = sl; } } } return(theLayer as SoftwareLayer); } return(null); }
/// <summary> /// Creates the link. /// </summary> /// <param name="clazz">The clazz.</param> /// <param name="clazz2">The clazz2.</param> /// <returns></returns> private static ElementLink CreateLink(ClassImplementation clazz, ClassImplementation clazz2) { if (clazz.Layer.Level < clazz2.Layer.Level) { Utils.Swap <ClassImplementation>(ref clazz, ref clazz2); } if (clazz.Layer.LayerPackage == clazz2.Layer.LayerPackage) { return(new ClassUsesOperations(clazz, clazz2)); } SoftwareLayer nextLayer = GetDownestLayer(clazz.Layer, clazz2.Layer); if (nextLayer is InterfaceLayer) { ServiceContract contract = CreateContract(clazz2, (InterfaceLayer)nextLayer); new ClassUsesOperations(clazz, contract); return(CreateLink(contract, clazz2)); } ClassImplementation clazz3 = CreateClass(clazz2, (Layer)nextLayer); ClassUsesOperations link = new ClassUsesOperations(clazz, clazz3); link.Scope |= ReferenceScope.Compilation; if (nextLayer == clazz2.Layer) { return(link); } return(CreateLink(clazz3, clazz2)); }
/// <summary> /// Liste de tous les types disponibles dans le modèle /// </summary> /// <param name="sourceLayer">Source à partir duquel on veut récupérer les types (null pour récupérer à partir du modelsLayer)</param> /// <param name="includeExternalTypes">Indique si on doit inclure les types externes</param> /// <returns></returns> public IList <DataType> GetAllTypes(SoftwareLayer sourceLayer, bool includeExternalTypes) { List <DataType> types = new List <DataType>(); foreach (Package package in this.Packages) { foreach (DataType clazz in package.Types) { types.Add(clazz); } } if (includeExternalTypes) { // Référence entre les couches modèles List <Guid> models = new List <Guid>(); foreach (ExternalComponent sys in this.ReferencedExternalComponents) { CandleModel model = sys.ReferencedModel; if (model != null && model.DataLayer != null) { models.Add(model.Id); types.AddRange(model.DataLayer.AllTypes); } } if (sourceLayer != null) { ExternalDataLayerVisitor visitor = new ExternalDataLayerVisitor(types, models); ReferenceWalker walker = new ReferenceWalker(ReferenceScope.Compilation, new ConfigurationMode()); walker.Traverse(visitor, sourceLayer); } } return(types); }
/// <summary> /// Merges the disconnect layer. /// </summary> /// <param name="sourceElement">The source element.</param> private void MergeDisconnectLayer(Microsoft.VisualStudio.Modeling.ModelElement sourceElement) { SoftwareLayer layer = sourceElement as SoftwareLayer; if (layer != null) { foreach (ElementLink link in SoftwareComponentHasLayers.GetLinks(this, layer)) { // Delete the link, but without possible delete propagation to the element since it's moving to a new location. link.Delete(SoftwareComponentHasLayers.SoftwareComponentDomainRoleId, SoftwareComponentHasLayers.SoftwareLayerDomainRoleId); } } }
protected void ValidateAssemblyNames(ValidationContext context) { string msg = "All the layers within the same Visual Studio project must have the same assembly name"; bool isValid = true; ModelElement elemInError = this; try { // Tous les projets Visual Studio de même nom doivent avoir le même nom // d'assemblie Dictionary <string, string> names = new Dictionary <string, string>(); foreach (AbstractLayer layer in Layers) { SoftwareLayer slayer = layer as SoftwareLayer; if (slayer == null) { continue; } if (names.ContainsKey(slayer.VSProjectName)) { if (!Utils.StringCompareEquals(names[slayer.VSProjectName], slayer.AssemblyName)) { isValid = false; elemInError = layer; break; } } else { names[slayer.VSProjectName] = slayer.AssemblyName; } } } catch (Exception ex) { msg = ex.Message; isValid = false; } if (!isValid) { context.LogError( msg, "NMS1", // Unique error number elemInError); } }
/// <summary> /// Creates the link. /// </summary> /// <param name="contract">The contract.</param> /// <param name="targetLayer">The target layer.</param> /// <returns></returns> private static ElementLink CreateLink(ServiceContract contract, SoftwareLayer targetLayer) { InterfaceLayer iLayer = targetLayer as InterfaceLayer; Layer layer = targetLayer as Layer; Debug.Assert(iLayer != null || layer != null); int layerLevel = 0; if (layer != null) { layerLevel = layer.Level; } else if (iLayer != null) { layerLevel = iLayer.Level; } // On descend if (contract.Layer.Level > layerLevel) { // Implémentation Layer downLayer = GetDownestLayer(contract.Layer, targetLayer) as Layer; Debug.Assert(downLayer != null); ClassImplementation impl = CreateClass(contract, downLayer); Implementation link = new Implementation(impl, contract); if (downLayer == targetLayer) { return(link); } return(CreateLink(impl, targetLayer)); } else { // On monte if (layer != null) { ClassImplementation impl = CreateClass(contract, layer); return(CreateLink(contract, impl)); } // Sinon la couche destinatrice est une couche d'interface ServiceContract contract2 = CreateContract(contract, iLayer); return(CreateLink(contract, contract2)); } }
/// <summary> /// Creates the link. /// </summary> /// <param name="clazz">The clazz.</param> /// <param name="layer">The layer.</param> /// <returns></returns> private static ElementLink CreateLink(ClassImplementation clazz, SoftwareLayer layer) { if (clazz.Layer.Level > ((ISortedLayer)layer).Level) { InterfaceLayer iLayer = (InterfaceLayer)GetDownestLayer(clazz.Layer, layer); ServiceContract contract = CreateContract(clazz, iLayer); ClassUsesOperations link = new ClassUsesOperations(clazz, contract); if (iLayer == layer) { return(link); } return(CreateLink(contract, layer)); } else // On monte { if (layer is InterfaceLayer) { ServiceContract contract = CreateContract(clazz, (InterfaceLayer)layer); return(CreateLink(contract, clazz)); } ClassImplementation clazz2 = CreateClass(clazz, (Layer)layer); return(CreateLink(clazz2, clazz)); } }
public static bool CanAcceptSourceAndTarget(DslModeling::ModelElement candidateSource, DslModeling::ModelElement candidateTarget) { if (candidateSource == candidateTarget) { return(false); } if (candidateSource == null) { if (candidateTarget != null) { throw new global::System.ArgumentNullException("candidateSource"); } else // Both null { return(false); } } bool acceptSource = CanAcceptSource(candidateSource); // If the source wasn't accepted then there's no point checking targets. // If there is no target then the source controls the accept. if (!acceptSource || candidateTarget == null) { return(acceptSource); } if (!CanAcceptTarget(candidateTarget)) { return(false); } if (candidateTarget is ExternalComponent) { if (candidateSource is DataLayer) { return(DataLayerReferencesExternalComponent.GetLink((DataLayer)candidateSource, (ExternalComponent)candidateTarget) == null); } return(false); } // Assembly -> Assembly AssemblyReferencesAssemblies // Assembly -> Model DotnetPublication if (candidateSource is DotNetAssembly) { if (candidateTarget is DotNetAssembly) { return(AssemblyReferencesAssemblies.GetLink((DotNetAssembly)candidateSource, (DotNetAssembly)candidateTarget) == null); } if (candidateTarget is ExternalPublicPort) { return(ExternalServiceReference.GetLink((AbstractLayer)candidateSource, (ExternalPublicPort)candidateTarget) == null); } } // Important - Comme ExternalServiceContract hérite de ExternalPublicPort, il faut faire ce test avant if (candidateSource is ExternalServiceContract || candidateTarget is ExternalServiceContract) { if (!(candidateSource is ExternalServiceContract)) { Utils.Swap <ModelElement>(ref candidateSource, ref candidateTarget); } if (candidateTarget is ClassImplementation || candidateTarget is Scenario) { return(ClassUsesOperations.GetLinks((TypeWithOperations)candidateTarget, (ExternalServiceContract)candidateSource).Count == 0); } return(candidateTarget is SoftwareLayer); } if (candidateSource is ExternalPublicPort || candidateTarget is ExternalPublicPort) { // Contract tjs en temps que source if (!(candidateSource is ExternalPublicPort)) { Utils.Swap <ModelElement>(ref candidateSource, ref candidateTarget); } if (candidateTarget is AbstractLayer) { return(ExternalServiceReference.GetLink((AbstractLayer)candidateTarget, (ExternalPublicPort)candidateSource) == null); } } if (candidateSource is ServiceContract || candidateTarget is ServiceContract) { // Contract tjs en temps que source if (!(candidateSource is ServiceContract)) { Utils.Swap <ModelElement>(ref candidateSource, ref candidateTarget); } ServiceContract contract = candidateSource as ServiceContract; if (candidateTarget is ClassImplementation) { ClassImplementation clazz = candidateTarget as ClassImplementation; if (contract.Layer.Level > clazz.Layer.Level) { return(clazz.Contract == null); } else { return(ClassUsesOperations.GetLinks(clazz, contract).Count == 0); } } if (candidateTarget is Scenario) { SoftwareLayer iLayer = GetDownestLayer(((Scenario)candidateTarget).Layer, null); return(((ServiceContract)candidateSource).Layer == iLayer && ScenarioUsesContracts.GetLinks((Scenario)candidateTarget, (ServiceContract)candidateSource).Count == 0); } if (candidateTarget is SoftwareLayer) { int layerLevel; if (candidateTarget is Layer) { layerLevel = ((Layer)candidateTarget).Level; } else if (candidateTarget is InterfaceLayer) { layerLevel = ((InterfaceLayer)candidateTarget).Level; } else { return(false); } // Implementation if (contract.Layer.Level > layerLevel) { // Est ce qu'il y a dèjà une implémentation avec cette couche ? foreach (Implementation impl in Implementation.GetLinksToImplementations(contract)) { if (impl.ClassImplementation.Layer == ((SoftwareLayer)candidateTarget)) { return(false); // Si oui, c'est pas bon } } return(true); } // Utilise service else if (contract.Layer.Level < layerLevel) { foreach (ClassUsesOperations link in ClassUsesOperations.GetLinksToSources(contract)) { // if (link.Source.Layer == (Layer)candidateTarget) return(false); } return(true); } } } if (candidateSource is ClassImplementation) { if (candidateTarget is ClassImplementation) { //// Dans le même layer //Layer sourceLayer = ((ClassImplementation)candidateSource).Layer; //Layer targetLayer = ((ClassImplementation)candidateTarget).Layer; //if (targetLayer.LayerPackage == sourceLayer.LayerPackage) //{ // return true; //} //// Sinon il faut que ce soit la couche immédiatement en dessous //SoftwareLayer downestLayer=null; //if (sourceLayer.Level > targetLayer.Level) //{ // downestLayer = GetDownestLayer(sourceLayer, null); // return downestLayer == targetLayer; //} //else //{ // downestLayer = GetDownestLayer(targetLayer, null); // return downestLayer == sourceLayer; //} return(true); } //if (candidateTarget is Scenario) //{ // SoftwareLayer iLayer = GetDownestLayer(((Scenario)candidateTarget).Layer, null); // return ((ServiceContract)candidateSource).Layer == iLayer && ScenarioUsesContracts.GetLinks((Scenario)candidateTarget, (ClassImplementation)candidateSource).Count == 0; //} return(candidateTarget is InterfaceLayer); } return(false); }