Gets the part after the last dot in a dotted identifier. If there are no dots, returns the
whole identifier.

<p><b>Important:</b> The input must be a dotted identifier. This is not checked.
540172
public Identifier extractPartAfterLastDot() {
    String part = BaseUtils.extractPartAfterLastDot(identifier());
    return Identifier.create(
        part, location().offsetStartCol(identifier().length() - part.length()));
  }
1036269
private int cutWordAfter() {
        if (after.length() > 0) {
            int cut = 0;
            while (cut < after.length() && isDelimiter(after.charAt(cut))) {
                ++cut;
            }
            final int last = after.length() - 1;
            while (cut <= last) {
                if (isDelimiter(after.charAt(cut))) {
                    return cut;
                }
                ++cut;
            }
        }
        return -1;
    }
364067
private boolean isLetter(final char paramInput) {

        return (paramInput >= '0' && paramInput <= '9') || (paramInput >= 'a' && paramInput <= 'z')
            || (paramInput >= 'A' && paramInput <= 'Z') || (paramInput == '_') || (paramInput == '-')
            || (paramInput == '.');

    }
1127736
public String getWholeNumberPart(final int digit) {
        
        final int length = wholeNumberPart.length();
        if(length < digit || digit <= 0) {
            return "";
        }
        
        return String.valueOf(wholeNumberPart.charAt(length - digit));
    }
369743
public Identifier getIdentifier(int i) {
        return mIdentifiers.size() > i ? mIdentifiers.get(i) : null;
    }
385712
public String getDenominatorPart(final int digit) {
        
        final int length = denominatorPart.length();
        if(length < digit || digit <= 0) {
            return "";
        }
        
        return String.valueOf(denominatorPart.charAt(length - digit));
    }
1216944
public static String getPrefix(String input, char delimiter) {
        int index = input.indexOf(delimiter);
        if (index > -1) {
            return input.substring(0, index);
        }

        return input;
    }
1332677
public int getLastChild(int nodeHandle)
  {

    int identity = makeNodeIdentity(nodeHandle);
    int child = _firstch(identity);
    int lastChild = DTM.NULL;

    while (child != DTM.NULL)
    {
      lastChild = child;
      child = _nextsib(child);
    }

    return makeNodeHandle(lastChild);
  }
403656
public String getExponentPart(final int digit) {
        
        final int length = exponentPart.length();
        if(length < digit || digit <= 0) {
            return "";
        }
        
        return String.valueOf(exponentPart.charAt(length - digit));
        
    }
247284
public String getShortName() {
        int endOfPkg = className.lastIndexOf('.');
        if (endOfPkg >= 0) {
            return className.substring(endOfPkg + 1);
        }
        return className;
    }
655508
int getState() {
    if (tc.isEntryEnabled())
      tc.entry(this,cclass, "getState");
    int state;
    if (!prefixDone) {
      // Somewhere in the prefix or at beginning and there is no prefix
      Pattern.Clause prefix = pattern.getPrefix();
      if (prefix == null || next >= prefix.items.length) {
        // There is no prefix or we're at the end of it
        Pattern.Clause suffix = pattern.getSuffix();
        // Answer depends on the suffix
        state = suffix == null ? FINAL_MANY : suffix == prefix ? FINAL_EXACT
          : SWITCH_TO_SUFFIX;
      }
      else
        // We're somewhere in the body of the prefix
        state = prefix.items[next] == Pattern.matchOne ? SKIP_ONE_PREFIX : PREFIX_CHARS;
    }
    else {
      // We're in the suffix
      Pattern.Clause suffix = pattern.getSuffix();
      state = (next < 0) ? FINAL_MANY
        : suffix.items[next] == Pattern.matchOne ? SKIP_ONE_SUFFIX : SUFFIX_CHARS;  
    }
    if (tc.isEntryEnabled())
      tc.exit(this,cclass, "getState", new Integer(state));
    return state;
  }
447144
public String getName() {
        int separatorIndex = path.lastIndexOf(separator);
        return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());
    }
553922
def getSource(self):
        
        bracket = self.next()
        # we should only be here because that was a bracket
        if not bracket == u'{':
            raise Exception(u"parse error getting source")
        c = u''
        identifier = u''
        while True:
            c = self.next()
            if not c:
                raise Exception(u"unexpected end of input getting source")
            elif c == u'}':
                break
            else:
                identifier += c
        if not identifier or not isidentifier(identifier):
            raise StringGenerator.SyntaxError(u"not a valid identifier: %s"%identifier)
        return StringGenerator.Source(identifier)
733031
public CompilerInput getInput() {
    if (compilerInput == null && inputId != null) {
      compilerInput = compiler.getInput(inputId);
    }
    return compilerInput;
  }
342940
public int getPosition(long identifier) {
        int position = 0;
        for (IAdapter<Item> adapter : mAdapters) {
            if (adapter.getOrder() < 0) {
                continue;
            }

            int relativePosition = adapter.getAdapterPosition(identifier);
            if (relativePosition != -1) {
                return position + relativePosition;
            }
            position = adapter.getAdapterItemCount();
        }

        return -1;
    }
1271228
private String buildIdentifier() {
    checkForEmptyIdentifier();
    CharType boundary = nearestCharType(CharType.DOT, CharType.EOL);
    if (chars.positiveLookaheadBefore(boundary, CharType.LETTER, CharType.HYPHEN)) {
      return alphanumericIdentifier();
    } else {
      return digits();
    }
  }
1228945
public static String getLastCharacters(String s, int last) {
        int index = s.length() - last + 1;
        if (index < 0) {
            index = 0;
        }
        String result = "";
        if (index > 0) {
            result = " ... ";
        }
        result = result +  s.substring(index);
        return result;
    }