<code-name-base>org.netbeans.libs.neo4j.core</code-name-base>

                    <build-prerequisite/>

                    <compile-dependency/>

                    <run-dependency>

                        <release-version>1</release-version>

                        <specification-version>1.0</specification-version>

                    </run-dependency>

                </dependency>

                <dependency>

import org.netbeans.modules.java.source.indexing.neo4j.Neo4jIndex;

    @Override

    public void restored() {

        super.restored();

        Neo4jIndex.getDefault().start();

    }

        Neo4jIndex.getDefault().stop();

import java.util.concurrent.Callable;

import org.netbeans.modules.java.source.indexing.neo4j.Neo4jAnalyzer;

import org.netbeans.modules.java.source.indexing.neo4j.Neo4jIndex;

import org.netbeans.modules.java.source.indexing.neo4j.Neo4jIndexTransaction;

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import java.util.BitSet;

import javax.lang.model.element.ElementKind;

import org.neo4j.graphdb.Node;

import org.neo4j.graphdb.index.Index;

import org.neo4j.kernel.EmbeddedGraphDatabase;

import org.netbeans.api.annotations.common.CheckForNull;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.annotations.common.NullAllowed;

/**

 *

 * @author Tomas Zezula

 */

class ClassNode extends ModelNode {

    private static final String PROP_BIN_NAME = "binName";       //NOI18N

    private static final String PROP_SIMPLE_NAME = "name";          //NOI18N

    private static final String PROP_KIND = "kind";                 //NOI18N

    private static final String PROP_RES_NAME = "resName";          //NOI18N

    private static final String KEY_SIMPLE_NAME ="sn";              //NOI18N

    private static final String KEY_CASE_INSENSITIVE_SIMPLE_NAME = "cisn";  //NOI18N

    private ClassNode(Node node) {

        super(node);

    }

    @NonNull

    String getSimpleName() {

        return (String) node.getProperty(PROP_SIMPLE_NAME);

    }

    @NonNull

    String getBinaryName() {

        return (String) node.getProperty(PROP_BIN_NAME);

    }

    @NonNull

    ElementKind getKind() {

        final String kn = (String) node.getProperty(PROP_KIND);

        return ElementKind.valueOf(kn);

    }

    @CheckForNull

    String getResourceName() {

        return (String) node.getProperty(PROP_RES_NAME, null);

    }

    void uses(

        @NonNull TypeReferenceNode type,

        @NonNull final BitSet usageTypes) {

        TimeLogger.start();

        try {

            for (int i = usageTypes.nextSetBit(0); i >= 0; i = usageTypes.nextSetBit(i+1)) {

                final RelationshipTypes rt = RelationshipTypes.fromUsageTypeOrdinal(i);

                node.createRelationshipTo(type.node, rt);

            }

        } finally {

            TimeLogger.stop();

        }

    }

