org.jboss.weld.bean.builtin.InstanceImpl Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of weld-osgi-bundle Show documentation
Weld runtime packaged as an OSGi bundle
There is a newer version: 6.0.0.Beta4
/*
 * JBoss, Home of Professional Open Source
 * Copyright 2008, Red Hat, Inc., and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.weld.bean.builtin;

import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.Set;

import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.Instance;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.InjectionPoint;
import javax.enterprise.util.TypeLiteral;

import org.jboss.weld.Container;
import org.jboss.weld.exceptions.InvalidObjectException;
import org.jboss.weld.injection.CurrentInjectionPoint;
import org.jboss.weld.injection.ForwardingInjectionPoint;
import org.jboss.weld.manager.BeanManagerImpl;
import org.jboss.weld.resolution.Resolvable;
import org.jboss.weld.resolution.ResolvableBuilder;
import org.jboss.weld.util.reflection.Formats;
import org.jboss.weld.util.reflection.Reflections;

import static org.jboss.weld.logging.messages.BeanMessage.PROXY_REQUIRED;

/**
 * Helper implementation for Instance for getting instances
 *
 * @param 
 * @author Gavin King
 */
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "SE_NO_SUITABLE_CONSTRUCTOR", justification = "Uses SerializationProxy")
public class InstanceImpl extends AbstractFacade> implements Instance, Serializable {

    private static class InstanceInjectionPoint extends ForwardingInjectionPoint implements Serializable {

        private static final long serialVersionUID = -4102173765226078459L;

        private final InjectionPoint injectionPoint;
        private final Type type;
        private final Set qualifiers;

        public InstanceInjectionPoint(InjectionPoint injectionPoint, Type type, Set qualifiers) {
            this.injectionPoint = injectionPoint;
            this.type = type;
            this.qualifiers = qualifiers;
        }

        @Override
        protected InjectionPoint delegate() {
            return injectionPoint;
        }

        @Override
        public Type getType() {
            return type;
        }

        @Override
        public Set getQualifiers() {
            return qualifiers;
        }

    }

    private static final long serialVersionUID = -376721889693284887L;

    public static  Instance of(InjectionPoint injectionPoint, CreationalContext creationalContext, BeanManagerImpl beanManager) {
        return new InstanceImpl(injectionPoint, creationalContext, beanManager);
    }

    private InstanceImpl(InjectionPoint injectionPoint, CreationalContext creationalContext, BeanManagerImpl beanManager) {
        super(injectionPoint, creationalContext, beanManager);
    }

    public T get() {
        Resolvable resolvable = new ResolvableBuilder(getType(), getBeanManager())
            .addQualifiers(getQualifiers())
            .setDeclaringBean(getInjectionPoint().getBean())
            .create();
        Bean bean = getBeanManager().getBean(resolvable);
        // Generate a correct injection point for the bean, we do this by taking the original injection point and adjusting the qualifiers and type
        InjectionPoint ip = new InstanceInjectionPoint(getInjectionPoint(), getType(), getQualifiers());
        CurrentInjectionPoint currentInjectionPoint = Container.instance().services().get(CurrentInjectionPoint.class);
        try {
            currentInjectionPoint.push(ip);
            return Reflections.cast(getBeanManager().getReference(bean, getType(), getCreationalContext()));
        } finally {
            currentInjectionPoint.pop();
        }
    }

    /**
     * Gets a string representation
     *
     * @return A string representation
     */
    @Override
    public String toString() {
        return Formats.formatAnnotations(getQualifiers()) + " Instance<" + Formats.formatType(getType()) + ">";
    }

    private Set> getBeans() {
        return getBeanManager().getBeans(getType(), getQualifiers());
    }

    public Iterator iterator() {
        Collection instances = new ArrayList();
        for (Bean bean : getBeans()) {
            // Don't return the InjectionPoint bean, it's not a possible to inject an instance of that!
            if (!InjectionPoint.class.isAssignableFrom(bean.getBeanClass())) {
                Object object = getBeanManager().getReference(bean, getType(), getBeanManager().createCreationalContext(bean));
                instances.add(Reflections.cast(object));
            }
        }
        return instances.iterator();
    }

    public boolean isAmbiguous() {
        return getBeans().size() > 1;
    }

    public boolean isUnsatisfied() {
        return getBeans().size() == 0;
    }

    public Instance select(Annotation... qualifiers) {
        return selectInstance(this.getType(), qualifiers);
    }

    public  Instance select(Class subtype, Annotation... qualifiers) {
        return selectInstance(subtype, qualifiers);
    }

    public  Instance select(TypeLiteral subtype, Annotation... qualifiers) {
        return selectInstance(subtype.getType(), qualifiers);
    }

    private  Instance selectInstance(Type subtype, Annotation[] newQualifiers) {
        InjectionPoint modifiedInjectionPoint = new FacadeInjectionPoint(getInjectionPoint(), subtype, getQualifiers(), newQualifiers);
        return new InstanceImpl(modifiedInjectionPoint, getCreationalContext(), getBeanManager());
    }

    // Serialization

    private Object writeReplace() throws ObjectStreamException {
        return new SerializationProxy(this);
    }

    private void readObject(ObjectInputStream stream) throws InvalidObjectException {
        throw new InvalidObjectException(PROXY_REQUIRED);
    }

    private static class SerializationProxy extends AbstractFacadeSerializationProxy> {

        private static final long serialVersionUID = 9181171328831559650L;

        public SerializationProxy(InstanceImpl instance) {
            super(instance);
        }

        private Object readResolve() {
            return InstanceImpl.of(getInjectionPoint(), getCreationalContext(), getBeanManager());
        }

    }

}