/// <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>
/// 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;
}
ClassImplementation clazz = ModelElement as ClassImplementation;
if (clazz != null)
{
Mapper.Instance.ShowCode(clazz.Id, clazz.Name, null);
}
}
/// <summary>
/// Création d'une nouvelle classe
/// </summary>
/// <param name="elem">The elem.</param>
/// <param name="layer">The layer.</param>
/// <returns></returns>
private static ClassImplementation CreateClass(CandleElement elem, Layer layer)
{
string name = StrategyManager.GetInstance(elem.Store).NamingStrategy.CreateElementName(layer, elem.RootName);
// On regarde d'abord si il n'existe pas une classe du même nom
foreach (ClassImplementation cl in layer.Classes)
{
if (cl.Name == name)
{
return(cl);
}
}
// Sinon création d'une nouvelle
ClassImplementation clazz = new ClassImplementation(layer.Store);
clazz.RootName = elem.RootName;
clazz.Name = name;
clazz.Comment = elem.Comment;
layer.Classes.Add(clazz);
UnplacedModelHelper.RegisterNewModel(layer.Store, clazz);
return(clazz);
}
/// <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);
}