    static ClassNode create(

            @NonNull final EmbeddedGraphDatabase db,

            @NonNull final Index<Node> classSimpleNames,

            @NonNull final String binaryName,

            @NonNull final String simpleName,

            @NonNull final PackageNode packageNode,

            @NonNull final ElementKind kind,

            @NullAllowed final String resourceName) {

        TimeLogger.start();

        try {

            final Node node = db.createNode();

            node.setProperty(PROP_BIN_NAME, binaryName);

            node.setProperty(PROP_SIMPLE_NAME, simpleName);

            node.setProperty(PROP_KIND, kind.name());

            if (resourceName != null) {

                node.setProperty(PROP_RES_NAME, resourceName);

            }

            node.createRelationshipTo(packageNode.node, RelationshipTypes.IN_PACKAGE);

            classSimpleNames.add(node, KEY_SIMPLE_NAME, simpleName);

            classSimpleNames.add(node,KEY_CASE_INSENSITIVE_SIMPLE_NAME, simpleName.toLowerCase());

            return new ClassNode(node);

        } finally {

            TimeLogger.stop();

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import org.neo4j.graphdb.Node;

import org.netbeans.api.annotations.common.NonNull;

/**

 *

 * @author Tomas Zezula

 */

public class ModelNode {

    protected final Node node;

    ModelNode(@NonNull Node node) {

        assert node != null;

        this.node = node;

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import com.sun.source.tree.ClassTree;

import com.sun.source.tree.CompilationUnitTree;

import com.sun.source.tree.ErroneousTree;

import com.sun.source.tree.IdentifierTree;

import com.sun.source.tree.ImportTree;

import com.sun.source.tree.MemberSelectTree;

import com.sun.source.tree.MethodTree;

import com.sun.source.tree.NewClassTree;

import com.sun.source.tree.ParameterizedTypeTree;

import com.sun.source.tree.Tree;

import com.sun.source.tree.VariableTree;

import com.sun.source.util.TreeScanner;

import com.sun.tools.javac.api.JavacTaskImpl;

import com.sun.tools.javac.code.Kinds;

import com.sun.tools.javac.code.Symbol;

import com.sun.tools.javac.code.Type;

import com.sun.tools.javac.tree.JCTree;

import com.sun.tools.javac.util.Name;

import com.sun.tools.javac.util.Names;

import java.net.MalformedURLException;

import java.net.URI;

import java.net.URL;

import java.util.ArrayDeque;

import java.util.BitSet;

import java.util.Deque;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Stack;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.lang.model.element.Element;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.TypeElement;

import javax.lang.model.type.ArrayType;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.TypeKind;

import javax.lang.model.type.TypeMirror;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.StandardLocation;

import org.netbeans.api.annotations.common.CheckForNull;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.annotations.common.NullAllowed;

import org.netbeans.api.java.classpath.ClassPath;

import org.netbeans.api.java.source.ElementHandle;

import org.netbeans.api.java.source.SourceUtils;

import org.netbeans.modules.java.source.indexing.JavaCustomIndexer;

import org.netbeans.modules.java.source.indexing.TransactionContext;

import org.netbeans.modules.java.source.parsing.FileObjects;

import org.netbeans.modules.java.source.usages.ClassFileUtil;

import org.netbeans.modules.java.source.usages.ClassIndexImpl;

import org.netbeans.modules.java.source.usages.Pair;

import org.openide.filesystems.FileObject;

import org.openide.filesystems.FileUtil;

import org.openide.filesystems.URLMapper;

import org.openide.util.Exceptions;

/**

 *

 * @author tom

 */

public class Neo4jAnalyzer extends TreeScanner<Void, Void> {

    private static final Logger LOG = Logger.getLogger(Neo4jAnalyzer.class.getName());

    enum State {

        EXTENDS, IMPLEMENTS, GT, OTHER, IMPORT, PACKAGE_ANN

    };

    private final Neo4jIndexTransaction neoTx;

    private final Stack<ClassNode> activeClass;

    private final Name errorName;

    private final Name pkgImportName;

    private final URL siblingUrl;

    private final String sourceName;

    private final boolean signatureFiles;

    private final Set<? super Pair<String, String>> topLevels;

    private final Set<? super ElementHandle<TypeElement>> newTypes;

    private final Set<Symbol> imports;

    private final Set<Symbol> staticImports;

    private final Set<Symbol> unusedPkgImports;

    private final Set<Pair<Symbol, ClassIndexImpl.UsageType>> packageAnnotations;

    private final Set<CharSequence> importIdents;

    private final Set<CharSequence> packageAnnotationIdents;

    private final boolean virtual;

    private final boolean[] mainMethod;

    private final Neo4jIndex index;

    private final RootNode rootNode;

    private boolean isStaticImport;

    private boolean isPkgImport;

    private State state;

    private Element enclosingElement = null;

    private Set<String> rsList;         //List of references from source in case when the source has more top levels or is wrongly packaged

    private boolean crossedTopLevel;    //True when the visitor already reached the correctly packaged top level

    private PackageNode packageNode;

    private CompilationUnitTree cu;

    private Map<ClassNode, Map<String, BitSet>> usages;

    public Neo4jAnalyzer(

            final JavacTaskImpl jt,

            final JavaFileManager manager,

            final JavaCustomIndexer.CompileTuple tuple,

            final Set<? super ElementHandle<TypeElement>> newTypes,

            final boolean[] mainMethod) throws MalformedURLException, IllegalArgumentException {

        assert jt != null;

        assert manager != null;

        assert tuple != null;

        assert mainMethod != null;

        this.activeClass = new Stack<ClassNode>();

        this.imports = new HashSet<Symbol>();

        this.staticImports = new HashSet<Symbol>();

        this.unusedPkgImports = new HashSet<Symbol>();

        this.importIdents = new HashSet<CharSequence>();

        this.packageAnnotationIdents = new HashSet<CharSequence>();

        this.packageAnnotations = new HashSet<Pair<Symbol, ClassIndexImpl.UsageType>>();

        final Names names = Names.instance(jt.getContext());

        this.errorName = names.error;

        this.pkgImportName = names.asterisk;

        this.state = State.OTHER;

        this.signatureFiles = true;

        this.virtual = tuple.virtual;

        this.siblingUrl = virtual ? tuple.indexable.getURL() : tuple.jfo.toUri().toURL();

        this.sourceName = inferBinaryName(manager, tuple.jfo);

        this.topLevels = null;

        this.newTypes = newTypes;

        this.mainMethod = mainMethod;

        index = Neo4jIndex.getDefault();

        neoTx = TransactionContext.get().get(Neo4jIndexTransaction.class);

        rootNode = neoTx.getRootNode();

        usages = new HashMap<ClassNode, Map<String, BitSet>>();

    }

    @Override

    @CheckForNull

    public Void scan(@NonNull final Tree node, @NullAllowed final Void nil) {

        if (node == null) {

            return null;

        }

        super.scan(node, nil);

        return null;

    }

    @Override

    @CheckForNull

    public Void visitCompilationUnit(@NonNull final CompilationUnitTree node, @NullAllowed final Void nil) {

        this.cu = node;

        State oldState = state;

        try {

            state = State.PACKAGE_ANN;

            scan(node.getPackageAnnotations(), nil);

            scan(node.getPackageName(), nil);

            packageNode = index.getOrCreatePackage(rootNode, node.getPackageName().toString());

            state = State.IMPORT;

            scan(node.getImports(), nil);

        } finally {

            state = oldState;

        }

        scan(node.getTypeDecls(), nil);

        ClassNode classNode = null;

        if (!imports.isEmpty()

                || !staticImports.isEmpty()

                || !unusedPkgImports.isEmpty()) {

            //Empty file

            String className = getResourceSimpleName(node);

            if (className != null) {

                classNode = index.createClass(

                        packageNode,

                        className,

                        className,

                        ElementKind.CLASS,

                        null);

            }

            addAndClearImports(classNode);

            addAndClearUnusedPkgImports(classNode);

        }

        if (!packageAnnotations.isEmpty()) {

            if (classNode == null) {

                String className = getResourceSimpleName(node);

                if (className != null) {

                    classNode = index.createClass(

                            packageNode,

                            className,

                            className,

                            ElementKind.CLASS,

                            null);

                    for (Pair<Symbol, ClassIndexImpl.UsageType> usage : packageAnnotations) {

                        addUsage(classNode, usage.first, usage.second);

                    }

//TODO:                        for (CharSequence ident : packageAnnotationIdents) {

//                            addIdent(name, ident, p, false);

//                        }

                }

            }

            packageAnnotations.clear();

            packageAnnotationIdents.clear();

        }

        storeUsages();

        return null;

    }

    @Override

    @CheckForNull

    public Void visitClass(@NonNull final ClassTree node, @NullAllowed final Void nil) {

        final Symbol.ClassSymbol sym = ((JCTree.JCClassDecl) node).sym;

        boolean errorInDecl = false;

        boolean errorIgnorSubtree = true;

        boolean topLevel = false;

        String className = null;

        ClassNode classNode = null;

        if (sym != null) {

            errorInDecl = hasErrorName(sym);

            if (errorInDecl) {

                if (!activeClass.isEmpty()) {

                    classNode = activeClass.get(0);

                } else {

                    topLevel = true;

                    className = getResourceName(this.cu);

                    if (className != null && !className.isEmpty()) {

                        final String simpleName = className.substring(className.lastIndexOf('.') + 1);  //NOI18N

                        classNode = index.createClass(

                                packageNode,

                                simpleName,

                                simpleName,

                                ElementKind.CLASS,

                                null);

                    } else {

                        LOG.log(

                                Level.WARNING,

                                "Cannot resolve {0} (class name: {1}), ignoring whole subtree.", //NOI18N

                                new Object[]{

                                    sym,

                                    className

                                });

                    }

                }

            } else {

                final StringBuilder classNameBuilder = new StringBuilder();

                ClassFileUtil.encodeClassName(sym, classNameBuilder, '.');  //NOI18N

                className = classNameBuilder.toString();

                if (!className.isEmpty()) {

                    ElementKind classType = sym.getKind();

                    String resourceName = null;

                    topLevel = activeClass.isEmpty();

                    if (topLevel) {

                        if (virtual || !className.equals(sourceName)) {

                            if (signatureFiles && rsList == null) {

                                rsList = new HashSet<String>();

                                if (crossedTopLevel) {

                                    rsList.add(sourceName);

                                }

                            }

                            final StringBuilder rnBuilder = new StringBuilder(FileObjects.convertPackage2Folder(sourceName));

                            rnBuilder.append('.');  //NOI18N

                            rnBuilder.append(FileObjects.getExtension(siblingUrl.getPath()));

                            resourceName = rnBuilder.toString();

                        } else {

                            crossedTopLevel = true;

                        }

                    } else {

                        resourceName = activeClass.peek().getResourceName();

                    }

                    classNode = index.createClass(

                            packageNode,

                            sym.getSimpleName().toString(),

                            className.substring(className.lastIndexOf('.') + 1),    //NOI18N

                            classType,

                            resourceName);

                } else {

                    LOG.log(

                            Level.WARNING,

                            "Invalid symbol {0} (source: {1}), ignoring whole subtree.", //NOI18N

                            new Object[]{

                                sym,

                                siblingUrl

                            });

                }

            }

        }

        if (classNode != null) {

            activeClass.push(classNode);

            errorIgnorSubtree = false;

            if (className != null) {

                if (topLevel) {

                    if (topLevels != null) {

                        topLevels.add(Pair.<String, String>of(className, classNode.getResourceName()));

                    }

                    addAndClearImports(classNode);

                }

                addUsage(classNode, className, ClassIndexImpl.UsageType.TYPE_REFERENCE);

                // index only simple name, not FQN for classes

//TODO:                    addIdent(classNode, simpleName, nil, true);

                if (newTypes != null) {

                    newTypes.add((ElementHandle<TypeElement>) ElementHandle.createTypeElementHandle(ElementKind.CLASS, className));

                }

            }

        }

        if (!errorIgnorSubtree) {

            Element old = enclosingElement;

            try {

                enclosingElement = sym;

                scan(node.getModifiers(), nil);

                scan(node.getTypeParameters(), nil);

                state = errorInDecl ? State.OTHER : State.EXTENDS;

                scan(node.getExtendsClause(), nil);

                state = errorInDecl ? State.OTHER : State.IMPLEMENTS;

                scan(node.getImplementsClause(), nil);

                state = State.OTHER;

                scan(node.getMembers(), nil);

                activeClass.pop();

            } finally {

                enclosingElement = old;

            }

        }

        if (!errorInDecl && this.rsList != null) {

            this.rsList.add(className);

        }

        if (topLevel) {

            addAndClearUnusedPkgImports(classNode);

        }

        return null;

    }

    @Override

    @CheckForNull

    public Void visitNewClass(@NonNull final NewClassTree node, @NullAllowed final Void nil) {

        final Symbol sym = ((JCTree.JCNewClass) node).constructor;

        if (sym != null) {

            final Symbol owner = sym.getEnclosingElement();

            if (owner != null && owner.getKind().isClass()) {

                addUsage(

                        activeClass.peek(),

                        owner,

                        ClassIndexImpl.UsageType.METHOD_REFERENCE);

            }

        }

        return super.visitNewClass(node, nil);

    }

    @Override

    @CheckForNull

    public Void visitErroneous(@NonNull final ErroneousTree tree, @NullAllowed final Void nil) {

        List<? extends Tree> trees = tree.getErrorTrees();

        for (Tree t : trees) {

            this.scan(t, nil);

        }

        return null;

    }

    @Override

    @CheckForNull

    public Void visitMethod(@NonNull final MethodTree node, @NullAllowed final Void nil) {

        Element old = enclosingElement;

        try {

            enclosingElement = ((JCTree.JCMethodDecl) node).sym;

            if (enclosingElement != null && enclosingElement.getKind() == ElementKind.METHOD) {

                mainMethod[0] |= SourceUtils.isMainMethod((ExecutableElement) enclosingElement);

                // do not add idents for constructors, they always match their class' name, which is added as an ident separately

//todo:                    addIdent(activeClass.peek(), node.getName(), p, true);

            }

            return super.visitMethod(node, nil);

        } finally {

            enclosingElement = old;

        }

    }

    @Override

    @CheckForNull

    public Void visitVariable(@NonNull final VariableTree node, @NullAllowed final Void nil) {

        Symbol s = ((JCTree.JCVariableDecl) node).sym;

        if (s != null && s.owner != null && (s.owner.getKind().isClass() || s.owner.getKind().isInterface())) {

//todo:                addIdent(activeClass.peek(), node.getName(), p, true);

        }

        return super.visitVariable(node, nil);

    }

    @Override

    @CheckForNull

    public Void visitMemberSelect(@NonNull final MemberSelectTree node, @NullAllowed final Void nil) {

        handleVisitIdentSelect(((JCTree.JCFieldAccess) node).sym, node.getIdentifier());

        State oldState = this.state;

        this.state = (this.state == State.IMPORT || state == State.PACKAGE_ANN) ? state : State.OTHER;

        Void ret = super.visitMemberSelect(node, nil);

        this.state = oldState;

        return ret;

    }

    @Override

    @CheckForNull

    public Void visitIdentifier(@NonNull final IdentifierTree node, @NonNull @NullAllowed final Void nil) {

        handleVisitIdentSelect(((JCTree.JCIdent) node).sym, node.getName());

        return super.visitIdentifier(node, nil);

    }

    @Override

    @CheckForNull

    public Void visitImport(@NonNull final ImportTree node, @NullAllowed final Void nil) {

        this.isStaticImport = node.isStatic();

        final Tree qit = node.getQualifiedIdentifier();

        isPkgImport = qit.getKind() == Tree.Kind.MEMBER_SELECT && pkgImportName == (((MemberSelectTree) qit).getIdentifier());

        final Void ret = super.visitImport(node, nil);

        isStaticImport = isPkgImport = false;

        return ret;

    }

    private void handleVisitIdentSelect(

            @NullAllowed final Symbol sym,

            @NonNull final CharSequence name) {

        if (!activeClass.empty()) {

//todo:                addIdent(activeClass.peek(), name, p, false);

            if (sym != null) {

                if (sym.kind == Kinds.ERR) {

                    final Symbol owner = sym.getEnclosingElement();

                    if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                        addUsage(activeClass.peek(), owner, ClassIndexImpl.UsageType.TYPE_REFERENCE);

                    }

                }

                if (sym.getKind().isClass() || sym.getKind().isInterface()) {

                    switch (this.state) {

                        case EXTENDS:

                            addUsage(activeClass.peek(), sym, ClassIndexImpl.UsageType.SUPER_CLASS);

                            break;

                        case IMPLEMENTS:

                            addUsage(activeClass.peek(), sym, ClassIndexImpl.UsageType.SUPER_INTERFACE);

                            break;

                        case OTHER:

                        case GT:

                            addUsage(activeClass.peek(), sym, ClassIndexImpl.UsageType.TYPE_REFERENCE);

                            break;

                    }

                } else if (sym.getKind().isField()) {

                    final Symbol owner = sym.getEnclosingElement();

                    if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                        addUsage(activeClass.peek(), owner, ClassIndexImpl.UsageType.FIELD_REFERENCE);

                    }

                    recordTypeUsage(sym.asType());

                } else if (sym.getKind() == ElementKind.CONSTRUCTOR || sym.getKind() == ElementKind.METHOD) {

                    final Symbol owner = sym.getEnclosingElement();

                    if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                        addUsage(activeClass.peek(), owner, ClassIndexImpl.UsageType.METHOD_REFERENCE);

                    }

                    recordTypeUsage(((Symbol.MethodSymbol) sym).getReturnType());

                }

            }

        } else {

            if (state == State.IMPORT) {

                importIdents.add(name);

                if (sym != null && (sym.getKind().isClass() || sym.getKind().isInterface())) {

                    if (this.isStaticImport) {

                        this.staticImports.add(sym);

                    } else {

                        this.imports.add(sym);

                    }

                } else if (isPkgImport && sym != null && sym.getKind() == ElementKind.PACKAGE) {

                    unusedPkgImports.add(sym);

                    isPkgImport = false;

                }

            } else if (state == State.PACKAGE_ANN) {

                packageAnnotationIdents.add(name);

                if (sym != null) {

                    if (sym.kind == Kinds.ERR) {

                        final Symbol owner = sym.getEnclosingElement();

                        if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                            packageAnnotations.add(Pair.of(owner, ClassIndexImpl.UsageType.TYPE_REFERENCE));

                        }

                    }

                    if (sym.getKind().isClass() || sym.getKind().isInterface()) {

                        packageAnnotations.add(Pair.of(sym, ClassIndexImpl.UsageType.TYPE_REFERENCE));

                    } else if (sym.getKind().isField()) {

                        final Symbol owner = sym.getEnclosingElement();

                        if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                            packageAnnotations.add(Pair.of(owner, ClassIndexImpl.UsageType.FIELD_REFERENCE));

                        }

                    } else if (sym.getKind() == ElementKind.CONSTRUCTOR || sym.getKind() == ElementKind.METHOD) {

                        final Symbol owner = sym.getEnclosingElement();

                        if (owner.getKind().isClass() || owner.getKind().isInterface()) {

                            packageAnnotations.add(Pair.of(owner, ClassIndexImpl.UsageType.METHOD_REFERENCE));

                        }

                    }

                }

            }

        }

    }

