/**
  * Returns the source of a relation. The source of a relation is defined as the modelelement that
  * propagates this relation. If there are more then 1 sources, only the first is returned. If
  * there is no source, null is returned. Examples of sources include classifiers that are types to
  * associationends, usecases that are bases to extend and include relations and so on.
  *
  * @param relation
  * @return MModelElement
  */
 public MModelElement getSource(MRelationship relation) {
   if (relation instanceof MAssociation) {
     MAssociation assoc = (MAssociation) relation;
     List conns = assoc.getConnections();
     if (conns.isEmpty()) return null;
     return ((MAssociationEnd) conns.get(0)).getType();
   }
   if (relation instanceof MGeneralization) {
     MGeneralization gen = (MGeneralization) relation;
     return gen.getParent();
   }
   if (relation instanceof MDependency) {
     MDependency dep = (MDependency) relation;
     Collection col = dep.getSuppliers();
     if (col.isEmpty()) return null;
     return (MModelElement) (col.toArray())[0];
   }
   if (relation instanceof MFlow) {
     MFlow flow = (MFlow) relation;
     Collection col = flow.getSources();
     if (col.isEmpty()) return null;
     return (MModelElement) (col.toArray())[0];
   }
   if (relation instanceof MExtend) {
     MExtend extend = (MExtend) relation;
     return extend.getExtension(); // we have to follow the arrows..
   }
   if (relation instanceof MInclude) {
     MInclude include = (MInclude) relation;
     return include.getBase();
   }
   return null;
 }
 /**
  * Returns the destination of a relation. The destination of a relation is defined as the
  * modelelement that receives this relation. If there are more then 1 destinations, only the first
  * is returned. If there is no destination, null is returned. Examples of sources include
  * classifiers that are types to associationends, usecases that are bases to extend and include
  * relations and so on. In the case of an association, the destination is defined as the type of
  * the second element in the connections list.
  *
  * @param relation
  * @return MModelElement
  */
 public MModelElement getDestination(MRelationship relation) {
   if (relation instanceof MAssociation) {
     MAssociation assoc = (MAssociation) relation;
     List conns = assoc.getConnections();
     if (conns.size() <= 1) return null;
     return ((MAssociationEnd) conns.get(1)).getType();
   }
   if (relation instanceof MGeneralization) {
     MGeneralization gen = (MGeneralization) relation;
     return gen.getChild();
   }
   if (relation instanceof MDependency) {
     MDependency dep = (MDependency) relation;
     Collection col = dep.getClients();
     if (col.isEmpty()) return null;
     return (MModelElement) (col.toArray())[0];
   }
   if (relation instanceof MFlow) {
     MFlow flow = (MFlow) relation;
     Collection col = flow.getTargets();
     if (col.isEmpty()) return null;
     return (MModelElement) (col.toArray())[0];
   }
   if (relation instanceof MExtend) {
     MExtend extend = (MExtend) relation;
     return extend.getBase();
   }
   if (relation instanceof MInclude) {
     MInclude include = (MInclude) relation;
     return include.getAddition();
   }
   return null;
 }
 public void gotoOther() {
   Object target = getTarget();
   if (target instanceof MAssociationEnd) {
     MAssociationEnd end = (MAssociationEnd) target;
     MAssociation assoc = end.getAssociation();
     Collection connections = assoc.getConnections();
     Iterator iter = connections.iterator();
     Object other = null;
     Object item = null;
     //
     //    always go to the one before match or to end
     //
     while (iter.hasNext()) {
       item = iter.next();
       if (item == end) {
         if (other != null) {
           navigateTo(other);
           return;
         }
       } else {
         other = item;
       }
     }
     //
     //   if previous end was the first, then navigate to the last
     navigateTo(other);
   }
 }
 /**
  * Returns the associationend between some classifier type and some associaton assoc.
  *
  * @param type
  * @param assoc
  * @return MAssociationEnd
  */
 public MAssociationEnd getAssociationEnd(MClassifier type, MAssociation assoc) {
   if (type == null || assoc == null) return null;
   Iterator it = type.getAssociationEnds().iterator();
   while (it.hasNext()) {
     MAssociationEnd end = (MAssociationEnd) it.next();
     if (assoc.getConnections().contains(end)) return end;
   }
   return null;
 }
 /**
  * Gets the associations between the classifiers from and to. Returns null if from or to is null
  * or if there is no association between them.
  *
  * @param from
  * @param to
  * @return MAssociation
  */
 public Collection getAssociations(MClassifier from, MClassifier to) {
   Set ret = new HashSet();
   if (from == null || to == null) return ret;
   Iterator it = from.getAssociationEnds().iterator();
   while (it.hasNext()) {
     MAssociationEnd end = (MAssociationEnd) it.next();
     MAssociation assoc = end.getAssociation();
     Iterator it2 = assoc.getConnections().iterator();
     while (it2.hasNext()) {
       MAssociationEnd end2 = (MAssociationEnd) it2.next();
       if (end2.getType() == to) {
         ret.add(assoc);
       }
     }
   }
   return ret;
 }
 /**
  * Gets all classifiers that are associated to the given classifier (have an association
  * relationship with the classifier).
  *
  * @param classifier
  * @return Collection
  */
 public Collection getAssociatedClassifiers(MClassifier classifier) {
   if (classifier == null) return new ArrayList();
   List list = new ArrayList();
   Iterator it = classifier.getAssociationEnds().iterator();
   while (it.hasNext()) {
     MAssociationEnd end = (MAssociationEnd) it.next();
     MAssociation assoc = end.getAssociation();
     Iterator it2 = assoc.getConnections().iterator();
     while (it2.hasNext()) {
       MAssociationEnd end2 = (MAssociationEnd) it2.next();
       if (end2 != end) {
         list.add(end2.getType());
       }
     }
   }
   return list;
 }
 private boolean isValidNamespace(MAssociation assoc, MNamespace ns) {
   Iterator it = assoc.getConnections().iterator();
   List namespaces = new ArrayList();
   while (it.hasNext()) {
     MAssociationEnd end = (MAssociationEnd) it.next();
     namespaces.add(end.getType().getNamespace());
   }
   it = namespaces.iterator();
   while (it.hasNext()) {
     MNamespace ns1 = (MNamespace) it.next();
     if (it.hasNext()) {
       MNamespace ns2 = (MNamespace) it.next();
       if (ns == getFirstSharedNamespace(ns1, ns2)) return true;
     }
   }
   return false;
 }
 /**
  * Deletes the association end. If the associationend's owner (the association) has one
  * associationend left after this delete, it is also deleted.
  */
 public void removeElement() {
   MAssociationEnd end = (MAssociationEnd) getTarget();
   MAssociation assoc = end.getAssociation();
   Collection ends = assoc.getConnections();
   if (ends.size() > 2) {
     Iterator it =
         ProjectBrowser.TheInstance.getProject()
             .findFigsForMember(end.getAssociation())
             .iterator();
     while (it.hasNext()) {
       // should do here something if the association end is shown
     }
     UmlFactory.getFactory().delete(end);
     navigateTo(assoc);
   } else {
     ProjectBrowser.TheInstance.setDetailsTarget(assoc);
     ActionRemoveFromModel.SINGLETON.actionPerformed(new ActionEvent(this, 0, null));
   }
 }
  /** Return a Fig that can be used to represent the given edge */
  public FigEdge getFigEdgeFor(GraphModel gm, Layer lay, Object edge) {
    if (edge instanceof MDependency) {

      MDependency dep = (MDependency) edge;
      FigDependency depFig = new FigDependency(dep);

      MModelElement supplier = (MModelElement) ((dep.getSuppliers().toArray())[0]);
      MModelElement client = (MModelElement) ((dep.getClients().toArray())[0]);

      FigNode supFN = (FigNode) lay.presentationFor(supplier);
      FigNode cliFN = (FigNode) lay.presentationFor(client);

      depFig.setSourcePortFig(cliFN);
      depFig.setSourceFigNode(cliFN);
      depFig.setDestPortFig(supFN);
      depFig.setDestFigNode(supFN);
      depFig.getFig().setLayer(lay);
      depFig.getFig().setDashed(true);
      return depFig;
    }

    if (edge instanceof MAssociation) {
      MAssociation asc = (MAssociation) edge;
      FigAssociation ascFig = new FigAssociation(asc, lay);
      Collection connections = asc.getConnections();
      if (connections == null) System.out.println("null connections....");
      Object[] connArray = connections.toArray();
      MAssociationEnd fromEnd = (MAssociationEnd) connArray[0];
      MClassifier fromCls = (MClassifier) fromEnd.getType();
      MAssociationEnd toEnd = (MAssociationEnd) connArray[1];
      MClassifier toCls = (MClassifier) toEnd.getType();
      FigNode fromFN = (FigNode) lay.presentationFor(fromCls);
      FigNode toFN = (FigNode) lay.presentationFor(toCls);
      ascFig.setSourcePortFig(fromFN);
      ascFig.setSourceFigNode(fromFN);
      ascFig.setDestPortFig(toFN);
      ascFig.setDestFigNode(toFN);
      ascFig.getFig().setLayer(lay);
      return ascFig;
    }
    return null;
  }
