Examples of org.apache.ctakes.core.fsm.token.BaseToken

Package org.apache.ctakes.core.fsm.token

Examples of org.apache.ctakes.core.fsm.token.BaseToken

org.apache.ctakes.core.fsm.token.BaseToken

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


    for (int i = 0; i < tokens.size(); i++) {
      BaseToken token = (BaseToken) tokens.get(i);


      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, new Integer(i));
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = (BaseToken) tokens
              .get(tokenStartIndex);
          BaseToken endToken = token;
          HyphenatedDrugToken fractionToken = new HyphenatedDrugToken(
              startToken.getStartOffset(), endToken
                  .getEndOffset());
          fractionSet.add(fractionToken);
          fsm.reset();
        }
      }

View Full Code Here

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


        for (int i = 0; i < tokens.size(); i++)
        {
            BaseToken token = (BaseToken) tokens.get(i);


            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, new Integer(i));
                }
                if (currentState.getEndStateFlag())
                {
                    Object o = tokenStartMap.get(fsm);
                    int tokenStartIndex;
                    if (o == null)
                    {
                        // By default, all machines start with
                        // token zero.
                        tokenStartIndex = 0;
                    }
                    else
                    {
                        tokenStartIndex = ((Integer) o).intValue();
                        // skip ahead over single token we don't want
                        tokenStartIndex++;
                    }
                    BaseToken endToken = null;
                    if (currentState instanceof NonTerminalEndState)
                    {
                        endToken = (BaseToken) tokens.get(i - 1);
                    }
                    else
                    {
                        endToken = token;
                    }


                    BaseToken startToken = (BaseToken) tokens
                            .get(tokenStartIndex);
                    NonIndicator neg = null;
                    if (fsm.equals(iv_negInitialDetermineMachine))
                    {
                        neg =  new NonIndicator(
                                startToken.getStartOffset(),
                                endToken.getEndOffset());
                    }
                    else neg = new NonIndicator(
                            startToken.getStartOffset(),
                            endToken.getEndOffset());
                    outSet.add(neg);
                    fsm.reset();
                }
            }

View Full Code Here


    Iterator overrideTokenItr = overrideSet.iterator();
    // key = start offset, value = override BaseToken object
    Map overrideTokenMap = new HashMap();
    while (overrideTokenItr.hasNext()) {
      BaseToken t = (BaseToken) overrideTokenItr.next();
      Integer key = new Integer(t.getStartOffset());
      overrideTokenMap.put(key, t);
    }


    boolean overrideOn = false;
    int overrideEndOffset = -1;
    for (int i = 0; i < tokens.size(); i++) {
      BaseToken token = (BaseToken) tokens.get(i);


      Integer key = new Integer(token.getStartOffset());


      if (overrideOn) {
        if (token.getStartOffset() >= overrideEndOffset) {
          overrideOn = false;
          overrideEndOffset = -1;
        } else {
          // step to next iteration of for loop
          continue;
        }
      } else {
        if (overrideTokenMap.containsKey(key)) {
          // override one or more tokens until the override
          // token is complete
          token = (BaseToken) overrideTokenMap.get(key);
          overrideOn = true;
          overrideEndOffset = token.getEndOffset();
        }
      }


      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, new Integer(i));
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = (BaseToken) tokens
              .get(tokenStartIndex);
          BaseToken endToken = token;
          RouteToken segmentToken = null;
          
          if (fsm.equals(iv_PatchesMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.TRANSDERMAL);
          }
          else if (fsm.equals(iv_GastricMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.GASTRIC);
          }
          else if (fsm.equals(iv_TopicalMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.TOPICAL);
          }
          else if (fsm.equals(iv_OralMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.ORAL);
          }
          else if (fsm.equals(iv_RectalMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.RECTAL);
          }
          else if (fsm.equals(iv_InjectMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.INTRAVENOUS);
          }
          rangeSet.add(segmentToken);
          fsm.reset();