    @Override

    @CheckForNull

    public Void visitParameterizedType(@NonNull final ParameterizedTypeTree node, @NullAllowed final Void nil) {

        scan(node.getType(), nil);

        State currState = this.state;

        this.state = State.GT;

        scan(node.getTypeArguments(), nil);

        this.state = currState;

        return null;

    }

    @NonNull

    private String inferBinaryName(

            @NonNull final JavaFileManager jfm,

            @NonNull final javax.tools.JavaFileObject jfo) throws IllegalArgumentException {

        String result = jfm.inferBinaryName(StandardLocation.SOURCE_PATH, jfo);

        if (result != null) {

            return result;

        }

        FileObject fo = null;

        ClassPath scp = null;

        try {

            fo = URLMapper.findFileObject(jfo.toUri().toURL());

            if (fo != null) {

                scp = ClassPath.getClassPath(fo, ClassPath.SOURCE);

                if (scp != null) {

                    result = scp.getResourceName(fo, '.', false); //NOI18N

                    if (result != null) {

                        return result;

                    }

                }

            }

        } catch (MalformedURLException e) {

            //pass - throws IAE

        }

        throw new IllegalArgumentException(String.format("File: %s Type: %s FileObject: %s Sourcepath: %s", //NOI18N

                jfo.toUri().toString(),

                jfo.getClass().getName(),

                fo == null ? "<null>" : FileUtil.getFileDisplayName(fo), //NOI18N

                scp == null ? "<null>" : scp.toString()));   //NOI18N

    }

