Attachment #110745 for bug #202063

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 202063
Collapse All | Expand All

Lines 42-48 Link Here

(-)a/java.editor/nbproject/project.properties (-1 / +1 lines)
42		42
43	javadoc.title=Java Editor	43	javadoc.title=Java Editor
44		44
45	spec.version.base=2.37.0	45	spec.version.base=2.38.0
46	test.qa-functional.cp.extra=${editor.dir}/modules/org-netbeans-modules-editor-fold.jar	46	test.qa-functional.cp.extra=${editor.dir}/modules/org-netbeans-modules-editor-fold.jar
47	javac.source=1.6	47	javac.source=1.6
48	#test.unit.cp.extra=	48	#test.unit.cp.extra=




                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.parsing.lucene</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <release-version>2</release-version>
                        <specification-version>2.3</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>
                    <code-name-base>org.netbeans.modules.projectapi</code-name-base>
                    <build-prerequisite/>
                    <compile-dependency/>

                    <build-prerequisite/>
                    <compile-dependency/>
                    <run-dependency>
                        <specification-version>1.2</specification-version>
                    </run-dependency>
                </dependency>
                <dependency>

Lines 42-53 Link Here

(-)a/java.editor/src/org/netbeans/modules/java/editor/whitelist/WhiteListCheckTask.java (-13 / +21 lines)
42	package org.netbeans.modules.java.editor.whitelist;	42	package org.netbeans.modules.java.editor.whitelist;
43		43
44	import com.sun.source.tree.CompilationUnitTree;	44	import com.sun.source.tree.CompilationUnitTree;
		45	import com.sun.source.tree.Tree;
45	import com.sun.source.util.SourcePositions;	46	import com.sun.source.util.SourcePositions;
46	import java.util.ArrayList;	47	import java.util.ArrayList;
47	import java.util.Collection;	48	import java.util.Collection;
48	import java.util.Collections;	49	import java.util.Collections;
49	import java.util.LinkedList;
50	import java.util.List;	50	import java.util.List;
		51	import java.util.Map;
		52	import java.util.concurrent.Callable;
51	import java.util.concurrent.atomic.AtomicBoolean;	53	import java.util.concurrent.atomic.AtomicBoolean;
52	import org.netbeans.api.editor.mimelookup.MimeRegistration;	54	import org.netbeans.api.editor.mimelookup.MimeRegistration;
53	import org.netbeans.api.java.source.CompilationInfo;	55	import org.netbeans.api.java.source.CompilationInfo;
Lines 65-70 Link Here
65	import org.netbeans.spi.editor.hints.ErrorDescriptionFactory;	67	import org.netbeans.spi.editor.hints.ErrorDescriptionFactory;
66	import org.netbeans.spi.editor.hints.HintsController;	68	import org.netbeans.spi.editor.hints.HintsController;
67	import org.netbeans.spi.editor.hints.Severity;	69	import org.netbeans.spi.editor.hints.Severity;
		70	import org.netbeans.api.whitelist.support.WhiteListSupport;
68	import org.openide.filesystems.FileObject;	71	import org.openide.filesystems.FileObject;
69		72
70	/**	73	/**
Lines 96-124 Link Here
96	if (whiteList == null) {	99	if (whiteList == null) {
97	return;	100	return;
98	}	101	}
99	final List<WhiteListScanner.Problem> problems = new LinkedList<WhiteListScanner.Problem>();	102	final CompilationUnitTree cu = info.getCompilationUnit();
100	final WhiteListScanner scanner = new WhiteListScanner(	103	final Map<? extends Tree, ? extends WhiteListQuery.Result> problems = WhiteListSupport.getWhiteListViolations(
		104	cu,
		105	whiteList,
101	info.getTrees(),	106	info.getTrees(),
102	whiteList,	107	new Callable<Boolean>() {
103	canceled);	108	@Override
104	final CompilationUnitTree cu = info.getCompilationUnit();	109	public Boolean call() throws Exception {
105	try {	110	return canceled.get();
106	scanner.scan(cu, problems);	111	}
107	} catch (WhiteListScanner.Cancel cancel) {	112	});
		113	if (problems == null) {
		114	//Canceled
108	return;	115	return;
109	}	116	}
110	final SourcePositions sp = info.getTrees().getSourcePositions();	117	final SourcePositions sp = info.getTrees().getSourcePositions();
111	final List<ErrorDescription> errors = new ArrayList<ErrorDescription>(problems.size());	118	final List<ErrorDescription> errors = new ArrayList<ErrorDescription>(problems.size());
112	for (WhiteListScanner.Problem problem : problems) {	119	for (Map.Entry<? extends Tree, ? extends WhiteListQuery.Result> problem : problems.entrySet()) {
113	if (canceled.get()) {	120	if (canceled.get()) {
114	return;	121	return;
115	}	122	}
116	final int start = (int) sp.getStartPosition(cu, problem.tree);	123	final Tree tree = problem.getKey();
117	final int end = (int) sp.getEndPosition(cu, problem.tree);	124	final int start = (int) sp.getStartPosition(cu, tree);
		125	final int end = (int) sp.getEndPosition(cu, tree);
118	if (start >= 0 && end >= 0) {	126	if (start >= 0 && end >= 0) {
119	errors.add(ErrorDescriptionFactory.createErrorDescription(	127	errors.add(ErrorDescriptionFactory.createErrorDescription(
120	Severity.WARNING,	128	Severity.WARNING,
121	problem.description,	129	problem.getValue().getViolatedRuleDescription(),
122	file,	130	file,
123	start,	131	start,
124	end));	132	end));




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.java.editor.whitelist;

import com.sun.source.tree.ClassTree;
import com.sun.source.tree.IdentifierTree;
import com.sun.source.tree.MemberSelectTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.NewClassTree;
import com.sun.source.tree.Tree;
import com.sun.source.util.TreePathScanner;
import com.sun.source.util.Trees;
import java.util.ArrayDeque;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
import org.netbeans.api.java.source.ElementHandle;
import org.netbeans.api.whitelist.WhiteListQuery;
import org.netbeans.api.whitelist.WhiteListQuery.WhiteList;

/**
 *
 * @author Tomas Zezula
 */
class WhiteListScanner extends TreePathScanner<Void, List<? super WhiteListScanner.Problem>> {

    private final Trees trees;
    private final AtomicBoolean cancel;
    private final WhiteList whiteList;
    private final ArrayDeque<MethodInvocationTree> methodInvocation;

    WhiteListScanner(
        final Trees trees,
        final WhiteList whiteList,
        final AtomicBoolean cancel) {
        this.trees = trees;
        this.whiteList = whiteList;
        this.cancel = cancel;
        methodInvocation = new ArrayDeque<MethodInvocationTree>();
    }

    @Override
    public Void visitMethod(MethodTree node, List<? super Problem> p) {
        checkCancel();
        return super.visitMethod(node, p);
    }

    @Override
    public Void visitClass(ClassTree node, List<? super Problem> p) {
        checkCancel();
        return super.visitClass(node, p);
    }