View Full Code Here

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


    for (int i = 0; i < tokens.size(); i++) {
      BaseToken token = (BaseToken) tokens.get(i);


      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, new Integer(i));
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = (BaseToken) tokens
              .get(tokenStartIndex);
          BaseToken endToken = token;
          RouteToken segmentToken = null;
          
          if (fsm.equals(iv_PatchesMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.TRANSDERMAL);
          }
          else if (fsm.equals(iv_GastricMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.GASTRIC);
          }
          else if (fsm.equals(iv_TopicalMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.TOPICAL);
          }
          else if (fsm.equals(iv_OralMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.ORAL);
          }
          else if (fsm.equals(iv_RectalMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.RECTAL);
          }
          else if (fsm.equals(iv_InjectMachine)){
            segmentToken = new RouteToken(
                startToken.getStartOffset(), endToken
                    .getEndOffset());
            segmentToken.setFormMethod(RouteToken.INTRAVENOUS);
          }
          
          fractionSet.add(segmentToken);

View Full Code Here

        // key = Machine , value = token start index
        Map tokenStartMap = new HashMap();


        for (int i = 0; i < tokens.size(); i++)
        {
            BaseToken token = (BaseToken) tokens.get(i);


            Iterator machineItr = iv_machineSet.iterator();
            while (machineItr.hasNext())
            {
                Machine m = (Machine) machineItr.next();
                m.input(token);


                State currentState = m.getCurrentState();
                if (currentState.getStartStateFlag())
                {
                    tokenStartMap.put(m, new Integer(i));
                }
                if (currentState.getEndStateFlag())
                {
                    Object o = tokenStartMap.get(m);
                    int tokenStartIndex;
                    if (o == null)
                    {
                        // By default, all machines start with
                        // token zero.
                        tokenStartIndex = 0;
                    }
                    else
                    {
                        tokenStartIndex = ((Integer) o).intValue();
                        // skip ahead over single token we don't want
                        tokenStartIndex++;
                    }
                    BaseToken endToken = null;
                    if (currentState instanceof NonTerminalEndState)
                    {
                        endToken = (BaseToken) tokens.get(i - 1);
                    }
                    else
                    {
                        endToken = token;
                    }


                    BaseToken startToken = (BaseToken) tokens
                            .get(tokenStartIndex);
                    StatusIndicator si = null;
                    if (m.equals(iv_historyMachine))
                    {
                        si = new StatusIndicator(
                                startToken.getStartOffset(),
                                endToken.getEndOffset(),
                                StatusIndicator.HISTORY_STATUS);
                    }
                    else if (m.equals(iv_probableMachine) || (m.equals(iv_probableMachineNoTerm)))
                    {


                        si = new StatusIndicator(
                                startToken.getStartOffset(),
                                endToken.getEndOffset(),
                                StatusIndicator.PROBABLE_STATUS);
                    }
                    else if (m.equals(iv_familyHistoryMachine))
                    {
                        si = new StatusIndicator(
                                startToken.getStartOffset(),
                                endToken.getEndOffset(),
                                StatusIndicator.FAMILY_HISTORY_STATUS);
                    }
                    outSet.add(si);
                    m.reset();

View Full Code Here

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


        for (int i = 0; i < tokens.size(); i++)
        {
            BaseToken token = (BaseToken) tokens.get(i);


            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, Integer.valueOf(i));
              }
              if (currentState.getEndStateFlag())
              {
                Object o = tokenStartMap.get(fsm);
                int tokenStartIndex;
                if (o == null)
                {
                  // By default, all machines start with token zero.
                  tokenStartIndex = 0;
                }
                else
                {
                  tokenStartIndex = ((Integer) o).intValue();
                  // skip ahead over single token we don't want
                  tokenStartIndex++;            
                }
                BaseToken startToken =
                  (BaseToken) tokens.get(tokenStartIndex);
                BaseToken endToken = token;
                FractionStrengthToken fractionToken =
                  new FractionStrengthToken(
                      startToken.getStartOffset(),
                      endToken.getEndOffset());
                fractionSet.add(fractionToken);
                fsm.reset();
              }
            }
        }