    @CheckForNull

    private static String getResourceSimpleName(@NullAllowed final CompilationUnitTree cu) {

        final FileObject file = findFile(cu);

        if (file != null) {

            return file.getName();

        }

        return null;

    }

    @CheckForNull

    private static String getResourceName (@NullAllowed final CompilationUnitTree cu) {

        final FileObject file = findFile(cu);

        if (file != null) {

            final ClassPath cp = ClassPath.getClassPath(file,ClassPath.SOURCE);

            if (cp != null) {

                return cp.getResourceName(file,'.',false);

            }

        }

        return null;

    }

    @CheckForNull

    private static FileObject findFile(@NullAllowed final CompilationUnitTree cu) {

        if (cu instanceof JCTree.JCCompilationUnit) {

            JavaFileObject jfo = ((JCTree.JCCompilationUnit)cu).sourcefile;

            if (jfo != null) {

                URI uri = jfo.toUri();

                if (uri != null && uri.isAbsolute()) {

                    try {

                        FileObject fo = URLMapper.findFileObject(uri.toURL());

                        return fo;

                    } catch (MalformedURLException e) {

                        Exceptions.printStackTrace(e);

                    }

                }

            }

        }

        return null;

    }

    private boolean hasErrorName(@NullAllowed Symbol cs) {

        while (cs != null) {

            if (cs.name == errorName) {

                return true;

            }

            cs = cs.getEnclosingElement();

        }

        return false;

    }