    @Override
    public Void visitIdentifier(IdentifierTree node, List<? super Problem> p) {
        handleNode(node,p);
        return super.visitIdentifier(node, p);
    }

    @Override
    public Void visitMemberSelect(MemberSelectTree node, List<? super Problem> p) {
        handleNode(node,p);
        return super.visitMemberSelect(node, p);
    }

    @Override
    public Void visitNewClass(NewClassTree node, List<? super Problem> p) {
        final Element e = trees.getElement(getCurrentPath());
        final WhiteListQuery.Result res;
        if (e != null && !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
                p.add(new Problem(node,res.getViolatedRuleDescription()));
        }
        scan(node.getTypeArguments(), p);
        scan(node.getArguments(), p);
	scan(node.getClassBody(), p);
        return null;
    }

    @Override
    public Void visitMethodInvocation(MethodInvocationTree node, List<? super Problem> p) {
        methodInvocation.offerFirst(node);
        super.visitMethodInvocation(node, p);
        methodInvocation.removeFirst();
        return null;
    }

    private void handleNode(
            final Tree node,
            final List<? super Problem> p) {
        final Element e = trees.getElement(getCurrentPath());
        if (e == null) {
            return;
        }
        final ElementKind k = e.getKind();
        Tree toReport =  null;
        if (k.isClass() || k.isInterface()) {
            toReport=node;
        } else if ((k == ElementKind.METHOD || k == ElementKind.CONSTRUCTOR) &&
                !methodInvocation.isEmpty()) {
            toReport=methodInvocation.peekFirst();
        }
        final WhiteListQuery.Result res;
        if (toReport != null &&
            !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
                p.add(new Problem(toReport,res.getViolatedRuleDescription()));
        }
    }

    private void checkCancel() {
        if (cancel.get()) {
            throw new Cancel();
        }
    }

    static final class Problem {
        final Tree tree;
        final String description;

        private Problem (
                final Tree tree,
                final String description) {
            this.tree = tree;
            this.description = description;
        }
    }

    static final class Cancel extends RuntimeException {
    }

}




 */
package org.netbeans.modules.java.editor.whitelist;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;

