MentaContainer

Rev

Rev 5 | Blame | Compare with Previous | Last modification | View Log | RSS feed

package org.mentacontainer.impl;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import org.mentacontainer.Dependency;
import org.mentacontainer.util.InjectionUtils;

/**
 * A simple implementation of the Dependency interface.
 *
 * @author sergio.oliveira.jr@gmail.com
 */

public class MentaDependency implements Dependency {
       
        private final String target;
       
        private String source;
       
        private final Class<? extends Object> klass;
       
        private Map<String, Method> cache = new HashMap<String, Method>();
       
        public MentaDependency(String target, Class<? extends Object> klass, String source) {
               
                this.klass = klass;
               
                this.target = target;
               
                this.source = source;
        }
       
        public MentaDependency(String target, Class<? extends Object> klass) {
               
                this(target, klass, target);
        }
       
        public String getTarget() {
               
                return target;
        }
       
        public String getSource() {
               
                return source;
        }
       
        public Class<? extends Object> getType() {
               
                return klass;
        }
       
        public int hashCode() {
               
                return klass.hashCode() * 62 + target.hashCode() * 31 + source.hashCode();
        }
       
        public boolean equals(Object obj) {
               
                if (!(obj instanceof MentaDependency)) return false;
               
                MentaDependency d = (MentaDependency) obj;
               
                if (!d.target.equals(this.target)) return false;
               
                if (!d.klass.equals(this.klass)) return false;

                return true;
        }
       
    public Method check(Class<? extends Object> targetClass) {

        String className = targetClass.getName();

        // first check cache...
       
        Method m = null;
       
        synchronized(cache) {
               
                m = cache.get(className);
               
        }
       
        if (m == null && cache.containsKey(className)) return null; // it is null...

        if (m != null) return m;

        m = InjectionUtils.findMethodToInject(targetClass, target, klass);
       
        if (m != null) {
               
                synchronized(cache) {

                        cache.put(className, m);
                       
                }
           
            return m;
        }
       
        synchronized(cache) {
               
                // save null to indicate there is no method here... (so you don't do again to find null !!!
       
                cache.put(className, null);
               
        }

        return null;
    }
}