Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014-2015 the original author or authors.
   *
   * 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.lastaflute.di.core.meta.impl;
 
 import java.util.List;
 import java.util.Map;
 
 

Author(s):
modified by jflute (originated in Seasar)
 
 public class LaContainerImpl implements LaContainerContainerConstants {
 
     private static final SLogger logger = SLogger.getLogger(LaContainerImpl.class);
 
     protected List<ComponentDefcomponentDefList = new ArrayList<ComponentDef>();
     protected String namespace;
     protected String path;
     protected boolean initializeOnCreate;
     protected List<LaContainerchildren = new ArrayList<LaContainer>();
     protected Map<LaContainerIntegerchildPositions = new HashMap<LaContainerInteger>();
     protected List<LaContainerparents = new ArrayList<LaContainer>();
     protected CaseInsensitiveMap descendants = new CaseInsensitiveMap();
     protected LaContainer root;
     protected ExternalContext externalContext;
     protected MetaDefSupport metaDefSupport = new MetaDefSupport(this);
     protected boolean inited = false;
     protected ClassLoader classLoader = null;
 
     static {
         . = true;
             public ClassLoader get(ProxyFactory proxyFactory) {
                 return Thread.currentThread().getContextClassLoader();
             }
         };
     }
 
     public LaContainerImpl() {
          = this;
         register0(new SimpleComponentDef(this));
          = Thread.currentThread().getContextClassLoader();
     }
 
     public LaContainer getRoot() {
         return ;
     }
 
     public void setRoot(LaContainer root) {
         this. = root != null ? root : this;
     }
 
     @SuppressWarnings("unchecked")
     public <COMPONENT> COMPONENT getComponent(Object componentKey) {
         assertParameterIsNotNull(componentKey"componentKey");
         final ComponentDef cd = LaContainerBehavior.acquireFromGetComponent(thiscomponentKey);
        if (cd == null) {
            return null;
        }
        return (COMPONENT) cd.getComponent();
    }
    public Object[] findComponents(Object componentKey) {
        assertParameterIsNotNull(componentKey"componentKey");
        ComponentDef[] componentDefs = findComponentDefs(componentKey);
        return toComponentArray(componentKeycomponentDefs);
    }
    public Object[] findAllComponents(Object componentKeythrows CyclicReferenceRuntimeException {
        assertParameterIsNotNull(componentKey"componentKey");
        ComponentDef[] componentDefs = findAllComponentDefs(componentKey);
        return toComponentArray(componentKeycomponentDefs);
    }
    public Object[] findLocalComponents(Object componentKeythrows CyclicReferenceRuntimeException {
        assertParameterIsNotNull(componentKey"componentKey");
        ComponentDef[] componentDefs = findLocalComponentDefs(componentKey);
        return toComponentArray(componentKeycomponentDefs);
    }
    protected Object[] toComponentArray(Object componentKeyComponentDef[] componentDefs) {
        int length = componentDefs.length;
        Object[] components =
                (componentKey instanceof Class) ? (Object[]) Array.newInstance((ClasscomponentKeylength) : new Object[length];
        for (int i = 0; i < length; ++i) {
            components[i] = componentDefs[i].getComponent();
        }
        return components;
    }
    public void injectDependency(Object outerComponent) {
        injectDependency(outerComponentouterComponent.getClass());
    }

    
    public void injectDependency(Object outerComponentClass componentClass) {
        assertParameterIsNotNull(outerComponent"outerComponent");
        assertParameterIsNotNull(componentClass"componentClass");
        ComponentDef cd = LaContainerBehavior.acquireFromInjectDependency(thiscomponentClass);
        if (cd != null) {
            cd.injectDependency(outerComponent);
        }
    }

    
    public void injectDependency(Object outerComponentString componentName) {
        assertParameterIsNotNull(outerComponent"outerComponent");
        assertParameterIsNotEmpty(componentName"componentName");
        ComponentDef cd = LaContainerBehavior.acquireFromInjectDependency(thiscomponentName);
        if (cd != null) {
            cd.injectDependency(outerComponent);
        }
    }
    @Override
    public void register(Object component) {
        assertParameterIsNotNull(component"component");
        register(new SimpleComponentDef(component));
    }
    @Override
    public void register(Object componentString componentName) {
        assertParameterIsNotNull(component"component");
        assertParameterIsNotEmpty(componentName"componentName");
        register(new SimpleComponentDef(componentcomponentName));
    }
    @Override
    public void register(Class<?> componentClass) {
        assertParameterIsNotNull(componentClass"componentClass");
        register(new ComponentDefImpl(componentClass));
    }
    @Override
    public void register(Class<?> componentClassString componentName) {
        assertParameterIsNotNull(componentClass"componentClass");
        assertParameterIsNotEmpty(componentName"componentName");
        register(new ComponentDefImpl(componentClasscomponentName));
    }
    @Override
    public void register(ComponentDef componentDef) {
        assertParameterIsNotNull(componentDef"componentDef");
        register0(componentDef);
        .add(componentDef);
    }
    public void register0(ComponentDef componentDef) { // #component_point
        if (componentDef.getContainer() == null) {
            componentDef.setContainer(this);
        }
        registerByClass(componentDef);
        registerByName(componentDef);
    }
    @Override
    public void registerByClass(ComponentDef componentDef) {
        final Class<?> componentClass = componentDef.getComponentClass();
        if (componentClass != null) { // null allowed when e.g. expression, then registered later
            final Class<?>[] classes = ComponentUtil.getAssignableClasses(componentClass);
            for (int i = 0; i < classes.length; ++i) {
                registerMap(classes[i], componentDef);
            }
        }
    }
    protected void registerByName(ComponentDef componentDef) {
        final String componentName = componentDef.getComponentName();
        if (componentName != null) {
            registerMap(componentNamecomponentDef);
        }
    }
    protected void registerMap(Object keyComponentDef componentDef) {
        registerMap(keycomponentDefthis);
    }
    public void registerMap(Object keyComponentDef componentDefLaContainer container) {
        int position = getContainerPosition(container);
        ComponentDefHolder holder = (ComponentDefHolder.get(key);
        if (holder == null) {
            holder = new ComponentDefHolder(positioncomponentDef);
            .put(keyholder);
        } else if (position > holder.getPosition()) {
            return;
        } else if (position < holder.getPosition()) {
            holder.setPosition(position);
            holder.setComponentDef(componentDef);
        } else if (container != this) {
            holder.setComponentDef(componentDef);
        } else {
            holder.setComponentDef(createTooManyRegistration(keyholder.getComponentDef(), componentDef));
        }
        registerParent(keyholder.getComponentDef());
    }
    protected void registerParent(Object keyComponentDef componentDef) { // for performacen when deep nest
        for (int i = 0; i < getParentSize(); i++) {
            LaContainer parent = (LaContainergetParent(i);
            parent.registerMap(keycomponentDefthis);
            if (isNeedNS(keycomponentDef)) {
                parent.registerMap( +  + keycomponentDefthis);
            }
        }
    }
    public int getComponentDefSize() {
        return .size();
    }
    public ComponentDef getComponentDef(int index) {
        return (ComponentDef.get(index);
    }
        assertParameterIsNotNull(key"key");
        return LaContainerBehavior.acquireFromGetComponentDef(thiskey);
    }
        assertParameterIsNotNull(key"key");
        ComponentDef cd = internalGetComponentDef(key);
        return toComponentDefArray(cd);
    }
    public ComponentDef[] findAllComponentDefs(final Object componentKey) {
        assertParameterIsNotNull(componentKey"componentKey");
        final List<ComponentDefcomponentDefs = new ArrayList<ComponentDef>();
        Traversal.forEachContainer(thisnew Traversal.S2ContainerHandler() {
            public Object processContainer(LaContainer container) {
                componentDefs.addAll(Arrays.asList(container.findLocalComponentDefs(componentKey)));
                return null;
            }
        });
        return (ComponentDef[]) componentDefs.toArray(new ComponentDef[componentDefs.size()]);
    }
    public ComponentDef[] findLocalComponentDefs(Object componentKey) {
        ComponentDefHolder holder = (ComponentDefHolder.get(componentKey);
        if (holder == null || holder.getPosition() > 0) {
            return new ComponentDef[0];
        }
        return toComponentDefArray(holder.getComponentDef());
    }
    protected ComponentDef[] toComponentDefArray(ComponentDef cd) {
        if (cd == null) {
            return new ComponentDef[0];
        } else if (cd instanceof TooManyRegistrationComponentDefImpl) {
            return ((TooManyRegistrationComponentDefImplcd).getComponentDefs();
        }
        return new ComponentDef[] { cd };
    }
    protected ComponentDef internalGetComponentDef(Object key) {
        ComponentDefHolder holder = (ComponentDefHolder.get(key);
        if (holder != null) {
            return holder.getComponentDef();
        }
        if (key instanceof String) {
            String name = (Stringkey;
            int index = name.indexOf();
            if (index > 0) {
                String ns = name.substring(0, index);
                name = name.substring(index + 1);
                if (ns.equals()) {
                    return internalGetComponentDef(name);
                }
            }
        }
        return null;
    }
    public boolean hasComponentDef(Object componentKey) {
        assertParameterIsNotNull(componentKey"componentKey");
        return LaContainerBehavior.acquireFromHasComponentDef(thiscomponentKey) != null;
    }
    public boolean hasDescendant(String path) {
        assertParameterIsNotEmpty(path"path");
        return .containsKey(path);
    }
    public LaContainer getDescendant(String path) {
        LaContainer descendant = (LaContainer.get(path);
        if (descendant != null) {
            return descendant;
        }
        throw new ContainerNotRegisteredRuntimeException(path);
    }
    public void registerDescendant(LaContainer descendant) {
        assertParameterIsNotNull(descendant"descendant");
        .put(descendant.getPath(), descendant);
    }
    public void include(LaContainer child) {
        assertParameterIsNotNull(child"child");
        .add(child);
        .put(childnew Integer(.size()));
        child.setRoot(getRoot());
        child.addParent(this);
    }
    protected int getContainerPosition(LaContainer container) {
        if (container == this) {
            return 0;
        }
        return ((Integer.get(container)).intValue();
    }
    protected boolean isNeedNS(Object keyComponentDef cd) {
        return key instanceof String &&  != null;
    }
    // ===================================================================================
    //                                                                     Child Container
    //                                                                     ===============
    @Override
    public LaContainer findChild(String namespace) {
        for (LaContainer child : ) {
            if (namespace.equals(child.getNamespace())) {
                return child;
            }
        }
        for (LaContainer child : ) {
            final LaContainer nestedFound = child.findChild(namespace);
            if (nestedFound != null) {
                return nestedFound;
            }
        }
        return null;
    }
    @Override
    public int getChildSize() {
        return .size();
    }
    @Override
    public LaContainer getChild(int index) {
        return .get(index);
    }
    public int getParentSize() {
        return .size();
    }
    public LaContainer getParent(int index) {
        return (LaContainer.get(index);
    }
    public void addParent(LaContainer parent) {
        .add(parent);
        for (Iterator it = .entrySet().iterator(); it.hasNext();) {
            Entry entry = (Entryit.next();
            Object key = entry.getKey();
            final ComponentDefHolder holder = (ComponentDefHolderentry.getValue();
            final ComponentDef cd = holder.getComponentDef();
            parent.registerMap(keycdthis);
            if (isNeedNS(keycd)) {
                parent.registerMap( +  + keycdthis);
            }
        }
    }
    // ===================================================================================
    //                                                                          Initialize
    //                                                                          ==========
    public void init() {
        try {
            doInit();
        } catch (Throwable e) {
            throwContainerInitFailureException(e);
        }
    }
    protected void doInit() {
        if () {
            return;
        }
        if (register != null) {
            register.registerComponentDefs(this);
        }
        final ClassLoader currentLoader = Thread.currentThread().getContextClassLoader();
        try {
            for (int i = 0; i < getChildSize(); ++i) {
                getChild(i).init();
            }
            for (int i = 0; i < getComponentDefSize(); ++i) {
                getComponentDef(i).init();
            }
             = true;
        } finally {
            Thread.currentThread().setContextClassLoader(currentLoader);
        }
    }
    protected void throwContainerInitFailureException(Throwable cause) {
        if (cause instanceof ContainerInitFailureException) { // means nested exception
            throw (ContainerInitFailureExceptioncause;
        }
        final LdiExceptionMessageBuilder br = new LdiExceptionMessageBuilder();
        br.addNotice("Failed to initialize the container.");
        br.addItem("Path");
        br.addElement(getPath());
        br.addItem("Namespace");
        br.addElement(getNamespace());
        int parentSize = getParentSize();
        if (parentSize > 0) {
            br.addItem("Included by");
            for (int i = 0; i < parentSizei++) {
                final LaContainer parent = getParent(i);
                if (parent != null) { // just in case
                    br.addElement(parent.getPath());
                }
            }
        }
        final String msg = br.buildExceptionMessage();
        throw new ContainerInitFailureException(msgcause);
    }
    // ===================================================================================
    //                                                                             Destroy
    //                                                                             =======
    public void destroy() {
        if (!) {
            return;
        }
        final ClassLoader currentLoader = Thread.currentThread().getContextClassLoader();
        try {
            for (int i = getComponentDefSize() - 1; 0 <= i; --i) {
                try {
                    getComponentDef(i).destroy();
                } catch (Throwable t) {
                    .error("ESSR0017"t);
                }
            }
            for (int i = getChildSize() - 1; 0 <= i; --i) {
                getChild(i).destroy();
            }
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = null;
             = this;
             = false;
        } finally {
            Thread.currentThread().setContextClassLoader(currentLoader);
        }
    }
    // ===================================================================================
    //                                                                       Assert Helper
    //                                                                       =============
    public static ComponentDef createTooManyRegistration(Object keyComponentDef currentComponentDefComponentDef newComponentDef) {
        if (currentComponentDef instanceof TooManyRegistrationComponentDef) {
            ((TooManyRegistrationComponentDefcurrentComponentDef).addComponentDef(newComponentDef);
            return currentComponentDef;
        } else {
            TooManyRegistrationComponentDef tmrcf = new TooManyRegistrationComponentDefImpl(key);
            tmrcf.addComponentDef(currentComponentDef);
            tmrcf.addComponentDef(newComponentDef);
            return tmrcf;
        }
    }

    
パラメータがnullでないことを表明します。

Parameters:
parameter
name
    protected void assertParameterIsNotNull(Object parameterString name) {
        if (parameter == null) {
            throw new IllegalArgumentException(name);
        }
    }

    
パラメータが空でないことを表明します。

Parameters:
parameter
name
    protected void assertParameterIsNotEmpty(String parameterString name) {
        if (LdiStringUtil.isEmpty(parameter)) {
            throw new IllegalArgumentException(name);
        }
    }
    static class ComponentDefHolder {
        private int position;
        private ComponentDef componentDef;
        public ComponentDefHolder(int positionComponentDef componentDef) {
            this. = position;
            this. = componentDef;
        }
        public int getPosition() {
            return ;
        }
        public void setPosition(int position) {
            this. = position;
        }
        public ComponentDef getComponentDef() {
            return ;
        }
        public void setComponentDef(ComponentDef componentDef) {
            this. = componentDef;
        }
    }
    // ===================================================================================
    //                                                                      Basic Override
    //                                                                      ==============
    @Override
    public String toString() {
        final Integer defCount = ( != null ? .size() : null);
        return "container:{path=" +  + ", def_count=" + defCount + "}";
    }
    // ===================================================================================
    //                                                                            Accessor
    //                                                                            ========
    public String getNamespace() {
        return ;
    }
    public void setNamespace(String namespace) {
        .remove(namespace);
        this. = namespace;
        registerMap(namespacenew LaContainerComponentDef(thisnamespace));
    }
    public boolean isInitializeOnCreate() {
        return ;
    }
    public void setInitializeOnCreate(boolean initializeOnCreate) {
        this. = initializeOnCreate;
    }
    public String getPath() {
        return ;
    }
    public void setPath(String path) {
        this. = path;
    }
        return ;
    }
    public void setExternalContext(ExternalContext externalContext) {
        this. = externalContext;
    }
    }
        this. = register;
    }
    public void addMetaDef(MetaDef metaDef) {
        .addMetaDef(metaDef);
    }
    public MetaDef getMetaDef(int index) {
        return .getMetaDef(index);
    }
    public MetaDef getMetaDef(String name) {
        return .getMetaDef(name);
    }
    public MetaDef[] getMetaDefs(String name) {
        return .getMetaDefs(name);
    }
    public int getMetaDefSize() {
        return .getMetaDefSize();
    }
    public ClassLoader getClassLoader() {
        return ;
    }
    public void setClassLoader(ClassLoader classLoader) {
        this. = classLoader;
    }
New to GrepCode? Check out our FAQ X