/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List lookupImplicitAction(Pattern pattern, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(pattern, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List<Action> lookupImplicitAction(ElementPath elementPath, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(elementPath, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List lookupImplicitAction(Pattern pattern, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(pattern, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }
/** * Check if any implicit actions are applicable. As soon as an applicable * action is found, it is returned. Thus, the returned list will have at most * one element. */ List lookupImplicitAction(Pattern pattern, Attributes attributes, InterpretationContext ec) { int len = implicitActions.size(); for (int i = 0; i < len; i++) { ImplicitAction ia = (ImplicitAction) implicitActions.get(i); if (ia.isApplicable(pattern, attributes, ec)) { List<Action> actionList = new ArrayList<Action>(1); actionList.add(ia); return actionList; } } return null; }