View Full Code Here

    Iterator overrideTokenItr = overrideSet.iterator();
    // key = start offset, value = override BaseToken object
    Map overrideTokenMap = new HashMap();
    while (overrideTokenItr.hasNext())
    {
      BaseToken t = (BaseToken)overrideTokenItr.next();
      Integer key = new Integer(t.getStartOffset());
      overrideTokenMap.put(key, t);
    }


    boolean overrideOn = false;
    int overrideEndOffset = -1;
    for (int i = 0; i < tokens.size(); i++)
    {
      BaseToken token = (BaseToken) tokens.get(i);


      Integer key = new Integer(token.getStartOffset());            
      
      if (overrideOn)
      {
        if (token.getStartOffset() >= overrideEndOffset)
        {
          overrideOn = false;
          overrideEndOffset = -1;            
        }
        else
        {
          // step to next iteration of for loop
          continue;
        }
      }      
      else
      {
        if (overrideTokenMap.containsKey(key))
        {
          // override one or more tokens until the override
          // token is complete
          token = (BaseToken)overrideTokenMap.get(key);
          overrideOn = true;
          overrideEndOffset = token.getEndOffset();
        }
      }


      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, new Integer(i));
        }
        if (currentState.getEndStateFlag())
        {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null)
          {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          }
          else
          {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;            
          }
          BaseToken startToken =
            (BaseToken) tokens.get(tokenStartIndex);
          BaseToken endToken = token;
          RangeStrengthToken segmentToken =
            new RangeStrengthToken(
              startToken.getStartOffset(),
              endToken.getEndOffset());
          rangeSet.add(segmentToken);
          fsm.reset();
        }
      }
    }

View Full Code Here

    // maps a fsm to a token start index
    // key = fsm , value = token start index
    Map tokenStartMap = new HashMap();
  
    for (int i = 0; i < tokens.size(); i++) {
      BaseToken token = (BaseToken) tokens.get(i);
  
      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, new Integer(i));
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = (BaseToken) tokens
              .get(tokenStartIndex);
          BaseToken endToken = token;
          RangeStrengthToken fractionToken = new RangeStrengthToken(startToken
              .getStartOffset(), endToken.getEndOffset());
          fractionSet.add(fractionToken);
          fsm.reset();
        }
      }
    }