    private void addAndClearImports(

            @NullAllowed final ClassNode classNode) {

        if (classNode != null) {

            for (Symbol s : imports) {

                addUsage(

                        classNode,

                        s,

                        ClassIndexImpl.UsageType.TYPE_REFERENCE);

            }

            for (Symbol s : staticImports) {

                addUsage(

                        classNode,

                        s,                        

                        ClassIndexImpl.UsageType.TYPE_REFERENCE,

                        ClassIndexImpl.UsageType.METHOD_REFERENCE,

                        ClassIndexImpl.UsageType.FIELD_REFERENCE);

            }

//TODO:                for (CharSequence s : importIdents) {

//                    addIdent(nameOfCU, s, data, false);

//                }

        }

        imports.clear();

        staticImports.clear();

        importIdents.clear();

    }

    private void addAndClearUnusedPkgImports(

            @NullAllowed final ClassNode classNode) {

        if (classNode != null) {

            for (Symbol s : unusedPkgImports) {

                final StringBuilder sb = new StringBuilder();

                sb.append(s.getQualifiedName());

                sb.append(".package-info"); //NOI18N

                addUsage(classNode, sb.toString(), ClassIndexImpl.UsageType.TYPE_REFERENCE);

            }

        }

        unusedPkgImports.clear();

    }

    @CheckForNull

    private static String encodeClassName(@NonNull final Symbol sym) {

        assert sym instanceof Symbol.ClassSymbol;

        TypeElement toEncode = null;

        final TypeMirror type = ((Symbol.ClassSymbol) sym).asType();

        if (sym.getEnclosingElement().getKind() == ElementKind.TYPE_PARAMETER) {

            if (type.getKind() == TypeKind.ARRAY) {

                TypeMirror ctype = ((ArrayType) type).getComponentType();

                if (ctype.getKind() == TypeKind.DECLARED) {

                    toEncode = (TypeElement) ((DeclaredType) ctype).asElement();

                }

            }

        } else {

            toEncode = (TypeElement) sym;

        }

        return toEncode == null ? null : ClassFileUtil.encodeClassName(toEncode);

    }

    private void addUsage(@NonNull final ClassNode classNode,

            @NullAllowed final Symbol sym,

            @NonNull final ClassIndexImpl.UsageType... usageTypes) {

        assert classNode != null;

        assert usageTypes != null;

        if (sym != null) {

            final String className = encodeClassName(sym);

            for (ClassIndexImpl.UsageType usageType : usageTypes) {

                addUsage(classNode, className, usageType);

            }

            final Symbol encElm = sym.getEnclosingElement();

            if (encElm.getKind() == ElementKind.PACKAGE) {

                unusedPkgImports.remove(encElm);

            }

        }

    }

