Example usage for org.eclipse.jdt.internal.core JavaElement JEM_IMPORTDECLARATION

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.core JavaElement JEM_IMPORTDECLARATION.

Prototype

char JEM_IMPORTDECLARATION

To view the source code for org.eclipse.jdt.internal.core JavaElement JEM_IMPORTDECLARATION.

Click Source Link

Usage

From source file:org.eclipse.ajdt.core.AJMementoTokenizer.java

License:Open Source License

public String nextToken() {
    int start = this.index;
    StringBuffer buffer = null;/*from ww w  . j  av  a 2 s  .  c  o  m*/
    switch (this.memento[this.index++]) {
    case JavaElement.JEM_ESCAPE:
        buffer = new StringBuffer();
        buffer.append(this.memento[this.index]);
        start = ++this.index;
        break;
    case JavaElement.JEM_COUNT:
        return COUNT;
    case JavaElement.JEM_JAVAPROJECT:
        return JAVAPROJECT;
    case JavaElement.JEM_PACKAGEFRAGMENTROOT:
        return PACKAGEFRAGMENTROOT;
    case JavaElement.JEM_PACKAGEFRAGMENT:
        return PACKAGEFRAGMENT;
    case JavaElement.JEM_FIELD:
        return FIELD;
    case JavaElement.JEM_METHOD:
        return METHOD;
    case JavaElement.JEM_INITIALIZER:
        return INITIALIZER;
    case JavaElement.JEM_COMPILATIONUNIT:
        return COMPILATIONUNIT;
    case JavaElement.JEM_CLASSFILE:
        return CLASSFILE;
    case JavaElement.JEM_TYPE:
        return TYPE;
    case JavaElement.JEM_PACKAGEDECLARATION:
        return PACKAGEDECLARATION;
    case JavaElement.JEM_IMPORTDECLARATION:
        return IMPORTDECLARATION;
    case JavaElement.JEM_LOCALVARIABLE:
        return LOCALVARIABLE;
    case JavaElement.JEM_TYPE_PARAMETER:
        return TYPE_PARAMETER;
    case JavaElement.JEM_ANNOTATION:
        return ANNOTATION;
    // begin AspectJ change
    case AspectElement.JEM_ADVICE:
        return ADVICE;
    case AspectElement.JEM_ASPECT_TYPE:
        return ASPECT_TYPE;
    case AspectElement.JEM_CODEELEMENT:
        return CODEELEMENT;
    case AspectElement.JEM_ITD_METHOD:
        return ITD_METHOD;
    case AspectElement.JEM_ITD_FIELD:
        return ITD_FIELD;
    case AspectElement.JEM_DECLARE:
        return DECLARE;
    case AspectElement.JEM_POINTCUT:
        return POINTCUT;

    case AspectElement.JEM_ASPECT_CU:
        // only return here if JDT weaving is off
        // if JDT weaving is on, then a * here
        // means that we are in an on demand import declaration
        if (!AspectJPlugin.USING_CU_PROVIDER) {
            return ASPECT_CU;
        }
        // end AspectJ change
    }
    loop: while (this.index < this.length) {
        switch (this.memento[this.index]) {
        case JavaElement.JEM_ESCAPE:
            if (buffer == null)
                buffer = new StringBuffer();
            buffer.append(this.memento, start, this.index - start);
            start = ++this.index;
            break;
        case JavaElement.JEM_COUNT:
        case JavaElement.JEM_JAVAPROJECT:
        case JavaElement.JEM_PACKAGEFRAGMENTROOT:
        case JavaElement.JEM_PACKAGEFRAGMENT:
        case JavaElement.JEM_FIELD:
        case JavaElement.JEM_METHOD:
        case JavaElement.JEM_INITIALIZER:
        case JavaElement.JEM_COMPILATIONUNIT:
        case JavaElement.JEM_CLASSFILE:
        case JavaElement.JEM_TYPE:
        case JavaElement.JEM_PACKAGEDECLARATION:
        case JavaElement.JEM_IMPORTDECLARATION:
        case JavaElement.JEM_LOCALVARIABLE:
        case JavaElement.JEM_TYPE_PARAMETER:
        case JavaElement.JEM_ANNOTATION:
            // begin AspectJ change
        case AspectElement.JEM_ADVICE:
        case AspectElement.JEM_ASPECT_TYPE:
        case AspectElement.JEM_CODEELEMENT:
        case AspectElement.JEM_ITD_METHOD:
        case AspectElement.JEM_ITD_FIELD:
        case AspectElement.JEM_DECLARE:
        case AspectElement.JEM_POINTCUT:
            break loop;
        // end AspectJ change

        // begin AspectJ change
        case AspectElement.JEM_ASPECT_CU:
            // only break here if JDT weaving is off
            // if JDT weaving is on, then a * here
            // means that we are in an on demand import declaration
            if (!AspectJPlugin.USING_CU_PROVIDER) {
                break loop;
            }
            // end AspectJ change
        }
        this.index++;
    }
    if (buffer != null) {
        buffer.append(this.memento, start, this.index - start);
        return buffer.toString();
    }
    return new String(this.memento, start, this.index - start);
}

