import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=ActionProvider.class, projectType="org-netbeans-modules-java-j2seproject")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service={GroovyFeature.class, GroovyProjectExtender.class},

projectType="org-netbeans-modules-java-j2seproject")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=ProjectOpenedHook.class, projectType="org-netbeans-modules-java-j2seproject")

    @LookupMerger.Registration(projectType="org-netbeans-modules-java-j2seproject")

import org.netbeans.spi.project.LookupProvider;

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=HibernateEnvironment.class, projectType={

    "org-netbeans-modules-maven",

    "org-netbeans-modules-java-j2seproject",

    "org-netbeans-modules-web-project"

}, projectTypes=@LookupProvider.Registration.ProjectType(id="org-netbeans-modules-ant-freeform", position=700))

import org.netbeans.spi.project.LookupProvider;

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=VerificationWarningOverrider.class, projectType={

    "org-netbeans-modules-maven",

    "org-netbeans-modules-java-j2seproject",

    "org-netbeans-modules-web-project"

}, projectTypes=@LookupProvider.Registration.ProjectType(id="org-netbeans-modules-ant-freeform", position=701))

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service={ProjectClassPathModifierImplementation.class, ProjectClassPathExtender.class},

projectType="org-netbeans-modules-maven")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=EntityClassScopeProvider.class, projectType="org-netbeans-modules-maven")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service={PersistenceLocationProvider.class, PersistenceScopeProvider.class, PersistenceScopesProvider.class},

projectType="org-netbeans-modules-maven")

/*

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

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

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

 * by Sun 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 2009 Sun Microsystems, Inc.

 */

package org.netbeans.modules.maven.persistence;

import org.netbeans.spi.project.ProjectServiceProvider;

import org.netbeans.spi.project.ui.RecommendedTemplates;

@ProjectServiceProvider(service=RecommendedTemplates.class, projectType="org-netbeans-modules-maven")

public class RecommendedTemplatesImpl implements RecommendedTemplates {

    public String[] getRecommendedTypes() {

        return new String[] {"persistence"};

    }

}

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=LateBoundPrerequisitesChecker.class, projectType="org-netbeans-modules-maven")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service={SpringConfigFileProvider.class, SpringConfigFileLocationProvider.class}, projectType="org-netbeans-modules-maven")

import org.netbeans.spi.project.ProjectServiceProvider;

@ProjectServiceProvider(service=RecommendedTemplates.class, projectType="org-netbeans-modules-maven")

import org.openide.util.Parameters;

        for (Class c : classes) {

            Parameters.notNull("classes[x]", c);

        }

        <change id="ProjectServiceProvider">

            <api name="general"/>

            <summary>Add annotations <code>@ProjectServiceProvider</code> and <code>@LookupMerger.Registration</code></summary>

            <version major="1" minor="23"/>

            <date day="23" month="1" year="2009"/>

            <author login="jglick"/>

            <compatibility addition="yes" binary="compatible" deletion="no" deprecation="no" modification="no" semantic="compatible" source="compatible">

                <p>

                    Implementations of <code>LookupProvider</code> should be converted wherever possible.

                </p>

            </compatibility>

            <description>

                <p>

                  Added annotations to register entries to project lookup individually.

                  These can be used instead of implementing a <code>LookupProvider</code>.

                  Since the entries are loaded on demand, this can help avoid needless class loading.

                </p>

            </description>

            <class package="org.netbeans.spi.project" name="ProjectServiceProvider"/>

            <class package="org.netbeans.spi.project" name="LookupMerger"/>

            <issue number="150194"/>

        </change>

/*

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

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

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

 * by Sun 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 2008 Sun Microsystems, Inc.

 */

package org.netbeans.modules.projectapi;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import org.netbeans.api.project.Project;

import org.netbeans.spi.project.LookupMerger;

import org.netbeans.spi.project.LookupProvider;

import org.netbeans.spi.project.ProjectServiceProvider;

import org.openide.util.Exceptions;