    private void addUsage(

            @NonNull final ClassNode classNode,

            @NullAllowed final Symbol sym,

            @NonNull final ClassIndexImpl.UsageType usageType) {

        assert classNode != null;

        assert usageType != null;

        if (sym != null) {

            final String className = encodeClassName(sym);

            addUsage(classNode, className, usageType);

            final Symbol encElm = sym.getEnclosingElement();

            if (encElm.getKind() == ElementKind.PACKAGE) {

                unusedPkgImports.remove(encElm);

            }

        }

    }

    private void addUsage(

            @NonNull final ClassNode user,

            @NullAllowed final String className,

            @NonNull final ClassIndexImpl.UsageType type) {

        if (className != null) {

            Map<String,BitSet> usagesForClass = usages.get(user);

            if (usagesForClass == null) {

                usagesForClass = new HashMap<String, BitSet>();

                usages.put(user, usagesForClass);

            }

            BitSet usageTypes = usagesForClass.get(className);

            if (usageTypes == null) {

                usageTypes = new BitSet(ClassIndexImpl.UsageType.values().length);

                usagesForClass.put(className, usageTypes);

            }

            usageTypes.set(type.ordinal());

        }

    }

    private void storeUsages() {

        for (Map.Entry<ClassNode,Map<String,BitSet>> cu : usages.entrySet()) {

            final ClassNode user = cu.getKey();

            for (Map.Entry<String,BitSet> us : cu.getValue().entrySet()) {

                final String className = us.getKey();

                TypeReferenceNode reference = neoTx.getCachedTypeReference(className);

                if (reference == null) {

                    reference = index.getOrCreateTypeReference(className);

                    neoTx.cacheTypeReference(className, reference);

                }

                user.uses(reference, us.getValue());

            }

        }

    }

