Example #1
0
        /// <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));
        }
Example #2
0
        /// <summary>
        /// Récupére la liste des services utilisés par cette couche. Cette méthode assure que les services sont uniques.
        /// </summary>
        /// <param name="mode">Mode à prendre en compte</param>
        /// <returns></returns>
        public List <ClassUsesOperations> GetServicesUsed(ConfigurationMode mode)
        {
            List <ClassUsesOperations> services = new List <ClassUsesOperations>();
            List <TypeWithOperations>  types    = GetImplementations();

            if (types == null || types.Count == 0)
            {
                return(services);
            }

            List <Guid> doublons = new List <Guid>();

            foreach (TypeWithOperations clazz in types)
            {
                foreach (ClassUsesOperations service in ClassUsesOperations.GetLinksToServicesUsed(clazz))
                {
                    if (!mode.CheckConfigurationMode(service.ConfigurationMode) ||
                        doublons.Contains(service.TargetService.Id))
                    {
                        continue;
                    }
                    doublons.Add(service.TargetService.Id);
                    services.Add(service);
                }
            }
            return(services);
        }
Example #3
0
        /// <summary>
        /// Gets the service references.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="context">The context.</param>
        /// <param name="layers">The layers.</param>
        /// <returns></returns>
        protected IEnumerable <ReferenceItem> GetServiceReferences(TypeWithOperations item, ReferenceContext context,
                                                                   List <Guid> layers)
        {
            foreach (NamedElement service in item.ServicesUsed)
            {
                IList <ClassUsesOperations> externalServiceLinks = ClassUsesOperations.GetLinksToServicesUsed(item);
                foreach (ClassUsesOperations link in externalServiceLinks)
                {
                    if (context.Mode.CheckConfigurationMode(link.ConfigurationMode) && context.CheckScope(link.Scope))
                    {
                        if (service is ExternalServiceContract)
                        {
                            ExternalServiceContract contract = service as ExternalServiceContract;

                            // Ici on part du principe qu'un composant ne publie qu'une couche donc
                            // on ne prend en considèration que le 1er port rencontré. Si ce n'était pas le
                            // cas, il faudrait d'abord créer un tableau global des ports rencontrés PUIS faire
                            // un RetrieveReferencesForExternalComponent avec tous les ports.
                            List <Guid> ports2 = new List <Guid>();
                            ports2.Add(contract.ComponentPortMoniker);
                            yield return
                                (new ReferenceItem(this, contract.Parent, link.Scope, ports2, context.IsExternal));
                        }
                        else if (service is ServiceContract)
                        {
                            ServiceContract contract = service as ServiceContract;
                            if (!layers.Contains(contract.Layer.Id))
                            {
                                layers.Add(contract.Layer.Id);
                                yield return(new ReferenceItem(this, contract.Layer, context.IsExternal));
                            }
                        }
                        else if (service is ClassImplementation)
                        {
                            ClassImplementation targetClazz = service as ClassImplementation;
                            if (!layers.Contains(targetClazz.Layer.Id))
                            {
                                layers.Add(targetClazz.Layer.Id);
                                yield return(new ReferenceItem(this, targetClazz.Layer, context.IsExternal));
                            }
                        }
                    }
                }
            }
        }
Example #4
0
 /// <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));
     }
 }
Example #5
0
        /// <summary>
        /// Suppression des ports externes qui ne sont plus dans le modèle de référence
        /// </summary>
        /// <param name="modelPorts">The model ports.</param>
        protected void RemoveUnusedPorts(List <Guid> modelPorts)
        {
            // Suppression des inutiles
            IList <ExternalPublicPort> ports = Ports;

            while (true)
            {
                ExternalPublicPort portToDelete = null;
                foreach (ExternalPublicPort publicPort in ports)
                {
                    if (!modelPorts.Contains(publicPort.ComponentPortMoniker))
                    {
                        portToDelete = publicPort;
                        break;
                    }
                }
                if (portToDelete != null)
                {
                    // Recherche du port qui le remplace
                    ExternalPublicPort remplacant = null;
                    foreach (ExternalPublicPort newPort in Ports)
                    {
                        if (newPort.Name == portToDelete.Name && newPort != portToDelete)
                        {
                            remplacant = newPort;
                            break;
                        }
                    }
                    IList <ClassUsesOperations>      classReferences = null;
                    IList <ExternalServiceReference> layerReferences = null;

                    if (remplacant != null)
                    {
                        // Si ce port avait un lien, on essaye de le recréer sur le nouveau port du même nom
                        classReferences = ClassUsesOperations.GetLinksToSources(portToDelete);
                        layerReferences = ExternalServiceReference.GetLinksToClients(portToDelete);

                        // Suppression de l'ancien port
                        portToDelete.Delete();

                        // Re création des liens
                        if (layerReferences != null)
                        {
                            foreach (ExternalServiceReference link in layerReferences)
                            {
                                if (ReferencedModel != null)
                                {
                                    ((SoftwareLayer)link.Client).AddReferenceToService(ReferencedModel.Id,
                                                                                       ReferencedModel.Name,
                                                                                       ReferencedModel.Version,
                                                                                       portToDelete.Name);
                                }
                            }
                        }

                        if (classReferences != null)
                        {
                            foreach (ClassUsesOperations link in classReferences)
                            {
                                new ClassUsesOperations(link.Source, remplacant);
                            }
                        }
                    }
                    else
                    {
                        portToDelete.Delete();
                    }
                }
                else
                {
                    break;
                }
            }
        }
Example #6
0
        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);
        }
Example #7
0
        /// <summary>
        /// Gets the parent for class uses operations.
        /// </summary>
        /// <param name="classUsesOperations">The class uses operations.</param>
        /// <returns></returns>
        private Microsoft.VisualStudio.Modeling.ModelElement GetParentForClassUsesOperations(ClassUsesOperations classUsesOperations)
        {
            ICustomizableElement clazz = classUsesOperations.Source as ICustomizableElement;

            System.Diagnostics.Debug.Assert(clazz != null);
            return(((SoftwareLayer)clazz.Owner).Component.Model);
        }