import org.openide.util.Lookup;

import org.openide.util.Lookup.Template;

import org.openide.util.lookup.Lookups;

import org.openide.util.lookup.ProxyLookup;

/**

 * Factory methods for lazy {@link LookupProvider} registration.

 */

public class LazyLookupProviders {

    private LazyLookupProviders() {}

    /**

     * @see ProjectServiceProvider

     */

    public static LookupProvider forProjectServiceProvider(final Map<String,Object> attrs) throws ClassNotFoundException {

        return new LookupProvider() {

            public Lookup createAdditionalLookup(final Lookup lkp) {

                return new ProxyLookup() {

                    final Collection<String> serviceNames = Arrays.asList(((String) attrs.get("service")).split(",")); // NOI18N

                    Class<?> service;

                    protected @Override void beforeLookup(Template<?> template) {

                        if (service == null && serviceNames.contains(template.getType().getName())) { // NOI18N

                            service = template.getType();

                            try {

                                Object instance = loadPSPInstance((String) attrs.get("class"), (String) attrs.get("method"), lkp); // NOI18N

                                service.cast(instance);

                                setLookups(Lookups.singleton(instance));

                            } catch (Exception x) {

                                Exceptions.printStackTrace(x);

                            }

                        }

                    }

                };

            }

        };

    }

    private static Object loadPSPInstance(String implName, String methodName, Lookup lkp) throws Exception {

        Class<?> clazz = Thread.currentThread().getContextClassLoader().loadClass(implName);

        if (methodName == null) {

            for (Constructor c : clazz.getConstructors()) {

                Object[] vals = valuesFor(c.getParameterTypes(), lkp);

                if (vals != null) {

                    return c.newInstance(vals);

                }

            }

        } else {

            for (Method m : clazz.getMethods()) {

                Object[] vals = valuesFor(m.getParameterTypes(), lkp);

                if (vals != null) {

                    return m.invoke(null, vals);

                }

            }

        }

        throw new RuntimeException(implName + "." + methodName); // NOI18N

    }

    private static Object[] valuesFor(Class[] params, Lookup lkp) {

        if (params.length > 2) {

            return null;

        }

        List<Object> values = new ArrayList<Object>();

        for (Class param : params) {

            if (param == Lookup.class) {

                values.add(lkp);

            } else if (param == Project.class) {

                Project project = lkp.lookup(Project.class);

                if (project == null) {

                    throw new IllegalArgumentException("Lookup " + lkp + " did not contain any Project instance");

                }

                values.add(project);

            } else {

                return null;

            }

        }

        return values.toArray();

    }

    /**

     * @see org.netbeans.spi.project.LookupMerger.Registration

     */

    public static MetaLookupMerger forLookupMerger(final Map<String,Object> attrs) throws ClassNotFoundException {

        return new MetaLookupMerger() {

            private LookupMerger<?> delegate;

            public boolean canNowMerge(Class<?> service) {

                if (delegate == null && service.getName().equals((String) attrs.get("service"))) { // NOI18N

                    try {

                        LookupMerger<?> m = (LookupMerger<?>) attrs.get("lookupMergerInstance"); // NOI18N

                        if (service != m.getMergeableClass()) {

                            throw new ClassCastException(service + " vs. " + m.getMergeableClass()); // NOI18N

                        }

                        delegate = m;

                        return true;

                    } catch (Exception x) {

                        Exceptions.printStackTrace(x);

                    }

                }

                return false;

            }

            public LookupMerger merger() {

                return delegate;

            }

        };

    }

}

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import javax.lang.model.element.AnnotationMirror;

import javax.lang.model.element.AnnotationValue;

import javax.lang.model.element.ElementKind;

import javax.lang.model.element.ExecutableElement;

import javax.lang.model.element.Modifier;

import javax.lang.model.element.VariableElement;

import javax.lang.model.type.DeclaredType;

import javax.lang.model.type.TypeMirror;

import javax.lang.model.util.ElementFilter;

import org.netbeans.api.project.Project;