    private void recordTypeUsage(final TypeMirror type) {

        Deque<TypeMirror> types = new ArrayDeque<TypeMirror>();

        types.add(type);

        while (!types.isEmpty()) {

            TypeMirror currentType = types.removeFirst();

            if (currentType == null) {

                continue;

            }

            switch (currentType.getKind()) {

                case DECLARED:

                    final Symbol typeSym = ((Type) currentType).tsym;

                    if (typeSym != null && (typeSym.getKind().isClass() || typeSym.getKind().isInterface())) {

                        addUsage(activeClass.peek(), typeSym, ClassIndexImpl.UsageType.TYPE_REFERENCE);

                    }

                    types.addAll(((DeclaredType) currentType).getTypeArguments());

                    break;

                case ARRAY:

                    types.add(((ArrayType) currentType).getComponentType());

                    break;

            }

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import com.sun.source.tree.ClassTree;

import com.sun.tools.javac.tree.JCTree;

import java.net.URL;

import javax.lang.model.element.ElementKind;

import org.neo4j.graphdb.Node;

import org.neo4j.graphdb.Transaction;

import org.neo4j.graphdb.index.Index;

import org.neo4j.kernel.EmbeddedGraphDatabase;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.api.annotations.common.NullAllowed;

/**

 *

 * @author tom

 */

public class Neo4jIndex {

    private static final String ROOTS_INDEX = "roots";  //NOI18N

    private static final String PACKAGES_INDEX = "packages";  //NOI18N

    private static final String CLASSES_INDEX = "classes";  //NOI18N

    private static final String HANDLES_INDEX = "type-references";    //NOI18N

    //GuardedBy("Neo4jIndex.class")

    private static Neo4jIndex instance;

    //GuardedBy("this")

    private  EmbeddedGraphDatabase db;

    //GuardedBy("this")

    private Index<Node> roots;

    //GuardedBy("this")

    private Index<Node> packages;

    //GuardedBy("this")

    private Index<Node> classSimpleNames;

    //GuardedBy("this")

    private Index<Node> references;

    //GuardedBy("this")

    private RootNode.Factory rootFactory;

    //GuardedBy("this")

    private PackageNode.Factory packageFactory;

    //GuardedBy("this")

    private TypeReferenceNode.Factory typeReferenceFactory;

    private Neo4jIndex() {

    }

    public synchronized void start() {

        if (db == null) {

            db = new EmbeddedGraphDatabase("/tmp/neo");

            roots = db.index().forNodes(ROOTS_INDEX);

            packages = db.index().forNodes(PACKAGES_INDEX);

            classSimpleNames = db.index().forNodes(CLASSES_INDEX);

            references = db.index().forNodes(HANDLES_INDEX);

            rootFactory = new RootNode.Factory(roots);

            packageFactory = new PackageNode.Factory(packages);

            typeReferenceFactory = new TypeReferenceNode.Factory(references);

        }

    }

    public synchronized void stop() {

        if (db != null) {

            db.shutdown();

            db = null;

            roots = null;

            packages = null;

            classSimpleNames = null;

            references = null;

            rootFactory = null;

            packageFactory = null;

            typeReferenceFactory = null;

        }

    }

    @NonNull

    Transaction begin() {

        return db.beginTx();

    }

    void commit(@NonNull final Transaction tx) {

        try {

            tx.success();

        } finally {

            tx.finish();

        }

    }

    void rollBack(@NonNull final Transaction tx) {

        try {

            tx.failure();

        } finally {

            tx.finish();

        }

    }

    RootNode getOrCreateRoot(@NonNull final URL url) {

        return rootFactory.getOrCreate(url.toExternalForm());

    }

    PackageNode getOrCreatePackage(

            @NonNull final RootNode root,

            @NonNull final String packageName) {

        packageFactory.setRoot(root);

        return packageFactory.getOrCreate(packageName);

    }

    ClassNode createClass(

            @NonNull final PackageNode packageNode,

            @NonNull final String simpleName,

            @NonNull final String binaryName,

            @NonNull final ElementKind kind,

            @NullAllowed final String resourceName) {

        return ClassNode.create(

                db,

                classSimpleNames,

                binaryName,

                simpleName,

                packageNode,

                kind,

                resourceName);

    }

    TypeReferenceNode getOrCreateTypeReference(@NonNull final String binaryName) {

        return typeReferenceFactory.getOrCreate(binaryName);

    }

//    public Node lookupClass(ClassTree classTree) {

//        // determine if the class is part of the current scope, then link directly

//        // other lookup or create a placeholder type and link to that

//        return classes.get("fqn", className(classTree)).getSingle();

//    }

//    public Collection<String> methodNames(ClassTree className) {

//        // start class=node:classes(name="foo") match class-[:METHOD_OF]->method where method.name in "bar.*" return method limit 5;

//        final Relationship methodRel = lookupClass(className).getSingleRelationship(Direction.OUTGOING, RelTypes.METHOD_OF);

//        final Iterable<Relationship> methodRels = lookupClass(className).getRelationships(Direction.OUTGOING, RelTypes.METHOD_OF);

//        Collection<String> result=new ArrayList<String>();

//        for (Relationship relationship : methodRels) {

//            Node methodNode = relationship.getEndNode();

//            result.add((String)methodNode.getProperty("name"));

//        }

//        return result;

//    }

//    public void addMethod(ClassTree classTree, MethodTree methodTree){

//        Node classNode = getOrCreateClass(classTree);

//        Node methodNode=db.createNode();

//        classes.add(methodNode, "methodSignature", vmSignature);   //Indexed field

//        classNode.createRelationshipTo(methodNode, RelTypes.METHOD_OF);

//        ExecutableElement method  = ((JCTree.JCMethodDecl) methodTree).sym;

//        String returnType = method.getReturnType().toString();

//        methodNode.createRelationshipTo(getOrCreateClass(returnType), RelTypes.RETURN_TYPE);

//

//    }

    public static synchronized Neo4jIndex getDefault() {

        if (instance == null) {

            instance = new Neo4jIndex();

        }

        return instance;

    }

    private String className(final ClassTree classTree) {

        return ((JCTree.JCClassDecl)classTree).sym.fullname.toString();

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import java.io.IOException;

import java.net.URL;

import java.util.HashMap;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.neo4j.graphdb.Transaction;

import org.netbeans.api.annotations.common.CheckForNull;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.modules.java.source.indexing.TransactionContext;

/**

 *

 * @author Tomas Zezula

 */

public class Neo4jIndexTransaction extends TransactionContext.Service {

    private static final Logger LOG = Logger.getLogger(Neo4jIndexTransaction.class.getName());

    private final URL root;

    private final Neo4jIndex index;

    private final Transaction tx;

    private final Map<String,PackageNode> pkgCache;

    private final Map<String,TypeReferenceNode> clsCache;

    private RootNode rootNode;

    private Neo4jIndexTransaction(@NonNull final URL root) {

        this.root = root;

        this.index = Neo4jIndex.getDefault();

        this.tx = index.begin();

        this.clsCache = new HashMap<String, TypeReferenceNode>();

        this.pkgCache = new HashMap<String, PackageNode>();

        TimeLogger.clear();

    }

    @Override

    protected void commit() throws IOException {

        try {

            freeCache();

        } finally {

            index.commit(tx);

            LOG.log(

                Level.INFO,

                "Time spent in neo4j: {0} ms for root: {1}.",  //NOI18N

                new Object[]{

                    TimeLogger.getMillis(),

                    root

                });

        }

    }

    @Override

    protected void rollBack() throws IOException {

        try {

            freeCache();

        } finally {

            index.rollBack(tx);

        }

    }

    @NonNull

    RootNode getRootNode() {

        if (rootNode == null) {

            rootNode = index.getOrCreateRoot(root);

        }

        return rootNode;

    }

    @CheckForNull

    PackageNode getCachedPackage(@NonNull final String fqn) {

        return pkgCache.get(fqn);

    }

    void cachePackage(

            @NonNull final String fqn,

            @NonNull final PackageNode node) {

        pkgCache.put(fqn,node);

    }

    @CheckForNull

    TypeReferenceNode getCachedTypeReference(@NonNull final String fqn) {

        return clsCache.get(fqn);

    }

    void cacheTypeReference(

            @NonNull final String fqn,

            @NonNull final TypeReferenceNode node) {

        clsCache.put(fqn,node);

    }

    private void freeCache() {

        clsCache.clear();

        pkgCache.clear();

    }

    public static Neo4jIndexTransaction create(@NonNull final URL root) {

        return new Neo4jIndexTransaction(root);

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import java.util.Map;

import org.neo4j.graphdb.Node;

import org.neo4j.graphdb.index.Index;

import org.neo4j.graphdb.index.UniqueFactory;

import org.netbeans.api.annotations.common.NonNull;

/**

 *

 * @author Tomas Zezula

 */

class PackageNode extends ModelNode {

    private PackageNode(Node node) {

        super(node);

    }

    //@NotThreadSafe

    static class Factory extends UniqueFactory.UniqueNodeFactory {

        private static final String PROP_NAME = "name"; //NOI18N

        private RootNode root;

        Factory(

                @NonNull final Index<Node> packageIndex) {

            super(packageIndex);

        }

        @Override

        protected void initialize(

                @NonNull final Node t,

                @NonNull final Map<String, Object> map) {

            t.setProperty(PROP_NAME, map.get(PROP_NAME));

            t.createRelationshipTo(root.node, RelationshipTypes.IN_ROOT);

        }

        void setRoot(@NonNull final RootNode root) {

            this.root = root;

        }

        PackageNode getOrCreate(String name) {

            TimeLogger.start();

            try {

                return new PackageNode(getOrCreate(PROP_NAME, name));

            } finally {

                TimeLogger.stop();

            }

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import org.neo4j.graphdb.RelationshipType;

import org.netbeans.api.annotations.common.NonNull;

import org.netbeans.modules.java.source.usages.ClassIndexImpl;

/**

 *

 * @author Tomas Zezula

 */

enum RelationshipTypes implements RelationshipType {

    IN_ROOT,

    IN_PACKAGE,

    SUPER_CLASS,

    SUPER_INTERFACE,

    FIELD_REFERENCE,

    METHOD_REFERENCE,

    TYPE_REFERENCE;

    private static final RelationshipTypes[] translation;

    static {

        final ClassIndexImpl.UsageType[] values = ClassIndexImpl.UsageType.values();

        translation = new RelationshipTypes[values.length];

        for (int i = 0; i < values.length; i++) {

            translation[i] = fromUsageType(values[i]);

        }

    }

    @NonNull

    static RelationshipTypes fromUsageType(@NonNull final ClassIndexImpl.UsageType ut) {

        switch (ut) {

            case FIELD_REFERENCE:

                return FIELD_REFERENCE;

            case METHOD_REFERENCE:

                return METHOD_REFERENCE;

            case SUPER_CLASS:

                return SUPER_CLASS;

            case SUPER_INTERFACE:

                return SUPER_INTERFACE;

            case TYPE_REFERENCE:

                return TYPE_REFERENCE;

            default:

                throw new IllegalArgumentException(ut.toString());

        }

    }

    static RelationshipTypes fromUsageTypeOrdinal(final int ordinal) {

        checkRange(ordinal, translation.length);

        return translation[ordinal];

    }

    private static void checkRange(int index, int len) {

        if (index < 0 || index >= len) {

            throw new IllegalArgumentException(String.format("Index: %d, Length: %d", index, len)); //NOI18N

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import java.util.Map;

import org.neo4j.graphdb.Node;

import org.neo4j.graphdb.index.Index;

import org.neo4j.graphdb.index.UniqueFactory.UniqueNodeFactory;

import org.netbeans.api.annotations.common.NonNull;

/**

 *

 * @author Tomas Zezula

 */

class RootNode extends ModelNode {

    private static final String PROP_LOCATION = "location"; //NOI18N

    private RootNode(@NonNull Node node) {

        super(node);

    }

    String getURL() {

        return (String) node.getProperty(PROP_LOCATION);

    }

    static final class Factory extends UniqueNodeFactory {

        Factory(

                @NonNull final Index<Node> rootIndex) {

            super(rootIndex);

        }

        @Override

        protected void initialize(Node t, Map<String, Object> map) {

            t.setProperty(PROP_LOCATION, map.get(PROP_LOCATION));

        }

        RootNode getOrCreate(String name) {

            TimeLogger.start();

            try {

                return new RootNode(getOrCreate(PROP_LOCATION, name));

            } finally {

                TimeLogger.stop();

            }

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

/**

 *

 * @author Tomas Zezula

 */

class TimeLogger {

    private static long time = 0;

    private static long startTime = 0;

    static void clear() {

        time = 0;

    }

    static void start() {

        if (startTime != 0) {

            throw new IllegalStateException();

        }

        startTime = System.nanoTime();

    }

    static void stop() {

        long stopTime = System.nanoTime();

        if (startTime == 0) {

            throw new IllegalStateException();

        }

        time+=(stopTime - startTime);

        startTime = 0;

    }

    static long getMillis() {

        return time/1000000;

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2012 Sun Microsystems, Inc.

 */

package org.netbeans.modules.java.source.indexing.neo4j;

import java.util.Map;

import org.neo4j.graphdb.Node;

import org.neo4j.graphdb.index.Index;

import org.neo4j.graphdb.index.UniqueFactory;

import org.netbeans.api.annotations.common.NonNull;

/**

 *

 * @author Tomas Zezula

 */

class TypeReferenceNode extends ModelNode {

    private TypeReferenceNode(@NonNull final Node node) {

        super(node);

    }

    static class Factory extends UniqueFactory.UniqueNodeFactory {

        private static final String PROP_BIN_NAME = "binName";

        Factory(

                @NonNull final Index<Node> classIndex) {

            super(classIndex);

        }

        @Override

        protected void initialize(Node t, Map<String, Object> map) {

            t.setProperty(PROP_BIN_NAME, map.get(PROP_BIN_NAME));

        }

        TypeReferenceNode getOrCreate(String name) {

            TimeLogger.start();

            try {

                return new TypeReferenceNode(getOrCreate(PROP_BIN_NAME, name));

            } finally {

                TimeLogger.stop();

            }

        }

    }

}

<?xml version="1.0" encoding="UTF-8"?>

<!--

DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.

Oracle and Java are registered trademarks of Oracle and/or its affiliates.

Other names may be trademarks of their respective owners.

The contents of this file are subject to the terms of either the GNU

General Public License Version 2 only ("GPL") or the Common

Development and Distribution License("CDDL") (collectively, the

"License"). You may not use this file except in compliance with the

License. You can obtain a copy of the License at

http://www.netbeans.org/cddl-gplv2.html

or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

specific language governing permissions and limitations under the