Building Applications with Eclipse, EMF, GMF and XMF, Part 2

@Service setStart(node)
  Root::start := node
end;
  

@Service getPath(graph)
  
  // Define a local recursive operation that
  // calculates a path ending in the terminal 
  // node...
  
  @Letrec findPath(path) =
  
    // If the path ends with the terminal node
    // then produce the path as the result of
    // findPath...
    
    if path->last = terminal
    then @Result path end
    else
    
      // Otherwise, select an edge such that the 
      // source of the edge is the last node in 
      // the path and the target of the edge 
      // has not been visited before...
      
      @Select edge 
      
        // If a subsequent selection ever fails
        // then control returns here and tries
        // another edge...
        
        from graph.getEdges()
        
        when edge.getSource() = path->last() and
             not path->includes(edge.getTarget())
             
           
        do 
           // Add the edge and the target node to the
           // path and call findPath again...
           
           findPath(path + Seq{edge,edge.getTarget()})
      end
    end 
  in 
     // Get a path...
     
     let path = @Start findPath(Seq{start}) end
     in  
        // Display the path in a text dialog...
        
        xmf.textArea("info",pathLabel(path),displayPath(path))
     end
  end
end;

context C
  // some definition

<extension point="org.eclipse.ui.popupMenus">
  <objectContribution id="ID" objectClass="cpm.diagram.edit.parts.CPM_ModelEditPart">
    <action id="getPath" label="Get Path" menubarPath="additions" class="cpm.xmf.HandleAction" enablesFor="1">
    </action>
  </objectContribution>
</extension>

public void run(IAction action) {	

  Object selected = selection.getFirstElement();

  if(selected instanceof GraphicalEditPart) {
    		
    GraphicalEditPart gep = (GraphicalEditPart)selected;
    View view = (View)gep.getModel();
    EObject eobject = view.getElement();
    		
    if (action.getId().equals("getPath"))
      calculatePath((CPM_Model)eobject);
    		
  }
}

@Service getPath(model)
  model.performPasses()
end;

   context CPM_Model
     @Operation forwardPass()
 
      // Start off at the roots and visit each event setting
      // the earliest start time...
 
      let roots = self.roots() then
          visited = roots->asSet
      in 
         // While there are some unvisited events...
         @While visited <> self.getEvents()->asSeq->asSet do
           @For event in self.getEvents() do
 
             // If all the predecessors of the selected event
             // have been visited...
 
             if self.predecessors(event)->forAll(n | 
                  visited->includes(n)) and 
                  not visited->includes(event)
             then 
 
               // Calculate the earliest time that the event could
               // occur based on the duration of the activities...
 
               let preds = self.predecessors(event);
                   earliest = 0
               in @For pred in preds do
                    @For activity in self.activitiesBetween(pred,event) do
                      earliest := earliest.max(pred.getEarliestStart() + activity.getDuration())
                    end
                  end;
 
                  // Set the earliest start time...
                  event.setEarliestStart(earliest);
 
                  // Mark this event as having been visited...
                  visited := visited->including(event)
               end
             end
           end
         end
      end
  end

context CPM_Model
  @Operation showCriticalPath()
    let path = @Start self.calculateCriticalPath() end
    in @For activity in self.getActivities() do
         activity.setLabel("")
       end;
       @For activity in path do
         activity.setLabel("critical")
       end
    end
  end
      
context CPM_Model
  @Operation calculateCriticalPath()
    @Select event from self.roots() do
      self.critical(event,Seq{})
    end
  end
      
context CPM_Model
  @Operation critical(event,path)
    if self.terminals()->includes(event)
    then @Result path end
    else
      @Select activity from self.getActivities() 
        when activity.getStartEvent() = event and
             activity.isCritical()
        do self.critical(activity.getEndEvent(),path + Seq{activity})
      end
    end
  end
 

context CPM_model
  @Constraint UniqueEventLabels
 
    // Since ->asSet will remove any duplicates, the following
    // expression checks that there are no duplicate label names...

    self.events().label->size = self.events().label->asSet->size
  fail
 
    // A fail-clause in a constraint is used to calculate a
    // message-string that is used to report the reason when
    // the constraint is not satisfied...

    let names = self.events().label then
        duplicateNames = names->asSet->select(n | names->select(nn | nn = n)->size > 1)
    in formats("The following names are duplicated: ~{,~;~S~}",Seq{duplicateNames})
    end
  end
    
context CPM_Model
  @Constraint UniqueTerminalEvent
    self.terminals()->size <= 1
  fail
    formats("Can only have a single terminal event: ~{,~;~S~}",Seq{self.terminals().label})
  end

<extension point="org.eclipse.ui.popupMenus">
  <objectContribution id="ID" objectClass="cpm.diagram.edit.parts.CPM_ModelEditPart">
    <action id="check" label="Check" menubarPath="additions" class="actions.HandleAction" enablesFor="1">
    </action>
  </objectContribution>
</extension>

@Service check(model)
 
  // Each EMFClass can be requested to 'eclipseClassify' an 
  // EMF object. This will run any constraints that have been
  // defined for the class and report the failures using the
  // Problem View in Eclipse...

  CPM_Model.eclipseClassify(model)
end;