/// <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>
/// Gets the references.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public System.Collections.Generic.IEnumerable <ReferenceItem> GetReferences(ReferenceContext context)
{
// Si il y a des ports sélectionnés, on ne prend que ceux la + le modelsLayer
// sauf si on est en Runtime et que le modèle est une library (si cette library est dans le GAC, le layer n'a pas du proposer cette dépendance en runtime cf AbstractLayer).
if (context.Ports != null && ((context.Scope != ReferenceScope.Runtime || !this.Model.IsLibrary) || context.Scope == ReferenceScope.All))
{
foreach (Guid portId in context.Ports)
{
ServiceContract contract = this.Store.ElementDirectory.FindElement(portId) as ServiceContract;
if (contract != null)
{
yield return(new ReferenceItem(this, contract.Layer, context.IsExternal));
}
}
if (IsDataLayerExists)
{
yield return(new ReferenceItem(this, this.DataLayer, context.IsExternal));
}
}
// Sinon on prend tout
else
{
foreach (SoftwareLayer layer in this.Layers)
{
yield return(new ReferenceItem(this, layer, context.IsExternal));
}
}
}
/// <summary>
/// Creates the link.
/// </summary>
/// <param name="contract">The contract.</param>
/// <param name="contract2">The contract2.</param>
/// <returns></returns>
private static ElementLink CreateLink(ServiceContract contract, ServiceContract contract2)
{
if (contract.Layer.Level < contract2.Layer.Level)
{
Utils.Swap <ServiceContract>(ref contract, ref contract2);
}
Layer nextLayer = GetDownestLayer(contract.Layer, contract2.Layer) as Layer;
ClassImplementation clazz = CreateClass(contract, nextLayer);
new Implementation(clazz, contract);
return(CreateLink(contract2, clazz));
}
/// <summary>
/// Création d'un nouveau contrat
/// </summary>
/// <param name="port">The port.</param>
/// <param name="layer">The layer.</param>
/// <returns></returns>
private static ServiceContract CreateContract(CandleElement port, InterfaceLayer layer)
{
string name = StrategyManager.GetInstance(port.Store).NamingStrategy.CreateElementName(layer, port.RootName);
// Vérification de l'existence
foreach (ServiceContract sc in layer.ServiceContracts)
{
if (sc.Name == name)
{
return(sc);
}
}
// Sinon création avec copie des opérations
ServiceContract contract = new ServiceContract(layer.Store);
layer.ServiceContracts.Add(contract);
contract.RootName = port.RootName;
UnplacedModelHelper.RegisterNewModel(layer.Store, contract);
TypeWithOperations copiedContract = null;
if (port != null)
{
if (port is ServiceContract || port is ExternalServiceContract)
{
copiedContract = port as TypeWithOperations;
contract.Name = name;
}
else
{
ClassImplementation clazz = port as ClassImplementation;
contract.Name = StrategyManager.GetInstance(clazz.Store).NamingStrategy.CreateElementName(layer, clazz.Name);
if (clazz.Contract != null)
{
copiedContract = clazz.Contract;
}
contract.Comment = clazz.Comment;
}
}
if (copiedContract != null)
{
TypeWithOperations.CopyOperations(copiedContract, contract);
}
return(contract);
}
/// <summary>
/// Creates the link.
/// </summary>
/// <param name="contract">The contract.</param>
/// <param name="clazz">The clazz.</param>
/// <returns></returns>
private static ElementLink CreateLink(ServiceContract contract, ClassImplementation clazz)
{
// Le contrat est en dessous
if (contract.Layer.Level < clazz.Layer.Level)
{
InterfaceLayer iLayer = GetDownestLayer(clazz.Layer, contract.Layer) as InterfaceLayer;
if (iLayer == contract.Layer)
{
return(new ClassUsesOperations(clazz, contract));
}
ServiceContract contract2 = CreateContract(contract, iLayer);
new ClassUsesOperations(clazz, contract2);
return(CreateLink(contract2, contract));
//// Sélection de l'opération
//OperationSelectorDlg dlg = new OperationSelectorDlg(contract);
//if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
//{
// Operation op = dlg.SelectedOperation;
// if (op != null)
// {
// ClassUsesOperations link = new ClassUsesOperations(clazz, contract);
// link.Operation = op;
// return link;
// }
//}
//throw new CanceledByUser();
}
// Le contrat est au dessus
else
{
Layer nextLayer = GetDownestLayer(contract.Layer, clazz.Layer) as Layer;
if (nextLayer == null)
{
return(null);
}
if (nextLayer == clazz.Layer)
{
// Si c'est la couche du dessous, on donne le bon nom à l'interface
//contract.Name = StrategyManager.GetInstance(clazz.Store).NamingStrategy.CreateElementName(contract.Layer, clazz.Name);
return(new Implementation(clazz, contract));
}
ClassImplementation clazz2 = CreateClass(contract, nextLayer);
return(CreateLink(clazz2, clazz));
}
}
/// <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));
}
}
}
}
}
}
/// <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>
/// Alerts listeners when the mouse is double-clicked over the shape.
/// </summary>
/// <param name="e">The diagram point event arguments.</param>
public override void OnDoubleClick(DiagramPointEventArgs e)
{
base.OnDoubleClick(e);
// Avec shift = AdjustSize
if (Utils.IsKeyPressed(Keys.Shift))
{
using (Transaction transaction = Store.TransactionManager.BeginTransaction("Adjust size"))
{
ShapeHelper.ResizeToContent(this);
transaction.Commit();
}
return;
}
ServiceContract contract = ModelElement as ServiceContract;
if (contract != null)
{
Mapper.Instance.ShowCode(contract.Id, contract.Name, null);
}
}
/// <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);
}
/// <summary>
/// Creates the link.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="target">The target.</param>
/// <returns></returns>
private static ElementLink CreateLink(ModelElement source, ModelElement target)
{
s_initialContract = null;
// Assembly -> Assembly AssemblyReferencesAssemblies
// Assembly -> Model DotnetPublication
// Assembly -> ExternalPort ExternalServiceReference
if (source is DotNetAssembly || target is DotNetAssembly)
{
if (target is DotNetAssembly && !(source is DotNetAssembly))
{
Utils.Swap <ModelElement>(ref source, ref target);
}
return(CreateLinkFromDotNetAssembly(source, target));
}
// Important - Comme ExternalServiceContract hérite de ExternalPublicPort, il faut faire ce test avant
if (source is ExternalServiceContract || target is ExternalServiceContract)
{
// Contract tjs en temps que source
if (!(source is ExternalServiceContract))
{
Utils.Swap <ModelElement>(ref source, ref target);
}
ServiceContract contract = null;
if (target is InterfaceLayer)
{
contract = CreateContract(((ExternalServiceContract)source).ReferencedServiceContract, (InterfaceLayer)target);
target = GetDownestLayer((InterfaceLayer)target, null);
}
if (target is UIWorkflowLayer)
{
Scenario scenario = CreateScenario(((ExternalServiceContract)source).ReferencedServiceContract, (UIWorkflowLayer)target);
return(new ClassUsesOperations(scenario, (ExternalServiceContract)source));
}
if (target is Layer)
{
ClassImplementation clazz = CreateClass(((ExternalServiceContract)source).ReferencedServiceContract, (Layer)target);
if (contract != null)
{
clazz.Contract = contract;
}
target = clazz;
}
if (target is ClassImplementation || target is Scenario)
{
return(new ClassUsesOperations((TypeWithOperations)target, (ExternalServiceContract)source));
}
}
if (source is ExternalPublicPort || target is ExternalPublicPort)
{
// Contract tjs en temps que source
if (!(source is ExternalPublicPort))
{
Utils.Swap <ModelElement>(ref source, ref target);
}
if (target is AbstractLayer)
{
return(new ExternalServiceReference((AbstractLayer)target, (ExternalPublicPort)source));
}
}
if (source is ServiceContract || target is ServiceContract)
{
if (!(source is ServiceContract))
{
Utils.Swap <ModelElement>(ref source, ref target);
}
s_initialContract = source as ServiceContract;
if (target is ClassImplementation)
{
return(CreateLink(s_initialContract, (ClassImplementation)target));
}
if (target is Scenario)
{
return(new ScenarioUsesContracts((Scenario)target, (ServiceContract)source));
}
if (target is SoftwareLayer)
{
return(CreateLink(s_initialContract, (SoftwareLayer)target));
}
}
if (source is ClassImplementation)
{
if (target is ClassImplementation)
{
return(CreateLink((ClassImplementation)source, (ClassImplementation)target));
}
if (target is InterfaceLayer)
{
return(CreateLink((ClassImplementation)source, (SoftwareLayer)target));
}
if (target is ExternalServiceContract)
{
return(new ClassUsesOperations((ClassImplementation)source, (ExternalServiceContract)target));
}
}
return(null);
}