public Set execute()

in ctakes-drug-ner/src/main/java/org/apache/ctakes/drugner/fsm/machines/elements/StrengthFSM.java [159:320]
128 lines of code
24 McCabe index (conditional complexity)

	public Set execute(List tokens, Set overrideSet1, Set overrideSet2)
			throws Exception {
		Set measurementSet = new HashSet();

		// maps a fsm to a token start index
		// key = fsm , value = token start index
		Map tokenStartMap = new HashMap();

		Iterator overrideTokenItr1 = overrideSet1.iterator();
		Iterator overrideTokenItr2 = overrideSet2.iterator();
		Map overrideTokenMap1 = new HashMap();
		Map overrideTokenMap2 = new HashMap();
		Map overrideBeginTokenMap1 = new HashMap();
		Map overrideBeginTokenMap2 = new HashMap();
		while (overrideTokenItr1.hasNext()) {
			BaseToken t = (BaseToken) overrideTokenItr1.next();
			Integer key = t.getStartOffset();
			overrideTokenMap1.put(key, t);
		}

		while (overrideTokenItr2.hasNext()) {
			BaseToken t = (BaseToken) overrideTokenItr2.next();
			Integer key = t.getStartOffset();
			overrideTokenMap2.put(key, t);
		}

		boolean overrideOn1 = false;
		boolean overrideOn2 = false;
		int overrideEndOffset1 = -1;
		int overrideEndOffset2 = -1;
		int tokenOffset1 = 0;
		int tokenOffset2 = 0;
		int anchorKey1 = 0;
		int anchorKey2 = 0;
		for (int i = 0; i < tokens.size(); i++) {
			BaseToken token = (BaseToken) tokens.get(i);

			Integer key = token.getStartOffset();
			if (overrideOn1 && overrideOn2){
				if (overrideEndOffset1 >= overrideEndOffset2)
					overrideOn1 = false;
				else
					overrideOn2 = false;
			}
			if (overrideOn1) {
				if (token.getStartOffset() >= overrideEndOffset1) {
					overrideBeginTokenMap1.put( anchorKey1, tokenOffset1);
					overrideOn1 = false;
					overrideEndOffset1 = -1;
				} else {
					tokenOffset1++;
					// step to next iteration of for loop
					continue;
				}
			} else if (overrideOn2) {
				if (token.getStartOffset() >= overrideEndOffset2) {
					overrideBeginTokenMap2.put(anchorKey2, tokenOffset2);
					overrideOn2 = false;
					overrideEndOffset2 = -1;
				} else {
					tokenOffset2++;
					// step to next iteration of for loop
					continue;
				}
			} else {
				if (overrideTokenMap1.containsKey(key)) {
					// override one or more tokens until the override
					// token is complete
					anchorKey1 = key.intValue();
					token = (BaseToken) overrideTokenMap1.get(key);
					overrideOn1 = true;
					overrideEndOffset1 = token.getEndOffset();
					tokenOffset1 = 0;
				}
				if (overrideTokenMap2.containsKey(key)) {
					// override one or more tokens until the override
					// token is complete
					anchorKey2 = key.intValue();
					token = (BaseToken) overrideTokenMap2.get(key);
					overrideOn2 = true;
					overrideEndOffset2 = token.getEndOffset();
					tokenOffset2 = 0;
				}
			}

			Iterator machineItr = iv_machineSet.iterator();
			while (machineItr.hasNext()) {
				Machine fsm = (Machine) machineItr.next();

				fsm.input(token);

				State currentState = fsm.getCurrentState();
				if (currentState.getStartStateFlag()) {
					tokenStartMap.put(fsm, i);
					tokenOffset1 = 0;
					tokenOffset2 = 0;
				}
				if (currentState.getEndStateFlag()) {
					Object o = tokenStartMap.get(fsm);
					int tokenStartIndex;
					int globalOffset = 0;
					if (o == null) {
						// By default, all machines start with
						// token zero.
						tokenStartIndex = 0;
					} else {
						Integer tokenMap1 = 0;
						Integer tokenMap2 = 0;
					
						BaseToken lookUpOffset = (BaseToken) tokens.get(((Integer) o));
							
						if (overrideBeginTokenMap1.get(lookUpOffset.getStartOffset()) != null){
							Integer offSet = (Integer) (overrideBeginTokenMap1.get(lookUpOffset.getStartOffset()));
							tokenMap1 = offSet + tokenMap1;
						}
						if (overrideBeginTokenMap2.get(lookUpOffset.getStartOffset()) != null){
							Integer offSet = (Integer) (overrideBeginTokenMap2.get(lookUpOffset.getStartOffset()));
							tokenMap2 =offSet+ tokenMap2;
							}
						

						globalOffset = tokenMap1 + tokenMap2;
						tokenStartIndex = ((Integer) o) + globalOffset;
						// skip ahead over single token we don't want
						tokenStartIndex++;
					}
					
					BaseToken startToken = (BaseToken) tokens.get(tokenStartIndex);
					BaseToken endToken = null;
					if (currentState instanceof NonTerminalEndState && i > 0) {
						if (!currentState.getName().contentEquals("NON TERMINAL HYPH END"))
							endToken = (BaseToken) tokens.get(i - 1);
						else if (i > 1)
							endToken = (BaseToken) tokens.get(i - 2);
					} else {
						endToken = token;
					}
					/*if (fsm.equals(iv_strengthMachine)){
						startToken = (BaseToken) tokens	.get(tokenStartIndex+1);
					} else {*/
				//	    startToken = (BaseToken) tokens.get(tokenStartIndex);	
					//}
					StrengthToken measurementToken = new StrengthToken(startToken
							.getStartOffset(), endToken.getEndOffset());
					measurementSet.add(measurementToken);
					fsm.reset();
				}
			}
		}

		// cleanup
		tokenStartMap.clear();

		// reset machines
		Iterator itr = iv_machineSet.iterator();
		while (itr.hasNext()) {
			Machine fsm = (Machine) itr.next();
			fsm.reset();
		}

		return measurementSet;
	}