import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.modules.parsing.lucene.support.DocumentIndex;
import org.netbeans.modules.parsing.lucene.support.Index;
import org.netbeans.modules.parsing.lucene.support.IndexDocument;
import org.netbeans.modules.parsing.lucene.support.IndexManager;
import org.netbeans.modules.parsing.lucene.support.Queries.QueryKind;
import org.netbeans.spi.tasklist.PushTaskScanner;
import org.netbeans.spi.tasklist.Task;
import org.netbeans.spi.tasklist.TaskScanningScope;
import org.netbeans.api.whitelist.index.WhiteListIndex;
import org.netbeans.api.whitelist.index.WhiteListIndexEvent;
import org.netbeans.api.whitelist.index.WhiteListIndexListener;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.URLMapper;
import org.openide.util.Exceptions;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.TaskListener;

        super(Bundle.LBL_ProviderName(),
              Bundle.LBL_ProviderDescription(),
              null);
        WhiteListIndex.getDefault().addWhiteListIndexListener(new WhiteListIndexListener() {
            @Override
            public void indexChanged(WhiteListIndexEvent event) {
                refresh(event.getRoot());
            }
        });
    }

    void refresh(final @NonNull URL root) {
        final FileObject rootFo = URLMapper.findFileObject(root);
        final Set<FileObject> files;
        final Callback callback;
        synchronized (this) {
            files = currentFiles;
            callback = currentCallback;
        }
        if (rootFo != null &&
            files != null &&
            files.contains(rootFo)) {
            assert callback != null;
            enqueue(new Work(rootFo, currentCallback));
        }
    }

    @Override

        }
    }

    private void refresh(final @NonNull URL root) {
        assert root != null;
        final FileObject rootFo = URLMapper.findFileObject(root);
        final Set<FileObject> files;
        final Callback callback;
        synchronized (this) {
            files = currentFiles;
            callback = currentCallback;
        }
        if (rootFo != null &&
            files != null &&
            files.contains(rootFo)) {
            assert callback != null;
            enqueue(new Work(rootFo, currentCallback));
        }
    }

    private static void enqueue(Work w) {
        synchronized (TASKS) {
            final RequestProcessor.Task task = WORKER.post(w);

    }

    @CheckForNull
    private static Map.Entry<FileObject,Task> createTask(@NonNull final WhiteListIndex.Problem problem) {
        final FileObject file = problem.getFile();
            @NonNull final IndexDocument doc) {
        final FileObject file = root.getFileObject(doc.getPrimaryKey());
        if (file == null) {
            return null;
        }
        final Task task = Task.create(
            file,
            "nb-whitelist-warning", //NOI18N
            problem.getResult().getViolatedRuleDescription(),
            problem.getLine());
        return new Map.Entry<FileObject, Task>() {
            @Override
            public FileObject getKey() {

        };
    }

    @CheckForNull
    private static DocumentIndex getIndex(@NonNull final FileObject root) {
        try {
            final File whiteListFolder = WhiteListIndexerPlugin.getWhiteListDir(root.getURL());
            if (whiteListFolder != null) {
                final DocumentIndex index = IndexManager.createDocumentIndex(whiteListFolder);
                return index.getStatus() == Index.Status.VALID ? index : null;
            }
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
        }
        return null;
    }

    private static void updateErrorsInRoot(
            @NonNull final Callback callback,
            @NonNull final FileObject root) {

        filesWithErrors.clear();
        Set<FileObject> nueFilesWithErrors = new HashSet<FileObject>();
        final Map<FileObject,List<Task>> filesToTasks = new HashMap<FileObject,List<Task>>();
        for (WhiteListIndex.Problem problem : WhiteListIndex.getDefault().getWhiteListViolations(root, null)) {
            final Map.Entry<FileObject,Task> task = createTask(problem);
            if (task != null) {
                List<Task> tasks = filesToTasks.get(task.getKey());
                if (tasks == null) {
                    tasks = new ArrayList<Task>();
                    filesToTasks.put(task.getKey(), tasks);
                            for (IndexDocument doc : index.findByPrimaryKey("", QueryKind.PREFIX)) {    //NOI18N
                                final Map.Entry<FileObject,Task> task = createTask(root, doc);
                                if (task != null) {
                                    List<Task> tasks = filesToTasks.get(task.getKey());
                                    if (tasks == null) {
                                        tasks = new ArrayList<Task>();
                                        filesToTasks.put(task.getKey(), tasks);
                                    }
                                    tasks.add(task.getValue());
                                }
                            }
                        } finally {
                            index.close();
                        }
                    }
                    return null;
                }
                tasks.add(task.getValue());
            }
            Exceptions.printStackTrace(e);
        } catch (InterruptedException e) {
            Exceptions.printStackTrace(e);
        }
        for (Map.Entry<FileObject,List<Task>> e : filesToTasks.entrySet()) {
            LOG.log(Level.FINE, "Setting {1} for {0}\n",

        @NonNull final Callback callback,
        @NonNull final FileObject root,
        @NonNull final FileObject file) {
        final List<Task> tasks = new ArrayList<Task>();
        for (WhiteListIndex.Problem problem : WhiteListIndex.getDefault().getWhiteListViolations(root, file)) {
            final Map.Entry<FileObject,Task> task = createTask(problem);
            if (task != null) {
                tasks.add(task.getValue());
            }
                    if (index != null) {
                        try {
                            for (IndexDocument doc : index.findByPrimaryKey(FileUtil.getRelativePath(root, file), QueryKind.PREFIX)) {
                                final Map.Entry<FileObject,Task> task = createTask(root, doc);
                                if (task != null) {
                                    tasks.add(task.getValue());
                                }
                            }
                        } finally {
                            index.close();
                        }
                    }
                    Set<FileObject> filesWithErrors = getFilesWithAttachedErrors(root);
                    if (tasks.isEmpty()) {
                        filesWithErrors.remove(file);
                    } else {
                        filesWithErrors.add(file);
                    }
                    LOG.log(Level.FINE, "setting {1} for {0}", new Object[]{file, tasks});
                    callback.setTasks(file, tasks);
                    return null;
                }
            });
        } catch (IOException e) {
            Exceptions.printStackTrace(e);
        } catch (InterruptedException e) {
            Exceptions.printStackTrace(e);
        }
        final Set<FileObject> filesWithErrors = getFilesWithAttachedErrors(root);
        if (tasks.isEmpty()) {
            filesWithErrors.remove(file);
        } else {
            filesWithErrors.add(file);
        }
        LOG.log(Level.FINE, "setting {1} for {0}", new Object[]{file, tasks});
        callback.setTasks(file, tasks);
    }

    private static final class Work implements Runnable {

Lines 70-75 Link Here

(-)a/java.preprocessorbridge/nbproject/project.xml (+1 lines)
70	<friend>org.netbeans.modules.scala.editing</friend>	70	<friend>org.netbeans.modules.scala.editing</friend>
71	<friend>org.netbeans.modules.scala.editor</friend>	71	<friend>org.netbeans.modules.scala.editor</friend>
72	<friend>org.netbeans.modules.web.core.syntax</friend>	72	<friend>org.netbeans.modules.web.core.syntax</friend>
		73	<friend>org.netbeans.modules.whitelist</friend>
73	<package>org.netbeans.modules.java.preprocessorbridge.api</package>	74	<package>org.netbeans.modules.java.preprocessorbridge.api</package>
74	<package>org.netbeans.modules.java.preprocessorbridge.spi</package>	75	<package>org.netbeans.modules.java.preprocessorbridge.spi</package>
75	</friend-packages>	76	</friend-packages>

Lines 56-65 Link Here

(-)a/parsing.lucene/nbproject/project.xml (-1 / +1 lines)
56	</test-type>	56	</test-type>
57	</test-dependencies>	57	</test-dependencies>
58	<friend-packages>	58	<friend-packages>
59	<friend>org.netbeans.modules.java.editor</friend>
60	<friend>org.netbeans.modules.java.source</friend>	59	<friend>org.netbeans.modules.java.source</friend>
61	<friend>org.netbeans.modules.java.sourceui</friend>	60	<friend>org.netbeans.modules.java.sourceui</friend>
62	<friend>org.netbeans.modules.parsing.api</friend>	61	<friend>org.netbeans.modules.parsing.api</friend>
		62	<friend>org.netbeans.modules.whitelist</friend>
63	<package>org.netbeans.modules.parsing.lucene.support</package>	63	<package>org.netbeans.modules.parsing.lucene.support</package>
64	</friend-packages>	64	</friend-packages>
65	</data>	65	</data>




<!-- ACTUAL CHANGES BEGIN HERE: -->

<changes>
        <change id="WhiteListIndex">
            <api name="whitelist"/>
            <summary>Added WhiteListQuery to check violations of runtime restrictions</summary>
            <version major="1" minor="2"/>
            <date day="15" month="9" year="2011"/>
            <author login="tzezula"/>
            <compatibility addition="yes" modification="no" semantic="compatible" source="compatible" binary="compatible"/>
            <description>
                <p>
                    Added WhiteListIndex to provide persistent index of the white list violations.
                </p>
            </description>
            <class package="org.netbeans.api.whitelist.index" name="WhiteListIndex"/>
            <class package="org.netbeans.api.whitelist.index" name="WhiteListIndexListener"/>
            <class package="org.netbeans.api.whitelist.index" name="WhiteListIndexEvent"/>
            <class package="org.netbeans.api.whitelist.support" name="WhiteListSupport"/>
            <issue number="202063"/>
        </change>
        <change id="WhiteListQuery">
            <api name="whitelist"/>
            <summary>Added WhiteListQuery to check violations of runtime restrictions</summary>

Lines 2-6 Link Here

(-)a/whitelist/manifest.mf (-1 / +1 lines)
2	OpenIDE-Module: org.netbeans.modules.whitelist	2	OpenIDE-Module: org.netbeans.modules.whitelist
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/whitelist/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/whitelist/Bundle.properties
4	OpenIDE-Module-Layer: org/netbeans/modules/whitelist/resources/layer.xml	4	OpenIDE-Module-Layer: org/netbeans/modules/whitelist/resources/layer.xml
5	OpenIDE-Module-Specification-Version: 1.1	5	OpenIDE-Module-Specification-Version: 1.2
6		6

Lines 15-20 Link Here

(-)a/whitelist/nbproject/project.xml (+46 lines)
15	</run-dependency>	15	</run-dependency>
16	</dependency>	16	</dependency>
17	<dependency>	17	<dependency>
		18	<code-name-base>org.netbeans.api.java.classpath</code-name-base>
		19	<build-prerequisite/>
		20	<compile-dependency/>
		21	<run-dependency>
		22	<release-version>1</release-version>
		23	<specification-version>1.30</specification-version>
		24	</run-dependency>
		25	</dependency>
		26	<dependency>
18	<code-name-base>org.netbeans.libs.javacapi</code-name-base>	27	<code-name-base>org.netbeans.libs.javacapi</code-name-base>
19	<build-prerequisite/>	28	<build-prerequisite/>
20	<compile-dependency/>	29	<compile-dependency/>
Lines 23-28 Link Here
23	</run-dependency>	32	</run-dependency>
24	</dependency>	33	</dependency>
25	<dependency>	34	<dependency>
		35	<code-name-base>org.netbeans.modules.editor.mimelookup</code-name-base>
		36	<build-prerequisite/>
		37	<compile-dependency/>
		38	<run-dependency>
		39	<release-version>1</release-version>
		40	<specification-version>1.23</specification-version>
		41	</run-dependency>
		42	</dependency>
		43	<dependency>
		44	<code-name-base>org.netbeans.modules.java.preprocessorbridge</code-name-base>
		45	<build-prerequisite/>
		46	<compile-dependency/>
		47	<run-dependency>
		48	<specification-version>1.22</specification-version>
		49	</run-dependency>
		50	</dependency>
		51	<dependency>
26	<code-name-base>org.netbeans.modules.java.source</code-name-base>	52	<code-name-base>org.netbeans.modules.java.source</code-name-base>
27	<build-prerequisite/>	53	<build-prerequisite/>
28	<compile-dependency/>	54	<compile-dependency/>
Lines 31-36 Link Here
31	</run-dependency>	57	</run-dependency>
32	</dependency>	58	</dependency>
33	<dependency>	59	<dependency>
		60	<code-name-base>org.netbeans.modules.parsing.api</code-name-base>
		61	<build-prerequisite/>
		62	<compile-dependency/>
		63	<run-dependency>
		64	<release-version>1</release-version>
		65	<specification-version>1.43</specification-version>
		66	</run-dependency>
		67	</dependency>
		68	<dependency>
		69	<code-name-base>org.netbeans.modules.parsing.lucene</code-name-base>
		70	<build-prerequisite/>
		71	<compile-dependency/>
		72	<run-dependency>
		73	<release-version>2</release-version>
		74	<specification-version>2.3</specification-version>
		75	</run-dependency>
		76	</dependency>
		77	<dependency>
34	<code-name-base>org.netbeans.modules.projectapi</code-name-base>	78	<code-name-base>org.netbeans.modules.projectapi</code-name-base>
35	<build-prerequisite/>	79	<build-prerequisite/>
36	<compile-dependency/>	80	<compile-dependency/>
Lines 78-83 Link Here
78	<friend>org.netbeans.modules.java.editor</friend>	122	<friend>org.netbeans.modules.java.editor</friend>
79	<friend>org.netbeans.modules.web.project</friend>	123	<friend>org.netbeans.modules.web.project</friend>
80	<package>org.netbeans.api.whitelist</package>	124	<package>org.netbeans.api.whitelist</package>
		125	<package>org.netbeans.api.whitelist.index</package>
		126	<package>org.netbeans.api.whitelist.support</package>
81	<package>org.netbeans.spi.whitelist</package>	127	<package>org.netbeans.spi.whitelist</package>
82	<package>org.netbeans.spi.whitelist.support</package>	128	<package>org.netbeans.spi.whitelist.support</package>
83	</friend-packages>	129	</friend-packages>




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.api.whitelist.index;

import java.net.URL;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
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.whitelist.WhiteListQuery;
import org.netbeans.api.whitelist.WhiteListQuery.Result;
import org.netbeans.modules.whitelist.index.WhiteListIndexAccessor;
import org.netbeans.modules.whitelist.index.WhiteListIndexerPlugin;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.Parameters;

/**
 * A persistent index of white list violations.
 * @author Tomas Zezula
 * @since 1.2
 */
public final class WhiteListIndex {

    static {
        WhiteListIndexAccessor.setInstance(new WhiteListIndexAccessorImpl());
    }

    private static WhiteListIndex instance;
    private final List<WhiteListIndexListener> listeners = new CopyOnWriteArrayList<WhiteListIndexListener>();

    private WhiteListIndex() {}

    /**
     * Returns the white list violations for given root or file.
     * @param root the root to get white list violations for
     * @param file the file to restrict the white list violation search or null
     * @return a {@link Collection} of {@link Problem}s
     * @throws IllegalArgumentException in case when file is not under the root or it's not a valid file
     * @throws UnsupportedOperationException when the index is not supported by the IDE
     */
    @NonNull
    public Collection<? extends Problem> getWhiteListViolations(
            @NonNull final FileObject root,
            @NullAllowed final FileObject file) throws IllegalArgumentException, UnsupportedOperationException {
        Parameters.notNull("scope", root); //NOI18N
        if (file != null && !(root.equals(file) || FileUtil.isParentOf(root, file))) {
            throw new IllegalArgumentException(
                    "The file: " + //NOI18N
                    FileUtil.getFileDisplayName(file) +
                    " has to be inside the root: " + //NOI18N
                    FileUtil.getFileDisplayName(root));
        }
        if (file != null && !file.isData()) {
            throw new IllegalArgumentException(
                    "The file: " + //NOI18N
                    FileUtil.getFileDisplayName(file) +
                    " has to be file.");    //NOI18N
        }
        return WhiteListIndexerPlugin.getWhiteListViolations(root,file);
    }

    /**
     * Adds {@link WhiteListIndexListener}.
     * The listener is notified when the white list index is changed.
     * @param listener the listener to be added
     */
    public void addWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {
        Parameters.notNull("listener", listener);   //NOI18N
        listeners.add(listener);
    }

    /**
     * Removes {@link WhiteListIndexListener}.
     * @param listener the listener to be removed
     */
    public void removeWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {
        Parameters.notNull("listener", listener);   //NOI18N
        listeners.remove(listener);
    }

    /**
     * Returns an instance of {@link WhiteListIndex}
     * @return the instance of {@link WhiteListIndex}
     */
    public static synchronized WhiteListIndex getDefault() {
        if (instance == null) {
            instance = new WhiteListIndex();
        }
        return instance;
    }


    /**
     * Represent a white list violation
     */
    public static final class Problem {

        private final WhiteListQuery.Result result;
        private final FileObject root;
        private final String relPath;
        private final int line;

        private Problem (
                @NonNull final WhiteListQuery.Result result,
                @NonNull final FileObject root,
                @NonNull final String relPath,
                final int line) {
            Parameters.notNull("result", result);   //NOI18N
            Parameters.notNull("root", root);   //NOI18N
            Parameters.notNull("relPath", relPath); //NOI18N
            this.result = result;
            this.root = root;
            this.relPath = relPath;
            this.line = line;
        }

        /**
         * Returns {@link WhiteListQuery.Result} describing the
         * white list violation.
         * @return the {@link WhiteListQuery.Result}
         */
        @NonNull
        public WhiteListQuery.Result getResult() {
            return result;
        }

        /**
         * Returns the file in which the white list violation occured.
         * @return the {@link FileObject}
         */
        @CheckForNull
        public FileObject getFile() {
            return root.getFileObject(relPath);
        }

        /**
         * Returns the line number of white list violation.
         * @return the line number
         */
        public int getLine() {
            return line;
        }
    }

    //<editor-fold defaultstate="collapsed" desc="Private implementation">
    private void fireIndexChange(final URL root) {
        final WhiteListIndexEvent event = new WhiteListIndexEvent(this, root);
        for (WhiteListIndexListener l : listeners) {
            l.indexChanged(event);
        }
    }


    private static final class WhiteListIndexAccessorImpl extends WhiteListIndexAccessor {
        @Override
        public void refresh(@NonNull URL root) {
            WhiteListIndex.getDefault().fireIndexChange(root);
        }

        @Override
        @NonNull
        public Problem createProblem(
                @NonNull final Result result,
                @NonNull final FileObject root,
                @NonNull final String key,
                int line) {
            return new Problem(result, root, key, line);
        }
    }
    //</editor-fold>
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.api.whitelist.index;

import java.net.URL;
import java.util.EventObject;
import org.netbeans.api.annotations.common.NonNull;
import org.openide.util.Parameters;

/**
 * WhiteListIndexEvent is used to notify interested parties about
 * changes in persistent index of white list violations.
 * @author Tomas Zezula
 * @since 1.2
 */
public class WhiteListIndexEvent extends EventObject {

    private final URL root;

    WhiteListIndexEvent(@NonNull final Object source, @NonNull final URL root) {
        super(source);
        Parameters.notNull("root", root);   //NOI18N
        this.root = root;
    }

    /**
     * Returns a source root for which the index was changed.
     * @return the {@link URL} of the source root.
     */
    @NonNull
    public URL getRoot() {
        return root;
    }
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.api.whitelist.index;

import java.util.EventListener;
import org.netbeans.api.annotations.common.NonNull;

/**
 * The listener interface for receiving {@link WhiteListIndex} events.
 * @author Tomas Zezula
 * @since 1.2
 */
public interface WhiteListIndexListener extends EventListener {
    /**
     * Invoked when the index for a source root changed
     * @param event the event providing the change details
     */
    void indexChanged (@NonNull WhiteListIndexEvent event);
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.api.whitelist.support;

import com.sun.source.tree.ClassTree;
import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.IdentifierTree;
import com.sun.source.tree.MemberSelectTree;
import com.sun.source.tree.MethodInvocationTree;
import com.sun.source.tree.MethodTree;
import com.sun.source.tree.NewClassTree;
import com.sun.source.tree.Tree;
import com.sun.source.util.TreePathScanner;
import com.sun.source.util.Trees;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;
import javax.lang.model.element.Element;
import javax.lang.model.element.ElementKind;
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.source.ElementHandle;
import org.netbeans.api.whitelist.WhiteListQuery;
import org.netbeans.api.whitelist.WhiteListQuery.Result;
import org.netbeans.api.whitelist.WhiteListQuery.WhiteList;
import org.openide.util.Exceptions;
import org.openide.util.Parameters;

/**
 * White list supporting methods.
 * @author Tomas Zezula
 * @since 1.2
 */
public final class WhiteListSupport {

    private WhiteListSupport() {}

    /**
     * Utility method to check the given {@link CompilationUnitTree} for white list violations.
     * @param unit the {@link CompilationUnitTree} to be analyzed
     * @param whitelist the {@link WhiteList} to use to check the violations
     * @param trees the {@link Trees} service
     * @param cancel the cancel request. If the {@link Callable} returns true the check is canceled
     * and null is returned.
     * @return a {@link Map} of {@link Tree}s with attached white list violations or null when the
     * scan was canceled.
     */
    @CheckForNull
    public static Map<? extends Tree, ? extends WhiteListQuery.Result> getWhiteListViolations(
            @NonNull final CompilationUnitTree unit,
            @NonNull final WhiteListQuery.WhiteList whitelist,
            @NonNull final Trees trees,
            @NullAllowed final Callable<Boolean> cancel) {
        Parameters.notNull("tree", unit);           //NOI18N
        Parameters.notNull("whitelist", whitelist); //NOI18N
        Parameters.notNull("trees", trees);         //NOI18N
        final Map<Tree,WhiteListQuery.Result> result = new HashMap<Tree, Result>();
        final WhiteListScanner scanner = new WhiteListScanner(trees, whitelist, cancel);
        try {
            scanner.scan(unit, result);
            return result;
        } catch (WhiteListScanner.Cancel ce) {
            return null;
        }
    }

    //<editor-fold defaultstate="collapsed" desc="Private implementation">
    private static class WhiteListScanner extends TreePathScanner<Void, Map<Tree,WhiteListQuery.Result>> {

        private final Trees trees;
        private final Callable<Boolean> cancel;
        private final WhiteList whiteList;
        private final ArrayDeque<MethodInvocationTree> methodInvocation;

        WhiteListScanner(
            final Trees trees,
            final WhiteList whiteList,
            final Callable<Boolean> cancel) {
            this.trees = trees;
            this.whiteList = whiteList;
            this.cancel = cancel;
            methodInvocation = new ArrayDeque<MethodInvocationTree>();
        }

        @Override
        public Void visitMethod(MethodTree node, Map<Tree,WhiteListQuery.Result> p) {
            checkCancel();
            return super.visitMethod(node, p);
        }

        @Override
        public Void visitClass(ClassTree node, Map<Tree,WhiteListQuery.Result> p) {
            checkCancel();
            return super.visitClass(node, p);
        }

        @Override
        public Void visitIdentifier(IdentifierTree node, Map<Tree,WhiteListQuery.Result> p) {
            handleNode(node,p);
            return super.visitIdentifier(node, p);
        }

        @Override
        public Void visitMemberSelect(MemberSelectTree node, Map<Tree,WhiteListQuery.Result> p) {
            handleNode(node,p);
            return super.visitMemberSelect(node, p);
        }

        @Override
        public Void visitNewClass(NewClassTree node, Map<Tree,WhiteListQuery.Result> p) {
            final Element e = trees.getElement(getCurrentPath());
            final WhiteListQuery.Result res;
            if (e != null && !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
                p.put(node,res);
            }
            scan(node.getTypeArguments(), p);
            scan(node.getArguments(), p);
            scan(node.getClassBody(), p);
            return null;
        }

        @Override
        public Void visitMethodInvocation(MethodInvocationTree node, Map<Tree,WhiteListQuery.Result> p) {
            methodInvocation.offerFirst(node);
            super.visitMethodInvocation(node, p);
            methodInvocation.removeFirst();
            return null;
        }

        private void handleNode(
                final Tree node,
                final Map<Tree,WhiteListQuery.Result> p) {
            final Element e = trees.getElement(getCurrentPath());
            if (e == null) {
                return;
            }
            final ElementKind k = e.getKind();
            Tree toReport =  null;
            if (k.isClass() || k.isInterface()) {
                toReport=node;
            } else if ((k == ElementKind.METHOD || k == ElementKind.CONSTRUCTOR) &&
                    !methodInvocation.isEmpty()) {
                toReport=methodInvocation.peekFirst();
            }
            final WhiteListQuery.Result res;
            if (toReport != null &&
                !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
                    p.put(toReport,res);
            }
        }

        private void checkCancel() {
            try {
                if (cancel != null && cancel.call() == Boolean.TRUE) {
                    throw new Cancel();
                }
            } catch (Exception ex) {
                Exceptions.printStackTrace(ex);
            }
        }

        static final class Cancel extends RuntimeException {
        }
    }
    //</editor-fold>

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2011 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 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.whitelist.index;

import java.net.URL;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.whitelist.WhiteListQuery;
import org.netbeans.api.whitelist.index.WhiteListIndex;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;
import org.openide.util.Parameters;

/**
 *
 * @author Tomas Zezula
 */
public abstract class WhiteListIndexAccessor {

    private static volatile WhiteListIndexAccessor instance;

    @NonNull
    public static synchronized WhiteListIndexAccessor getInstance() {
        if (instance == null) {
            try {
                Class.forName(WhiteListIndex.class.getName(), true, WhiteListIndexAccessor.class.getClassLoader());
                assert instance != null;
            } catch (ClassNotFoundException ex) {
                Exceptions.printStackTrace(ex);
            }
        }
        return instance;

    }

    public static void setInstance(@NonNull final WhiteListIndexAccessor _instance) {
        Parameters.notNull("_instance", _instance); //NOI18N
        instance = _instance;
    }

    public abstract void refresh(@NonNull URL root);
    public abstract WhiteListIndex.Problem createProblem(
            @NonNull WhiteListQuery.Result result,
            @NonNull FileObject root,
            @NonNull String key,
            int line);
}




 *
 * Portions Copyrighted 2011 Sun Microsystems, Inc.
 */
package org.netbeans.modules.whitelist.index;

import com.sun.source.tree.CompilationUnitTree;
import com.sun.source.tree.LineMap;
import com.sun.source.tree.Tree;
import com.sun.source.util.SourcePositions;
import com.sun.source.util.Trees;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
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.editor.mimelookup.MimeRegistration;
import org.netbeans.api.whitelist.WhiteListQuery;
import org.netbeans.modules.java.preprocessorbridge.spi.JavaIndexerPlugin;
import org.netbeans.modules.parsing.lucene.support.DocumentIndex;
import org.netbeans.modules.parsing.lucene.support.Index;
import org.netbeans.modules.parsing.lucene.support.IndexDocument;
import org.netbeans.modules.parsing.lucene.support.IndexManager;
import org.netbeans.modules.parsing.lucene.support.Queries.QueryKind;
import org.netbeans.modules.parsing.spi.indexing.Indexable;
import org.netbeans.api.whitelist.index.WhiteListIndex;
import org.netbeans.api.whitelist.support.WhiteListSupport;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.filesystems.URLMapper;

public class WhiteListIndexerPlugin implements JavaIndexerPlugin {

    private static final String WHITE_LIST_INDEX = "whitelist"; //NOI18N
    private static final String MSG = "msg";    //NOI18N
    private static final String NAME = "name";  //NOI18N
    private static final String LINE = "line";  //NOI18N
    private static Map<URL,File> roots2whiteListDirs = new ConcurrentHashMap<URL, File>();

    private final URL root;

            @NonNull final Lookup services) {
        final Trees trees = services.lookup(Trees.class);
        assert trees != null;
        final Map<? extends Tree, ? extends WhiteListQuery.Result> problems = WhiteListSupport.getWhiteListViolations(toProcess, whiteList, trees, null);
        assert problems != null;
                whiteList,
                new AtomicBoolean());
        final List<WhiteListScanner.Problem> problems = new LinkedList<WhiteListScanner.Problem>();
        scanner.scan(toProcess,problems);
        final LineMap lm = toProcess.getLineMap();
        final SourcePositions sp = trees.getSourcePositions();
        for (Map.Entry<? extends Tree, ? extends WhiteListQuery.Result> p : problems.entrySet()) {
            final int start = (int) sp.getStartPosition(toProcess, p.getKey());
            int ln;
            if (start>=0 && (ln=(int)lm.getLineNumber(start))>=0) {
                final IndexDocument doc = IndexManager.createDocument(indexable.getRelativePath());
                doc.addPair(MSG, p.getValue().getViolatedRuleDescription(), false, true);
                doc.addPair(LINE, Integer.toString(ln), false, true);
                index.addDocument(doc);
            }

        try {
            index.store(true);
            roots2whiteListDirs.put(root, whiteListDir);
            WhiteListIndexAccessor.getInstance().refresh(root);
            if (tp != null) {
                tp.refresh(root);
            }
        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        } finally {

    }

    @CheckForNull
    private static DocumentIndex getIndex(@NonNull final FileObject root) {
        try {
            final File whiteListFolder = roots2whiteListDirs.get(root.getURL());
            if (whiteListFolder != null) {
                final DocumentIndex index = IndexManager.createDocumentIndex(whiteListFolder);
                return index.getStatus() == Index.Status.VALID ? index : null;
            }
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
        }
        return null;
    }

    @NonNull
    public static Collection<? extends WhiteListIndex.Problem> getWhiteListViolations(
            @NonNull final FileObject root,
            @NullAllowed final FileObject resource) {
        final List<WhiteListIndex.Problem> result = new ArrayList<WhiteListIndex.Problem>();
        try {
            IndexManager.readAccess(new IndexManager.Action<Void>() {
                @Override
                public Void run() throws IOException, InterruptedException {
                    final DocumentIndex index = getIndex(root);
                    if (index != null) {
                        try {
                            for (IndexDocument doc : index.findByPrimaryKey(
                                    resource == null ? "" : FileUtil.getRelativePath(root,resource),    //NOI18N
                                    QueryKind.PREFIX)) {
                                try {
                                    final String key = doc.getPrimaryKey();
                                    String wlName = doc.getValue(NAME);
                                    if (wlName == null) {
                                        wlName = "";    //NOI18N
                                    }
                                    final String wlDesc = doc.getValue(MSG);
                                    final int line = Integer.parseInt(doc.getValue(LINE));
                                    final WhiteListQuery.Result wr = new WhiteListQuery.Result(false, wlName, wlDesc);
                                    result.add(WhiteListIndexAccessor.getInstance().createProblem(wr, root, key, line));
                                } catch (ArithmeticException ae) {
                                    Exceptions.printStackTrace(ae);
                                }
                            }
                        } finally {
                            index.close();
                        }
                    }
                    return null;
                }
            });
        } catch (IOException e) {
            Exceptions.printStackTrace(e);
        } catch (InterruptedException e) {
            Exceptions.printStackTrace(e);
        }
        return result;
    }

    @MimeRegistration(mimeType="text/x-java",service=JavaIndexerPlugin.Factory.class)

        @Override
        public JavaIndexerPlugin create(final URL root, final FileObject cacheFolder) {
            try {
                File whiteListDir = roots2whiteListDirs.get(root);
                if (whiteListDir == null) {
                    //First time
                    final FileObject whiteListFolder = FileUtil.createFolder(cacheFolder, WHITE_LIST_INDEX);

Return to bug 202063

Lines 285-299 Link Here

(-)a/java.editor/nbproject/project.xml (-10 / +1 lines)
285	</run-dependency>	285	</run-dependency>
286	</dependency>	286	</dependency>
287	<dependency>	287	<dependency>
288	<code-name-base>org.netbeans.modules.parsing.lucene</code-name-base>
289	<build-prerequisite/>
290	<compile-dependency/>
291	<run-dependency>
292	<release-version>2</release-version>
293	<specification-version>2.3</specification-version>
294	</run-dependency>
295	</dependency>
296	<dependency>
297	<code-name-base>org.netbeans.modules.projectapi</code-name-base>	288	<code-name-base>org.netbeans.modules.projectapi</code-name-base>
298	<build-prerequisite/>	289	<build-prerequisite/>
299	<compile-dependency/>	290	<compile-dependency/>
Lines 315-321 Link Here
315	<build-prerequisite/>	306	<build-prerequisite/>
316	<compile-dependency/>	307	<compile-dependency/>
317	<run-dependency>	308	<run-dependency>
318	<specification-version>1.0</specification-version>	309	<specification-version>1.2</specification-version>
319	</run-dependency>	310	</run-dependency>
320	</dependency>	311	</dependency>
321	<dependency>	312	<dependency>

Lines 1-171 Link Here

(-)a/java.editor/src/org/netbeans/modules/java/editor/whitelist/WhiteListScanner.java (-171 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* If you wish your version of this file to be governed by only the CDDL
28	* or only the GPL Version 2, indicate your decision by adding
29	* "[Contributor] elects to include this software in this distribution
30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
31	* single choice of license, a recipient has the option to distribute
32	* your version of this file under either the CDDL, the GPL Version 2 or
33	* to extend the choice of license to its licensees as provided above.
34	* However, if you add GPL Version 2 code and therefore, elected the GPL
35	* Version 2 license, then the option applies only if the new code is
36	* made subject to such option by the copyright holder.
37	*
38	* Contributor(s):
39	*
40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
41	*/
42	package org.netbeans.modules.java.editor.whitelist;
43
44	import com.sun.source.tree.ClassTree;
45	import com.sun.source.tree.IdentifierTree;
46	import com.sun.source.tree.MemberSelectTree;
47	import com.sun.source.tree.MethodInvocationTree;
48	import com.sun.source.tree.MethodTree;
49	import com.sun.source.tree.NewClassTree;
50	import com.sun.source.tree.Tree;
51	import com.sun.source.util.TreePathScanner;
52	import com.sun.source.util.Trees;
53	import java.util.ArrayDeque;
54	import java.util.List;
55	import java.util.concurrent.atomic.AtomicBoolean;
56	import javax.lang.model.element.Element;
57	import javax.lang.model.element.ElementKind;
58	import org.netbeans.api.java.source.ElementHandle;
59	import org.netbeans.api.whitelist.WhiteListQuery;
60	import org.netbeans.api.whitelist.WhiteListQuery.WhiteList;
61
62	/**
63	*
64	* @author Tomas Zezula
65	*/
66	class WhiteListScanner extends TreePathScanner<Void, List<? super WhiteListScanner.Problem>> {
67
68	private final Trees trees;
69	private final AtomicBoolean cancel;
70	private final WhiteList whiteList;
71	private final ArrayDeque<MethodInvocationTree> methodInvocation;
72
73	WhiteListScanner(
74	final Trees trees,
75	final WhiteList whiteList,
76	final AtomicBoolean cancel) {
77	this.trees = trees;
78	this.whiteList = whiteList;
79	this.cancel = cancel;
80	methodInvocation = new ArrayDeque<MethodInvocationTree>();
81	}
82
83	@Override
84	public Void visitMethod(MethodTree node, List<? super Problem> p) {
85	checkCancel();
86	return super.visitMethod(node, p);
87	}
88
89	@Override
90	public Void visitClass(ClassTree node, List<? super Problem> p) {
91	checkCancel();
92	return super.visitClass(node, p);
93	}
94
95	@Override
96	public Void visitIdentifier(IdentifierTree node, List<? super Problem> p) {
97	handleNode(node,p);
98	return super.visitIdentifier(node, p);
99	}
100
101	@Override
102	public Void visitMemberSelect(MemberSelectTree node, List<? super Problem> p) {
103	handleNode(node,p);
104	return super.visitMemberSelect(node, p);
105	}
106
107	@Override
108	public Void visitNewClass(NewClassTree node, List<? super Problem> p) {
109	final Element e = trees.getElement(getCurrentPath());
110	final WhiteListQuery.Result res;
111	if (e != null && !(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
112	p.add(new Problem(node,res.getViolatedRuleDescription()));
113	}
114	scan(node.getTypeArguments(), p);
115	scan(node.getArguments(), p);
116	scan(node.getClassBody(), p);
117	return null;
118	}
119
120	@Override
121	public Void visitMethodInvocation(MethodInvocationTree node, List<? super Problem> p) {
122	methodInvocation.offerFirst(node);
123	super.visitMethodInvocation(node, p);
124	methodInvocation.removeFirst();
125	return null;
126	}
127
128	private void handleNode(
129	final Tree node,
130	final List<? super Problem> p) {
131	final Element e = trees.getElement(getCurrentPath());
132	if (e == null) {
133	return;
134	}
135	final ElementKind k = e.getKind();
136	Tree toReport = null;
137	if (k.isClass() \|\| k.isInterface()) {
138	toReport=node;
139	} else if ((k == ElementKind.METHOD \|\| k == ElementKind.CONSTRUCTOR) &&
140	!methodInvocation.isEmpty()) {
141	toReport=methodInvocation.peekFirst();
142	}
143	final WhiteListQuery.Result res;
144	if (toReport != null &&
145	!(res=whiteList.check(ElementHandle.create(e),WhiteListQuery.Operation.USAGE)).isAllowed()) {
146	p.add(new Problem(toReport,res.getViolatedRuleDescription()));
147	}
148	}
149
150	private void checkCancel() {
151	if (cancel.get()) {
152	throw new Cancel();
153	}
154	}
155
156	static final class Problem {
157	final Tree tree;
158	final String description;
159
160	private Problem (
161	final Tree tree,
162	final String description) {
163	this.tree = tree;
164	this.description = description;
165	}
166	}
167
168	static final class Cancel extends RuntimeException {
169	}
170
171	}

Lines 75-80 Link Here

(-)a/whitelist/apichanges.xml (+18 lines)
75	<!-- ACTUAL CHANGES BEGIN HERE: -->	75	<!-- ACTUAL CHANGES BEGIN HERE: -->
76		76
77	<changes>	77	<changes>
		78	<change id="WhiteListIndex">
		79	<api name="whitelist"/>
		80	<summary>Added WhiteListQuery to check violations of runtime restrictions</summary>
		81	<version major="1" minor="2"/>
		82	<date day="15" month="9" year="2011"/>
		83	<author login="tzezula"/>
		84	<compatibility addition="yes" modification="no" semantic="compatible" source="compatible" binary="compatible"/>
		85	<description>
		86	<p>
		87	Added WhiteListIndex to provide persistent index of the white list violations.
		88	</p>
		89	</description>
		90	<class package="org.netbeans.api.whitelist.index" name="WhiteListIndex"/>
		91	<class package="org.netbeans.api.whitelist.index" name="WhiteListIndexListener"/>
		92	<class package="org.netbeans.api.whitelist.index" name="WhiteListIndexEvent"/>
		93	<class package="org.netbeans.api.whitelist.support" name="WhiteListSupport"/>
		94	<issue number="202063"/>
		95	</change>
78	<change id="WhiteListQuery">	96	<change id="WhiteListQuery">
79	<api name="whitelist"/>	97	<api name="whitelist"/>
80	<summary>Added WhiteListQuery to check violations of runtime restrictions</summary>	98	<summary>Added WhiteListQuery to check violations of runtime restrictions</summary>

Line 0 Link Here

(-)a/whitelist/src/org/netbeans/api/whitelist/index/WhiteListIndex.java (+213 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.api.whitelist.index;
		43
		44	import java.net.URL;
		45	import java.util.Collection;
		46	import java.util.List;
		47	import java.util.concurrent.CopyOnWriteArrayList;
		48	import org.netbeans.api.annotations.common.CheckForNull;
		49	import org.netbeans.api.annotations.common.NonNull;
		50	import org.netbeans.api.annotations.common.NullAllowed;
		51	import org.netbeans.api.whitelist.WhiteListQuery;
		52	import org.netbeans.api.whitelist.WhiteListQuery.Result;
		53	import org.netbeans.modules.whitelist.index.WhiteListIndexAccessor;
		54	import org.netbeans.modules.whitelist.index.WhiteListIndexerPlugin;
		55	import org.openide.filesystems.FileObject;
		56	import org.openide.filesystems.FileUtil;
		57	import org.openide.util.Parameters;
		58
		59	/**
		60	* A persistent index of white list violations.
		61	* @author Tomas Zezula
		62	* @since 1.2
		63	*/
		64	public final class WhiteListIndex {
65
66	static {
67	WhiteListIndexAccessor.setInstance(new WhiteListIndexAccessorImpl());
68	}
69
70	private static WhiteListIndex instance;
71	private final List<WhiteListIndexListener> listeners = new CopyOnWriteArrayList<WhiteListIndexListener>();
72
73	private WhiteListIndex() {}
74
75	/**
76	* Returns the white list violations for given root or file.
77	* @param root the root to get white list violations for
78	* @param file the file to restrict the white list violation search or null
79	* @return a {@link Collection} of {@link Problem}s
80	* @throws IllegalArgumentException in case when file is not under the root or it's not a valid file
81	* @throws UnsupportedOperationException when the index is not supported by the IDE
82	*/
83	@NonNull
84	public Collection<? extends Problem> getWhiteListViolations(
85	@NonNull final FileObject root,
86	@NullAllowed final FileObject file) throws IllegalArgumentException, UnsupportedOperationException {
87	Parameters.notNull("scope", root); //NOI18N
88	if (file != null && !(root.equals(file) \|\| FileUtil.isParentOf(root, file))) {
89	throw new IllegalArgumentException(
90	"The file: " + //NOI18N
91	FileUtil.getFileDisplayName(file) +
92	" has to be inside the root: " + //NOI18N
93	FileUtil.getFileDisplayName(root));
94	}
95	if (file != null && !file.isData()) {
96	throw new IllegalArgumentException(
97	"The file: " + //NOI18N
98	FileUtil.getFileDisplayName(file) +
99	" has to be file."); //NOI18N
100	}
101	return WhiteListIndexerPlugin.getWhiteListViolations(root,file);
102	}
103
104	/**
105	* Adds {@link WhiteListIndexListener}.
106	* The listener is notified when the white list index is changed.
107	* @param listener the listener to be added
108	*/
109	public void addWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {
110	Parameters.notNull("listener", listener); //NOI18N
111	listeners.add(listener);
112	}
113
114	/**
115	* Removes {@link WhiteListIndexListener}.
116	* @param listener the listener to be removed
117	*/
118	public void removeWhiteListIndexListener(@NonNull final WhiteListIndexListener listener) {
119	Parameters.notNull("listener", listener); //NOI18N
120	listeners.remove(listener);
121	}
122
123	/**
124	* Returns an instance of {@link WhiteListIndex}
125	* @return the instance of {@link WhiteListIndex}
126	*/
127	public static synchronized WhiteListIndex getDefault() {
128	if (instance == null) {
129	instance = new WhiteListIndex();
130	}
131	return instance;
132	}
133
134
135	/**
136	* Represent a white list violation
137	*/
138	public static final class Problem {
139
140	private final WhiteListQuery.Result result;
141	private final FileObject root;
142	private final String relPath;
143	private final int line;
144
145	private Problem (
146	@NonNull final WhiteListQuery.Result result,
147	@NonNull final FileObject root,
148	@NonNull final String relPath,
149	final int line) {
150	Parameters.notNull("result", result); //NOI18N
151	Parameters.notNull("root", root); //NOI18N
152	Parameters.notNull("relPath", relPath); //NOI18N
153	this.result = result;
154	this.root = root;
155	this.relPath = relPath;
156	this.line = line;
157	}
158
159	/**
160	* Returns {@link WhiteListQuery.Result} describing the
161	* white list violation.
162	* @return the {@link WhiteListQuery.Result}
163	*/
164	@NonNull
165	public WhiteListQuery.Result getResult() {
166	return result;
167	}
168
169	/**
170	* Returns the file in which the white list violation occured.
171	* @return the {@link FileObject}
172	*/
173	@CheckForNull
174	public FileObject getFile() {
175	return root.getFileObject(relPath);
176	}
177
178	/**
179	* Returns the line number of white list violation.
180	* @return the line number
181	*/
182	public int getLine() {
183	return line;
184	}
185	}
186
187	//<editor-fold defaultstate="collapsed" desc="Private implementation">
188	private void fireIndexChange(final URL root) {
189	final WhiteListIndexEvent event = new WhiteListIndexEvent(this, root);
190	for (WhiteListIndexListener l : listeners) {
191	l.indexChanged(event);
192	}
193	}
194
195
196	private static final class WhiteListIndexAccessorImpl extends WhiteListIndexAccessor {
197	@Override
198	public void refresh(@NonNull URL root) {
199	WhiteListIndex.getDefault().fireIndexChange(root);
200	}
201
202	@Override
203	@NonNull
204	public Problem createProblem(
205	@NonNull final Result result,
206	@NonNull final FileObject root,
207	@NonNull final String key,
208	int line) {
209	return new Problem(result, root, key, line);
210	}
211	}
212	//</editor-fold>
213	}

Line 0 Link Here

(-)a/whitelist/src/org/netbeans/modules/whitelist/index/WhiteListIndexAccessor.java (+85 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2011 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.whitelist.index;
		43
		44	import java.net.URL;
		45	import org.netbeans.api.annotations.common.NonNull;
		46	import org.netbeans.api.whitelist.WhiteListQuery;
		47	import org.netbeans.api.whitelist.index.WhiteListIndex;
		48	import org.openide.filesystems.FileObject;
		49	import org.openide.util.Exceptions;
		50	import org.openide.util.Parameters;
		51
		52	/**
		53	*
		54	* @author Tomas Zezula
		55	*/
		56	public abstract class WhiteListIndexAccessor {
		57
		58	private static volatile WhiteListIndexAccessor instance;
		59
		60	@NonNull
		61	public static synchronized WhiteListIndexAccessor getInstance() {
		62	if (instance == null) {
		63	try {
		64	Class.forName(WhiteListIndex.class.getName(), true, WhiteListIndexAccessor.class.getClassLoader());
65	assert instance != null;
66	} catch (ClassNotFoundException ex) {
67	Exceptions.printStackTrace(ex);
68	}
69	}
70	return instance;
71
72	}
73
74	public static void setInstance(@NonNull final WhiteListIndexAccessor _instance) {
75	Parameters.notNull("_instance", _instance); //NOI18N
76	instance = _instance;
77	}
78
79	public abstract void refresh(@NonNull URL root);
80	public abstract WhiteListIndex.Problem createProblem(
81	@NonNull WhiteListQuery.Result result,
82	@NonNull FileObject root,
83	@NonNull String key,
84	int line);
85	}