import org.netbeans.spi.project.LookupMerger;

import org.netbeans.spi.project.ProjectServiceProvider;

import org.openide.filesystems.annotations.LayerBuilder;

import org.openide.util.Lookup;

        for (Element e : roundEnv.getElementsAnnotatedWith(ProjectServiceProvider.class)) {

            List<TypeMirror> services = findServiceAnnotation(e);

            if (services.isEmpty()) {

                throw new LayerGenerationException("Must specify at least one service", e);

            }

            String servicesBinName = null;

            for (TypeMirror service : services) {

                String n = processingEnv.getElementUtils().getBinaryName((TypeElement) processingEnv.getTypeUtils().asElement(service)).toString();

                if (n.equals(LookupMerger.class.getName())) {

                    throw new LayerGenerationException("@ProjectServiceProvider should not be used on LookupMerger; use @LookupMerger.Registration instead", e);

                }

                servicesBinName = servicesBinName == null ? n : servicesBinName + "," + n;

            }

            String[] binAndMethodNames = findPSPDefinition(e, services);

            ProjectServiceProvider psp = e.getAnnotation(ProjectServiceProvider.class);

            if (psp.projectType().length == 0 && psp.projectTypes().length == 0) {

                throw new LayerGenerationException("You must specify either projectType or projectTypes", e);

            }

            String fileBaseName = binAndMethodNames[0].replace('.', '-');

            if (binAndMethodNames[1] != null) {

                fileBaseName += "-" + binAndMethodNames[1];

            }

            for (String type : psp.projectType()) {

                LayerBuilder.File f = layer(e).file("Projects/" + type + "/Lookup/" + fileBaseName + ".instance").

                        methodvalue("instanceCreate", LazyLookupProviders.class.getName(), "forProjectServiceProvider").

                        stringvalue("class", binAndMethodNames[0]).

                        stringvalue("service", servicesBinName);

                if (binAndMethodNames[1] != null) {

                    f.stringvalue("method", binAndMethodNames[1]);

                }

                f.write();

            }

            for (LookupProvider.Registration.ProjectType type : psp.projectTypes()) {

                LayerBuilder.File f = layer(e).file("Projects/" + type.id() + "/Lookup/" + fileBaseName + ".instance").

                        methodvalue("instanceCreate", LazyLookupProviders.class.getName(), "forProjectServiceProvider").

                        stringvalue("class", binAndMethodNames[0]).

                        stringvalue("service", servicesBinName).

                        position(type.position());

                if (binAndMethodNames[1] != null) {

                    f.stringvalue("method", binAndMethodNames[1]);

                }

                f.write();

            }

        }

        for (Element e : roundEnv.getElementsAnnotatedWith(LookupMerger.Registration.class)) {

            LookupMerger.Registration lmr = e.getAnnotation(LookupMerger.Registration.class);

            String fileBaseName;

            DeclaredType impl;

            if (e.getKind() == ElementKind.CLASS) {

                fileBaseName = processingEnv.getElementUtils().getBinaryName((TypeElement) e).toString().replace('.', '-');

                impl = (DeclaredType) e.asType();

            } else {

                fileBaseName = processingEnv.getElementUtils().getBinaryName((TypeElement) e.getEnclosingElement()).toString().replace('.', '-') +

                        "-" + e.getSimpleName().toString();

                impl = (DeclaredType) ((ExecutableElement) e).getReturnType();

            }

            DeclaredType service = findLookupMergerType(impl);

            if (service == null) {

                throw new LayerGenerationException("Not assignable to LookupMerger<T> for some T", e);

            }

            String serviceBinName = processingEnv.getElementUtils().getBinaryName((TypeElement) service.asElement()).toString();

            if (lmr.projectType().length == 0 && lmr.projectTypes().length == 0) {

                throw new LayerGenerationException("You must specify either projectType or projectTypes", e);

            }

            for (String type : lmr.projectType()) {

                layer(e).file("Projects/" + type + "/Lookup/" + fileBaseName + ".instance").

                        methodvalue("instanceCreate", LazyLookupProviders.class.getName(), "forLookupMerger").

                        instanceAttribute("lookupMergerInstance", LookupMerger.class).

                        stringvalue("service", serviceBinName).

                        write();

            }

            for (LookupProvider.Registration.ProjectType type : lmr.projectTypes()) {

                layer(e).file("Projects/" + type.id() + "/Lookup/" + fileBaseName + ".instance").

                        methodvalue("instanceCreate", LazyLookupProviders.class.getName(), "forLookupMerger").

                        instanceAttribute("lookupMergerInstance", LookupMerger.class).

                        stringvalue("service", serviceBinName).

                        position(type.position()).

                        write();

            }

        }

    private List<TypeMirror> findServiceAnnotation(Element e) throws LayerGenerationException {

        for (AnnotationMirror ann : e.getAnnotationMirrors()) {

            if (!ProjectServiceProvider.class.getName().equals(ann.getAnnotationType().toString())) {

                continue;

            }

            for (Map.Entry<? extends ExecutableElement,? extends AnnotationValue> attr : ann.getElementValues().entrySet()) {

                if (!attr.getKey().getSimpleName().contentEquals("service")) {

                    continue;

                }

                List<TypeMirror> r = new ArrayList<TypeMirror>();

                for (Object item : (List<?>) attr.getValue().getValue()) {

                    r.add((TypeMirror) ((AnnotationValue) item).getValue());

                }

                return r;

            }

            throw new LayerGenerationException("No service attr found", e);

        }

        throw new LayerGenerationException("No @ProjectServiceProvider found", e);

    }

    private String[] findPSPDefinition(Element e, List<TypeMirror> services) throws LayerGenerationException {

        if (e.getKind() == ElementKind.CLASS) {

            TypeElement clazz = (TypeElement) e;

            for (TypeMirror service : services) {

                if (!processingEnv.getTypeUtils().isAssignable(clazz.asType(), service)) {

                    throw new LayerGenerationException("Not assignable to " + service, e);

                }

            }

            int constructorCount = 0;

            CONSTRUCTOR: for (ExecutableElement constructor : ElementFilter.constructorsIn(clazz.getEnclosedElements())) {

                if (!constructor.getModifiers().contains(Modifier.PUBLIC)) {

                    continue;

                }

                List<? extends VariableElement> params = constructor.getParameters();

                if (params.size() > 2) {

                    continue;

                }

                for (VariableElement param : params) {

                    if (!param.asType().equals(processingEnv.getElementUtils().getTypeElement(Project.class.getCanonicalName()).asType()) &&

                            !param.asType().equals(processingEnv.getElementUtils().getTypeElement(Lookup.class.getCanonicalName()).asType())) {

                        continue CONSTRUCTOR;

                    }

                }

                constructorCount++;

            }

            if (constructorCount != 1) {

                throw new LayerGenerationException("Must have exactly one public constructor optionally taking Project and/or Lookup", e);

            }

            return new String[] {processingEnv.getElementUtils().getBinaryName(clazz).toString(), null};

        } else {

            ExecutableElement meth = (ExecutableElement) e;

            for (TypeMirror service : services) {

                if (!processingEnv.getTypeUtils().isAssignable(meth.getReturnType(), service)) {

                    throw new LayerGenerationException("Not assignable to " + service, e);

                }

            }

            if (!meth.getModifiers().contains(Modifier.PUBLIC)) {

                throw new LayerGenerationException("Method must be public", e);

            }

            if (!meth.getModifiers().contains(Modifier.STATIC)) {

                throw new LayerGenerationException("Method must be static", e);

            }

            List<? extends VariableElement> params = meth.getParameters();

            if (params.size() > 2) {

                throw new LayerGenerationException("Method must take at most two parameters", e);

            }

            for (VariableElement param : params) {

                if (!param.asType().equals(processingEnv.getElementUtils().getTypeElement(Project.class.getCanonicalName()).asType()) &&

                        !param.asType().equals(processingEnv.getElementUtils().getTypeElement(Lookup.class.getCanonicalName()).asType())) {

                    throw new LayerGenerationException("Method parameters may be either Lookup or Project", e);

                }

            }

            return new String[] {

                processingEnv.getElementUtils().getBinaryName((TypeElement) meth.getEnclosingElement()).toString(),

                meth.getSimpleName().toString()};

        }

    }

    private DeclaredType findLookupMergerType(DeclaredType t) {

        String rawName = processingEnv.getTypeUtils().erasure(t).toString();

        if (rawName.equals(LookupMerger.class.getName())) {

            List<? extends TypeMirror> args = t.getTypeArguments();

            if (args.size() == 1) {

                return (DeclaredType) args.get(0);

            } else {

                return null;

            }

        }

        for (TypeMirror supe : processingEnv.getTypeUtils().directSupertypes(t)) {

            DeclaredType result = findLookupMergerType((DeclaredType) supe);

            if (result != null) {

                return result;

            }

        }

        return null;

    }