Example #10
0
  public Enumeration gen(Object o) {
      Vector res = new Vector();
    if (!(o instanceof MClassifier)) return res.elements();
    MClassifier cls = (MClassifier) o;
    Vector ends = new Vector(cls.getAssociationEnds());
    if (ends == null) return res.elements();
    Iterator enum = ends.iterator();
    while (enum.hasNext()) {
      MAssociationEnd ae = (MAssociationEnd) enum.next();
      if (MAggregationKind.COMPOSITE.equals(ae.getAggregation())) {
	MAssociation asc = ae.getAssociation();
	List conn = asc.getConnections();
	if (conn == null || conn.size() != 2) continue;
	Object otherEnd = (ae == conn.get(0)) ?
	  conn.get(1) : conn.get(0);
	MClassifier componentClass = ((MAssociationEnd)otherEnd).getType();
	res.add(componentClass);
      }
    }
    return res.elements();
  }
  public Vector getChildren(Object parent) {
    if (!(parent instanceof MClass)) return null;
    Vector res = new Vector();
    Vector ends = new Vector(((MClass)parent).getAssociationEnds());
    if (ends == null) return null;
    java.util.Enumeration enum = ends.elements();
    while (enum.hasMoreElements()) {
      MAssociationEnd ae = (MAssociationEnd) enum.nextElement();
      MAssociation asc = ae.getAssociation();
      Vector allEnds = new Vector( asc.getConnections());
      MAssociationEnd otherEnd = null;
      if (ae == allEnds.elementAt(0))
	otherEnd = (MAssociationEnd) allEnds.elementAt(1);
      if (ae == allEnds.elementAt(1))
	otherEnd = (MAssociationEnd) allEnds.elementAt(0);
      if (otherEnd == null) continue;
      if (!otherEnd.isNavigable()) continue;
      if (res.contains(otherEnd.getType())) continue;
      res.addElement(otherEnd.getType());
      // needs-more-work: handle n-way Associations
    }
    return res;
  }