Example usage for org.eclipse.jdt.internal.compiler.util SimpleLookupTable containsKey

List of usage examples for org.eclipse.jdt.internal.compiler.util SimpleLookupTable containsKey

Introduction

In this page you can find the example usage for org.eclipse.jdt.internal.compiler.util SimpleLookupTable containsKey.

Prototype

public boolean containsKey(Object key) 

Source Link

Usage

From source file:net.sf.j2s.core.builder.State.java

License:Open Source License

void write(DataOutputStream out) throws IOException {
    int length;/* ww  w .j av  a 2 s  .co  m*/
    Object[] keyTable;
    Object[] valueTable;

    /*
     * byte      VERSION
     * String      project name
     * int         build number
     * int         last structural build number
    */
    out.writeByte(VERSION);
    out.writeUTF(this.javaProjectName);
    out.writeInt(this.buildNumber);
    out.writeLong(this.lastStructuralBuildTime);

    /*
     * ClasspathMultiDirectory[]
     * int         id
     * String      path(s)
    */
    out.writeInt(length = this.sourceLocations.length);
    for (int i = 0; i < length; i++) {
        ClasspathMultiDirectory md = this.sourceLocations[i];
        out.writeUTF(md.sourceFolder.getProjectRelativePath().toString());
        out.writeUTF(md.binaryFolder.getProjectRelativePath().toString());
        writeNames(md.inclusionPatterns, out);
        writeNames(md.exclusionPatterns, out);
        out.writeBoolean(md.ignoreOptionalProblems);
        out.writeBoolean(md.hasIndependentOutputFolder);
    }

    /*
     * ClasspathLocation[]
     * int         id
     * String      path(s)
    */
    out.writeInt(length = this.binaryLocations.length);
    next: for (int i = 0; i < length; i++) {
        ClasspathLocation c = this.binaryLocations[i];
        if (c instanceof ClasspathMultiDirectory) {
            out.writeByte(SOURCE_FOLDER);
            for (int j = 0, m = this.sourceLocations.length; j < m; j++) {
                if (this.sourceLocations[j] == c) {
                    out.writeInt(j);
                    continue next;
                }
            }
        } else if (c instanceof ClasspathDirectory) {
            out.writeByte(BINARY_FOLDER);
            ClasspathDirectory cd = (ClasspathDirectory) c;
            out.writeUTF(cd.binaryFolder.getFullPath().toString());
            out.writeBoolean(cd.isOutputFolder);
            writeRestriction(cd.accessRuleSet, out);
        } else {
            ClasspathJar jar = (ClasspathJar) c;
            if (jar.resource == null) {
                out.writeByte(EXTERNAL_JAR);
                out.writeUTF(jar.zipFilename);
                out.writeLong(jar.lastModified());
            } else {
                out.writeByte(INTERNAL_JAR);
                out.writeUTF(jar.resource.getFullPath().toString());
            }
            writeRestriction(jar.accessRuleSet, out);
        }
    }

    /*
     * Structural build numbers table
     * String      prereq project name
     * int         last structural build number
    */
    out.writeInt(length = this.structuralBuildTimes.elementSize);
    if (length > 0) {
        keyTable = this.structuralBuildTimes.keyTable;
        valueTable = this.structuralBuildTimes.valueTable;
        for (int i = 0, l = keyTable.length; i < l; i++) {
            if (keyTable[i] != null) {
                length--;
                out.writeUTF((String) keyTable[i]);
                out.writeLong(((Long) valueTable[i]).longValue());
            }
        }
        if (JavaBuilder.DEBUG && length != 0)
            System.out.println("structuralBuildNumbers table is inconsistent"); //$NON-NLS-1$
    }

    /*
     * String[]   Interned type locators
     */
    out.writeInt(length = this.references.elementSize);
    SimpleLookupTable internedTypeLocators = new SimpleLookupTable(length);
    if (length > 0) {
        keyTable = this.references.keyTable;
        for (int i = 0, l = keyTable.length; i < l; i++) {
            if (keyTable[i] != null) {
                length--;
                String key = (String) keyTable[i];
                out.writeUTF(key);
                internedTypeLocators.put(key, new Integer(internedTypeLocators.elementSize));
            }
        }
        if (JavaBuilder.DEBUG && length != 0)
            System.out.println("references table is inconsistent"); //$NON-NLS-1$
    }

    /*
     * Type locators table
     * String      type name
     * int         interned locator id
     */
    out.writeInt(length = this.typeLocators.elementSize);
    if (length > 0) {
        keyTable = this.typeLocators.keyTable;
        valueTable = this.typeLocators.valueTable;
        for (int i = 0, l = keyTable.length; i < l; i++) {
            if (keyTable[i] != null) {
                length--;
                out.writeUTF((String) keyTable[i]);
                Integer index = (Integer) internedTypeLocators.get(valueTable[i]);
                out.writeInt(index.intValue());
            }
        }
        if (JavaBuilder.DEBUG && length != 0)
            System.out.println("typeLocators table is inconsistent"); //$NON-NLS-1$
    }

    /*
     * char[][]   Interned root names
     * char[][][]   Interned qualified names
     * char[][]   Interned simple names
     */
    SimpleLookupTable internedRootNames = new SimpleLookupTable(3);
    SimpleLookupTable internedQualifiedNames = new SimpleLookupTable(31);
    SimpleLookupTable internedSimpleNames = new SimpleLookupTable(31);
    valueTable = this.references.valueTable;
    for (int i = 0, l = valueTable.length; i < l; i++) {
        if (valueTable[i] != null) {
            ReferenceCollection collection = (ReferenceCollection) valueTable[i];
            char[][] rNames = collection.rootReferences;
            for (int j = 0, m = rNames.length; j < m; j++) {
                char[] rName = rNames[j];
                if (!internedRootNames.containsKey(rName)) // remember the names have been interned
                    internedRootNames.put(rName, new Integer(internedRootNames.elementSize));
            }
            char[][][] qNames = collection.qualifiedNameReferences;
            for (int j = 0, m = qNames.length; j < m; j++) {
                char[][] qName = qNames[j];
                if (!internedQualifiedNames.containsKey(qName)) { // remember the names have been interned
                    internedQualifiedNames.put(qName, new Integer(internedQualifiedNames.elementSize));
                    for (int k = 0, n = qName.length; k < n; k++) {
                        char[] sName = qName[k];
                        if (!internedSimpleNames.containsKey(sName)) // remember the names have been interned
                            internedSimpleNames.put(sName, new Integer(internedSimpleNames.elementSize));
                    }
                }
            }
            char[][] sNames = collection.simpleNameReferences;
            for (int j = 0, m = sNames.length; j < m; j++) {
                char[] sName = sNames[j];
                if (!internedSimpleNames.containsKey(sName)) // remember the names have been interned
                    internedSimpleNames.put(sName, new Integer(internedSimpleNames.elementSize));
            }
        }
    }
    char[][] internedArray = new char[internedRootNames.elementSize][];
    Object[] rootNames = internedRootNames.keyTable;
    Object[] positions = internedRootNames.valueTable;
    for (int i = positions.length; --i >= 0;) {
        if (positions[i] != null) {
            int index = ((Integer) positions[i]).intValue();
            internedArray[index] = (char[]) rootNames[i];
        }
    }
    writeNames(internedArray, out);
    // now write the interned simple names
    internedArray = new char[internedSimpleNames.elementSize][];
    Object[] simpleNames = internedSimpleNames.keyTable;
    positions = internedSimpleNames.valueTable;
    for (int i = positions.length; --i >= 0;) {
        if (positions[i] != null) {
            int index = ((Integer) positions[i]).intValue();
            internedArray[index] = (char[]) simpleNames[i];
        }
    }
    writeNames(internedArray, out);
    // now write the interned qualified names as arrays of interned simple names
    char[][][] internedQArray = new char[internedQualifiedNames.elementSize][][];
    Object[] qualifiedNames = internedQualifiedNames.keyTable;
    positions = internedQualifiedNames.valueTable;
    for (int i = positions.length; --i >= 0;) {
        if (positions[i] != null) {
            int index = ((Integer) positions[i]).intValue();
            internedQArray[index] = (char[][]) qualifiedNames[i];
        }
    }
    out.writeInt(length = internedQArray.length);
    for (int i = 0; i < length; i++) {
        char[][] qName = internedQArray[i];
        int qLength = qName.length;
        out.writeInt(qLength);
        for (int j = 0; j < qLength; j++) {
            Integer index = (Integer) internedSimpleNames.get(qName[j]);
            out.writeInt(index.intValue());
        }
    }

    /*
     * References table
     * int      interned locator id
     * ReferenceCollection
    */
    out.writeInt(length = this.references.elementSize);
    if (length > 0) {
        keyTable = this.references.keyTable;
        for (int i = 0, l = keyTable.length; i < l; i++) {
            if (keyTable[i] != null) {
                length--;
                Integer index = (Integer) internedTypeLocators.get(keyTable[i]);
                out.writeInt(index.intValue());
                ReferenceCollection collection = (ReferenceCollection) valueTable[i];
                if (collection instanceof AdditionalTypeCollection) {
                    out.writeByte(1);
                    AdditionalTypeCollection atc = (AdditionalTypeCollection) collection;
                    writeNames(atc.definedTypeNames, out);
                } else {
                    out.writeByte(2);
                }
                char[][][] qNames = collection.qualifiedNameReferences;
                int qLength = qNames.length;
                out.writeInt(qLength);
                for (int j = 0; j < qLength; j++) {
                    index = (Integer) internedQualifiedNames.get(qNames[j]);
                    out.writeInt(index.intValue());
                }
                char[][] sNames = collection.simpleNameReferences;
                int sLength = sNames.length;
                out.writeInt(sLength);
                for (int j = 0; j < sLength; j++) {
                    index = (Integer) internedSimpleNames.get(sNames[j]);
                    out.writeInt(index.intValue());
                }
                char[][] rNames = collection.rootReferences;
                int rLength = rNames.length;
                out.writeInt(rLength);
                for (int j = 0; j < rLength; j++) {
                    index = (Integer) internedRootNames.get(rNames[j]);
                    out.writeInt(index.intValue());
                }
            }
        }
        if (JavaBuilder.DEBUG && length != 0)
            System.out.println("references table is inconsistent"); //$NON-NLS-1$
    }
}