/*

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

 *

 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

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

 * by Sun 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 2009 Sun Microsystems, Inc.

 */

package org.netbeans.modules.projectapi;

import org.netbeans.spi.project.LookupMerger;

import org.openide.util.Lookup;

/**

 * @see LazyLookupProviders#forLookupMerger

 */

public interface MetaLookupMerger {

    boolean canNowMerge(Class<?> service);

    LookupMerger/*|null*/ merger();

}

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import org.netbeans.spi.project.LookupProvider.Registration.ProjectType;

    /**

     * Registers a lookup merger for some project types.

     * The annotated class must be assignable to {@link LookupMerger} with a type parameter.

     * @since org.netbeans.modules.projectapi/1 1.23

     */

    @Retention(RetentionPolicy.SOURCE)

    @Target({ElementType.TYPE, ElementType.METHOD})

    @interface Registration {

        /**

         * Token(s) denoting one or more project types, e.g. {@code "org-netbeans-modules-java-j2seproject"}

         */

        String[] projectType() default {};

        /**

         * Alternate registration of project types with positions.

         * You must specify either this or {@link #projectType} (or both).

         */

        ProjectType[] projectTypes() default {};

    }

         * @since org.netbeans.modules.projectapi/1 1.22

         * @since org.netbeans.modules.projectapi/1 1.22