---

From source file:org.eclipse.ajdt.core.javaelements.AJCompilationUnit.java

License:Open Source License

public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento,
        WorkingCopyOwner workingCopyOwner) {
    JavaElement type = this;
    if (!(memento instanceof AJMementoTokenizer)) {
        memento = new AJMementoTokenizer(memento, name);
    }/* w ww . j a v  a  2 s.co  m*/
    if ((token.charAt(0) == JavaElement.JEM_IMPORTDECLARATION)
            || (token.charAt(0) == JavaElement.JEM_PACKAGEDECLARATION)) {
        return super.getHandleFromMemento(token, memento, workingCopyOwner);
    }

    // need to handle types ourselves, because they may contain inner aspects
    // (or inner classes containing inner aspects etc)
    while ((token.charAt(0) == AspectElement.JEM_ASPECT_TYPE) || (token.charAt(0) == JavaElement.JEM_TYPE)
            || (token.charAt(0) == JavaElement.JEM_ANNOTATION)) {
        // note that we are also testing for JEM_ANNOTATION here.
        // this is because when the type handle identifiers were changed prior to 2.1.1,
        // JEM_ASPECT_TYPE and JEM_ANNOTATION were the same.
        // Some people have had problems in that the old handles were cached.
        // this can probably be safely removed post 2.1.2.
        if (!memento.hasMoreTokens())
            return type;
        String typeName = memento.nextToken();
        if (token.charAt(0) == AspectElement.JEM_ASPECT_TYPE || token.charAt(0) == JavaElement.JEM_ANNOTATION) {
            type = new AspectElement(type, typeName);
        } else if (token.charAt(0) == JavaElement.JEM_TYPE) {
            type = getType(type, typeName);
            if (type == null)
                type = (JavaElement) getType(typeName);
        }
        if (!memento.hasMoreTokens())
            return type;
        token = memento.nextToken();
    }
    // handle pointcuts in a class (bug 124992)
    if (!(type instanceof AspectElement) && (token.charAt(0) == AspectElement.JEM_POINTCUT)) {
        String name = memento.nextToken();
        ArrayList params = new ArrayList();
        nextParam: while (memento.hasMoreTokens()) {
            token = memento.nextToken();
            switch (token.charAt(0)) {
            case JEM_TYPE:
            case JEM_TYPE_PARAMETER:
                break nextParam;
            case AspectElement.JEM_POINTCUT:
                if (!memento.hasMoreTokens())
                    return this;
                String param = memento.nextToken();
                StringBuffer buffer = new StringBuffer();
                while (param.length() == 1 && Signature.C_ARRAY == param.charAt(0)) { // backward compatible with 3.0 mementos
                    buffer.append(Signature.C_ARRAY);
                    if (!memento.hasMoreTokens())
                        return this;
                    param = memento.nextToken();
                }
                params.add(buffer.toString() + param);
                break;
            default:
                break nextParam;
            }
        }
        String[] parameters = new String[params.size()];
        params.toArray(parameters);
        JavaElement pointcut = new PointcutElement(type, name, parameters);
        return pointcut.getHandleFromMemento(memento, workingCopyOwner);
    }

    return type.getHandleFromMemento(token, memento, workingCopyOwner);
}

---

From source file:org.eclipse.ajdt.core.model.AJProjectModelFacade.java

License:Open Source License

private boolean isBinaryAspectJHandle(String ajHandle) {
    int classFileIndex = ajHandle.indexOf(JavaElement.JEM_CLASSFILE);
    boolean doIt = false;
    if (classFileIndex != -1) {
        int dotClassIndex = ajHandle.indexOf(".class") + ".class".length();
        if (dotClassIndex >= ajHandle.length()) {
            // handle is for the class itself.
            doIt = true;//from w w  w  .ja  va  2  s. c o  m
        } else if (dotClassIndex != -1) {
            // make sure this isn't a code element
            char typeChar = ajHandle.charAt(dotClassIndex);
            doIt = (typeChar == AspectElement.JEM_ASPECT_TYPE || typeChar == JavaElement.JEM_TYPE
                    || typeChar == JavaElement.JEM_IMPORTDECLARATION
                    || typeChar == JavaElement.JEM_PACKAGEDECLARATION);
        }
    } else {
        // Bug 274558 ADE HACK...handles are not always right for aspects on aspect path
        // sometimes the source handle is used, bug should be binary handle
        if (ajHandle.indexOf("/binaries<") != -1) {
            doIt = true;
        }
    }
    return doIt;
}

---