/******************************************************************************* | |
* Copyright (C) 2017 Fondazione Bruno Kessler. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v2.0 | |
* which accompanies this distribution, and is available at | |
* http://www.eclipse.org/legal/epl-v20.html | |
* | |
* Contributors: | |
* Alberto Debiasi - initial API and implementation | |
******************************************************************************/ | |
package org.polarsys.chess.service.core.model; | |
import java.util.Set; | |
import org.eclipse.emf.common.util.BasicEList; | |
import org.eclipse.emf.common.util.EList; | |
import org.eclipse.papyrus.sysml.portandflows.FlowDirection; | |
import org.eclipse.papyrus.uml.tools.model.UmlModel; | |
import org.eclipse.uml2.uml.Constraint; | |
import org.eclipse.uml2.uml.Element; | |
import org.eclipse.uml2.uml.Port; | |
import org.eclipse.uml2.uml.Property; | |
import org.eclipse.uml2.uml.StateMachine; | |
import org.eclipse.uml2.uml.Transition; | |
import org.eclipse.uml2.uml.Type; | |
import org.eclipse.uml2.uml.Vertex; | |
import org.polarsys.chess.contracts.profile.chesscontract.util.EntityUtil; | |
import eu.fbk.eclipse.standardtools.utils.core.model.AbstractStateMachineModel; | |
public class UMLStateMachineModel implements AbstractStateMachineModel { | |
private static UMLStateMachineModel umlStateMachineModel; | |
private EntityUtil entityUtil = EntityUtil.getInstance(); | |
public static UMLStateMachineModel getInstance() { | |
if (umlStateMachineModel == null) { | |
umlStateMachineModel = new UMLStateMachineModel(); | |
} | |
return umlStateMachineModel; | |
} | |
@Override | |
public EList<Port> getOwnerInputPortsExceptEvents(Object stateMachine) { | |
Element owner = ((StateMachine) stateMachine).getOwner(); | |
return new BasicEList<Port>(entityUtil.getUmlPortsExceptEvents(owner, FlowDirection.IN_VALUE)); | |
} | |
@Override | |
public EList<Port> getOwnerOutputPortsExceptEvents(Object stateMachine) { | |
Element owner = ((StateMachine) stateMachine).getOwner(); | |
return new BasicEList<Port>(entityUtil.getUmlPortsExceptEvents(owner, FlowDirection.OUT_VALUE)); | |
} | |
/*@Override | |
public EList<Element> getOwnerAttributes(Object stateMachine) { | |
Element owner = ((StateMachine) stateMachine).getOwner(); | |
//return new BasicEList<Element>(entityUtil.getAttributesExceptPorts(owner)); | |
return null; | |
}*/ | |
@Override | |
public EList<Property> getOwnerNonStaticAttributesExceptPorts(Object stateMachine) { | |
Element owner = ((StateMachine) stateMachine).getOwner(); | |
return new BasicEList<Property>(entityUtil.getAttributesExceptPorts(owner,false)); | |
} | |
@Override | |
public EList<Property> getOwnerStaticAttributesExceptPorts(Object stateMachine) { | |
Element owner = ((StateMachine) stateMachine).getOwner(); | |
return new BasicEList<Property>(entityUtil.getAttributesExceptPorts(owner,true)); | |
} | |
@Override | |
public EList<String> getTransitionsNameList(Object stateMachine) throws Exception { | |
return entityUtil.getTransitionNameList(entityUtil.getTranstitions((StateMachine) stateMachine)); | |
} | |
@Override | |
public EList<String> getEventsNameList(Object stateMachine) { | |
EList<Port> events = entityUtil.getEventPorts(((StateMachine) stateMachine).getOwner()); | |
return (entityUtil.getPortsName(events)); | |
} | |
@Override | |
public String getStateMachineName(Object stateMachine) { | |
return (entityUtil.getStateMachineName((StateMachine) stateMachine)); | |
} | |
@Override | |
public EList<Transition> getInitTransitions(Object stateMachine) throws Exception { | |
return entityUtil.getInitialTransitions((StateMachine) stateMachine); | |
} | |
@Override | |
public EList<Transition> getNonInitTransitions(Object stateMachine) { | |
return entityUtil.getNonInitialTransitions((StateMachine) stateMachine); | |
} | |
@Override | |
public EList<String> getIntermediateStatesNameList(Object stateMachine) { | |
EList<Vertex> states = entityUtil.getIntermediateStates((StateMachine) stateMachine); | |
return entityUtil.getStatesNameList(states); | |
} | |
@Override | |
public String getTransitionName(Object transition) { | |
return entityUtil.getTransitionName((Transition) transition); | |
} | |
@Override | |
public String getTransitionNextStateName(Object transition) { | |
Vertex nextState = entityUtil.getTransitionNextState((Transition) transition); | |
return entityUtil.getStateName(nextState); | |
} | |
@Override | |
public String getTransitionStartStateName(Object transition) { | |
Vertex sourceState = entityUtil.getTransitionSourceState((Transition) transition); | |
return entityUtil.getStateName(sourceState); | |
} | |
@Override | |
public EList<String> getTransitionEventsName(Object transition) { | |
EList<Port> events = entityUtil.getTransitionEvents((Transition) transition); | |
if (events != null) { | |
return entityUtil.getPortsName(events); | |
} | |
return null; | |
} | |
@Override | |
public String getTransitionGuardCondition(Object transition, String language) { | |
return entityUtil.getTransitionGuardText((Transition) transition, language); | |
} | |
@Override | |
public boolean isFinalTransition(Object transition) { | |
return entityUtil.isFinalTransition((Transition) transition); | |
} | |
@Override | |
public boolean isTransitionWithNoEvent(Object transition) { | |
return entityUtil.isTransitionWithNoEvent((Transition) transition); | |
} | |
@Override | |
public String getAttributeName(Object property) { | |
return ((Property) property).getName(); | |
} | |
@Override | |
public Object getAttributeType(Object property) { | |
return entityUtil.getUmlType((Property) property); | |
} | |
@Override | |
public boolean isBooleanType(Object type) { | |
return entityUtil.isBooleanType((Type) type); | |
} | |
@Override | |
public boolean isIntegerType(Object type) { | |
return entityUtil.isIntegerType((Type) type); | |
} | |
@Override | |
public boolean isRealType(Object type) { | |
return entityUtil.isRealType((Type) type); | |
} | |
@Override | |
public boolean isIntervalType(Object type) { | |
return entityUtil.isRangeType((Type) type); | |
} | |
@Override | |
public boolean isInputPort(Object port) { | |
return entityUtil.isPort((Element) port) && entityUtil.isInputPort((Element) port); | |
} | |
@Override | |
public String[] getLowHighIntervalType(Object type) { | |
return entityUtil.getLowerUpperBoundsForRangeType((Type) type); | |
} | |
@Override | |
public EList<String> getEnumValues(Object type) { | |
return new BasicEList<String>(entityUtil.getListValuesForEnumeratorType((Type) type)); | |
} | |
@Override | |
public boolean isEnumType(Object type) { | |
return entityUtil.isEnumerationType((Type) type); | |
} | |
@Override | |
public String getEnumTypeName(Object type) { | |
return ((Type) type).getName(); | |
} | |
@Override | |
public String getStateMachineOwnerName(Object stateMachine) { | |
return ((org.eclipse.uml2.uml.Class) entityUtil.getOwner((StateMachine) stateMachine)).getName(); | |
} | |
@Override | |
public String getTransitionEffectText(Object transition, String language) { | |
return entityUtil.getTransitionEffectText((Transition) transition,language); | |
} | |
@Override | |
public Set<StateMachine> getNominalStateMachinesIncludingFromSubComponents(Object umlSelectedComponent) { | |
return entityUtil.getNominalStateMachines((org.eclipse.uml2.uml.Class) umlSelectedComponent, true); | |
} | |
@Override | |
public Set<StateMachine> getAllStateMachinesFromModel(Object model) { | |
return entityUtil.getNominalStateMachines((UmlModel) model); | |
} | |
@Override | |
public Object getFirstNominalStateMachine(Object umlSelectedComponent) { | |
return entityUtil.getFirstNominalStateMachine((org.eclipse.uml2.uml.Class) umlSelectedComponent); | |
} | |
@Override | |
public Object getStateMachineOwner(Object stateMachine) { | |
return entityUtil.getOwner((StateMachine) stateMachine); | |
} | |
@Override | |
public EList<String> getInitTransitionsNameList(Object stateMachine) throws Exception { | |
return entityUtil.getTransitionNameList(entityUtil.getInitialTransitions((StateMachine) stateMachine)); | |
} | |
@Override | |
public EList<String> getNonInitTransitionsNameList(Object stateMachine) throws Exception { | |
return entityUtil.getTransitionNameList(entityUtil.getNonInitialTransitions((StateMachine) stateMachine)); | |
} | |
} |