/*

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

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * 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.  Sun designates this

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

 * by Sun 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 2008 Sun Microsystems, Inc.

 */

package org.netbeans.spi.project;

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

import org.netbeans.api.project.Project;

import org.netbeans.spi.project.LookupProvider.Registration.ProjectType;

import org.openide.util.Lookup;

/**

 * Like {@link LookupProvider} but registers a single object into a project's lookup.

 * An annotated class must have one public constructor, which may take {@link Project} and/or {@link Lookup} parameters.

 * An annotated factory method must have similar parameters.

 * @since org.netbeans.modules.projectapi/1 1.23

 */

@Retention(RetentionPolicy.SOURCE)

@Target({ElementType.TYPE, ElementType.METHOD})

public @interface ProjectServiceProvider {

    /**

     * Service class(es) to be registered.

     * The annotated class must be assignable to the service class(es).

     */

    Class<?>[] service();

    /**

     * Token(s) denoting one or more project types, e.g. {@code "org-netbeans-modules-java-j2seproject"}

     */

    String[] projectType() default {};

    /**

     * Alternate registration of project types with positions.

     * You must specify either this or {@link #projectType} (or both).

     */

    ProjectType[] projectTypes() default {};

}

import org.netbeans.modules.projectapi.MetaLookupMerger;

        private final Lookup.Result<MetaLookupMerger> metaMergers;

            metaMergers = providerLookup.lookupResult(MetaLookupMerger.class);

            metaMergers.addLookupListener(

                WeakListeners.create(LookupListener.class, providerListener, metaMergers));

            Collection<? extends LookupProvider> providers = providerResult.allInstances();