View Full Code Here

    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 = new Integer(t.getStartOffset());
      overrideTokenMap1.put(key, t);
    }


    while (overrideTokenItr2.hasNext()) {
      BaseToken t = (BaseToken) overrideTokenItr2.next();
      Integer key = new Integer(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 = new Integer(token.getStartOffset());
      if (overrideOn1 && overrideOn2) {
        if (overrideEndOffset1 >= overrideEndOffset2)
          overrideOn1 = false;
        else
          overrideOn2 = false;
      }
      if (overrideOn1) {
        if (token.getStartOffset() >= overrideEndOffset1) {
          if (tokenOffset1 > 0)
            overrideBeginTokenMap1.put(new Integer(anchorKey1), new Integer(tokenOffset1));
          overrideOn1 = false;
          overrideEndOffset1 = -1;
        } else {
          tokenOffset1++;
          // step to next iteration of for loop
          continue;
        }
      } else if (overrideOn2) {
        if (token.getStartOffset() >= overrideEndOffset2) {
          if (tokenOffset2 > 0)
            overrideBeginTokenMap2.put(new Integer(anchorKey2), new Integer(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, new Integer(i));
          tokenOffset1 = 0;
          tokenOffset2 = 0;
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int globalOffset = 0;
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            Integer tokenMap1 = new Integer(0);
            Integer tokenMap2 = new Integer(0);
          
            BaseToken lookUpOffset = (BaseToken) tokens.get(((Integer) o).intValue());
              
            if (overrideBeginTokenMap1.get(new Integer(lookUpOffset.getStartOffset())) != null){
              Integer offSet = (Integer) (overrideBeginTokenMap1.get(new Integer(lookUpOffset.getStartOffset())));
              tokenMap1 = new Integer(offSet.intValue()  + tokenMap1.intValue());
            }
            if (overrideBeginTokenMap2.get(new Integer(lookUpOffset.getStartOffset())) != null){
              Integer offSet = (Integer) (overrideBeginTokenMap2.get(new Integer(lookUpOffset.getStartOffset())));
              tokenMap2 = new Integer(offSet.intValue() + tokenMap2.intValue());
              }
            


            globalOffset = tokenMap1.intValue() + tokenMap2.intValue();
            tokenStartIndex = ((Integer) o).intValue() + globalOffset;
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = null;
          if (currentState instanceof IndentStartState) {
            startToken = (BaseToken) tokens
                .get(tokenStartIndex + 1);


          } else {
            startToken = (BaseToken) tokens.get(tokenStartIndex);


          }
          BaseToken endToken = token;
          if (currentState instanceof NonTerminalEndState) {
            endToken = (BaseToken) tokens.get(i - 1);


            if (endToken instanceof PunctuationTokenAdapter) {
              endToken = (BaseToken) tokens.get(i - 2);
            }
          } else {
            endToken = token;
          }
          DosageToken measurementToken = new DosageToken(startToken
              .getStartOffset(), endToken.getEndOffset());
          measurementSet.add(measurementToken);
          fsm.reset();
        }
      }
    }

View Full Code Here


    Iterator overrideTokenItr = overrideSet.iterator();
    // key = start offset, value = override BaseToken object
    Map overrideTokenMap = new HashMap();
    while (overrideTokenItr.hasNext()) {
      BaseToken t = (BaseToken) overrideTokenItr.next();
      Integer key = new Integer(t.getStartOffset());
      overrideTokenMap.put(key, t);
    }


    boolean overrideOn = false;
    int overrideEndOffset = -1;
    for (int i = 0; i < tokens.size(); i++) {
      BaseToken token = (BaseToken) tokens.get(i);


      Integer key = new Integer(token.getStartOffset());


      if (overrideOn) {
        if (token.getStartOffset() >= overrideEndOffset) {
          overrideOn = false;
          overrideEndOffset = -1;
        } else {
          // step to next iteration of for loop
          continue;
        }
      } else {
        if (overrideTokenMap.containsKey(key)) {
          // override one or more tokens until the override
          // token is complete
          token = (BaseToken) overrideTokenMap.get(key);
          overrideOn = true;
          overrideEndOffset = token.getEndOffset();
        }
      }


      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, Integer.valueOf(i));
        }
        if (currentState.getEndStateFlag()) {
          Object o = tokenStartMap.get(fsm);
          int tokenStartIndex;
          if (o == null) {
            // By default, all machines start with
            // token zero.
            tokenStartIndex = 0;
          } else {
            tokenStartIndex = ((Integer) o).intValue();
            // skip ahead over single token we don't want
            tokenStartIndex++;
          }
          BaseToken startToken = null;
          if (currentState instanceof IndentStartState) {
            startToken = (BaseToken) tokens
                .get(tokenStartIndex + 1);


          } else {
            startToken = (BaseToken) tokens.get(tokenStartIndex);


          }
          BaseToken endToken = null;
          if (currentState instanceof NonTerminalEndState) {
            endToken = (BaseToken) tokens.get(i - 1);
            if (endToken instanceof PunctuationTokenAdapter) {
              endToken = (BaseToken) tokens.get(i - 2);
            }
          } else {
            endToken = token;
          }
          // BaseToken endToken = token;
          DosageToken measurementToken = new DosageToken(startToken
              .getStartOffset(), endToken.getEndOffset());


          measurementSet.add(measurementToken);
          fsm.reset();
        }
      }

View Full Code Here

0 1 2 3 4

TOP

Related Classes of org.apache.ctakes.core.fsm.token.BaseToken

org.apache.ctakes.contexttokenizer.ae.ContextDependentTokenizerAnnotator

org.apache.ctakes.core.fsm.machine.DateFSM

org.apache.ctakes.core.fsm.machine.FractionFSM

org.apache.ctakes.core.fsm.machine.MeasurementFSM

org.apache.ctakes.core.fsm.machine.NegationFSM

org.apache.ctakes.core.fsm.machine.PersonTitleFSM

org.apache.ctakes.core.fsm.machine.RangeFSM

org.apache.ctakes.core.fsm.machine.RomanNumeralFSM

org.apache.ctakes.core.fsm.machine.StatusIndicatorFSM

org.apache.ctakes.core.fsm.machine.TimeFSM

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.