import java.net.URL;

import java.net.URLClassLoader;

import java.util.Arrays;

import java.util.Collection;

import java.util.Set;

import java.util.SortedSet;

import java.util.TreeSet;

import org.netbeans.spi.project.ProjectServiceProvider;

import org.openide.util.test.MockLookup;

    public void testLazyProviders() throws Exception {

        // Cannot simply use static initializers to tell when classes are loaded;

        // these will not be run in case a service is loaded but not yet initialized.

        ClassLoader l = new URLClassLoader(new URL[] {

            LookupProviderSupportTest.class.getProtectionDomain().getCodeSource().getLocation()},

            LookupProviderSupportTest.class.getClassLoader()) {

            protected @Override synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {

                if (name.startsWith(LookupProviderSupportTest.class.getName() + "$")) {

                    Class c = findLoadedClass(name);

                    if (c == null) {

                        // do not delegate to parent, i.e. be sure we have loaded it

                        c = findClass(name);

                        if (resolve) {

                            resolveClass(c);

                        }

                        loadedClasses.add(c);

                    }

                    return c;

                } else {

                    return super.loadClass(name, resolve);

                }

            }

        };

        Thread.currentThread().setContextClassLoader(l);

        MockLookup.setInstances(l);

        assertLoadedClasses();

        Lookup all = LookupProviderSupport.createCompositeLookup(Lookups.fixed("hello"), "Projects/x/Lookup");

        assertLoadedClasses();

        assertEquals("hello", all.lookup(String.class));

        assertLoadedClasses();

        Collection<?> svcs2 = all.lookupAll(l.loadClass(Service2.class.getName()));

        assertEquals(1, svcs2.size());

        assertEquals(ServiceImpl2.class.getName(), svcs2.iterator().next().getClass().getName());

        assertLoadedClasses("Service2", "ServiceImpl2");

        Collection<?> svcs1 = all.lookupAll(l.loadClass(Service1.class.getName()));

        assertLoadedClasses("MergedServiceImpl1", "Merger", "Service1", "Service2", "ServiceImpl1a", "ServiceImpl1b", "ServiceImpl2");

        assertEquals(svcs1.toString(), 1, svcs1.size());

        assertTrue(svcs1.toString(), svcs1.toString().contains("ServiceImpl1a@"));

        assertTrue(svcs1.toString(), svcs1.toString().contains("ServiceImpl1b@"));

        assertTrue(svcs1.toString(), svcs1.toString().contains("Merge["));

    }

    private static final Set<Class<?>> loadedClasses = new HashSet<Class<?>>();

    private static void assertLoadedClasses(String... names) {

        SortedSet<String> actual = new TreeSet<String>();

        for (Class<?> clazz : loadedClasses) {

            actual.add(clazz.getName().replaceFirst("^\\Q" + LookupProviderSupportTest.class.getName() + "$\\E", ""));

        }

        assertEquals(Arrays.toString(names), actual.toString());

    }

    public interface Service1 {}

    public interface Service2 {}

    @ProjectServiceProvider(projectType="x", service=Service1.class)

    public static class ServiceImpl1a implements Service1 {}

    public static class ServiceImpl1b implements Service1 {

        private ServiceImpl1b(boolean x) {assert x;}

        @ProjectServiceProvider(projectType="x", service=Service1.class)

        public static Service1 create() {return new ServiceImpl1b(true);}

    }

    @ProjectServiceProvider(projectType="x", service=Service2.class)

    public static class ServiceImpl2 implements Service2 {

        public ServiceImpl2(Lookup base) {

            assertNotNull(base.lookup(String.class));

        }

    }

    @LookupMerger.Registration(projectType="x")

    public static class Merger implements LookupMerger<Service1> {

        public Class<Service1> getMergeableClass() {

            return Service1.class;

        }

        public Service1 merge(final Lookup lkp) {

            return new MergedServiceImpl1(lkp.lookupAll(Service1.class));