MentaContainer

Rev

Rev 60 | Rev 66 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 60 Rev 64
Line 4... Line 4...
4
import java.util.HashMap;
4
import java.util.HashMap;
5
import java.util.HashSet;
5
import java.util.HashSet;
6
import java.util.Map;
6
import java.util.Map;
7
import java.util.Set;
7
import java.util.Set;
8
8
-
 
9
import org.mentacontainer.Clearable;
9
import org.mentacontainer.Component;
10
import org.mentacontainer.Component;
10
import org.mentacontainer.ConfigurableComponent;
11
import org.mentacontainer.ConfigurableComponent;
11
import org.mentacontainer.Container;
12
import org.mentacontainer.Container;
12
import org.mentacontainer.Dependency;
13
import org.mentacontainer.Dependency;
13
import org.mentacontainer.Scope;
14
import org.mentacontainer.Scope;
Line 32... Line 33...
32
        private Set<Dependency> dependencies = new HashSet<Dependency>();
33
        private Set<Dependency> dependencies = new HashSet<Dependency>();
33
       
34
       
34
        public synchronized void clear(Scope scope) {
35
        public synchronized void clear(Scope scope) {
35
               
36
               
36
                if (scope == Scope.SINGLETON) {
37
                if (scope == Scope.SINGLETON) {
-
 
38
                       
-
 
39
                        for(String key : singletonsCache.keySet()) {
-
 
40
                               
-
 
41
                                Component comp = beans.get(key);
-
 
42
                               
-
 
43
                                if (comp instanceof Clearable) {
-
 
44
                                       
-
 
45
                                        Clearable<Object> c = (Clearable<Object>) comp;
-
 
46
                               
-
 
47
                                        Object value = singletonsCache.get(key);
-
 
48
                                       
-
 
49
                                        c.onCleared(value);
-
 
50
                                }
-
 
51
                        }
37
                       
52
                       
38
                        singletonsCache.clear();
53
                        singletonsCache.clear();
39
                       
54
                       
40
                } else if (scope == Scope.THREAD) {
55
                } else if (scope == Scope.THREAD) {
-
 
56
                       
-
 
57
                        for(String key : threadLocalsCache.keySet()) {
-
 
58
                               
-
 
59
                                Component comp = beans.get(key);
-
 
60
                               
-
 
61
                                if (comp instanceof Clearable) {
-
 
62
                                       
-
 
63
                                        Clearable<Object> c = (Clearable<Object>) comp;
-
 
64
                               
-
 
65
                                        ThreadLocal<Object> t = threadLocalsCache.get(key);
-
 
66
                                       
-
 
67
                                        Object value = t.get();
-
 
68
                                       
-
 
69
                                        if (value != null) c.onCleared(value);
-
 
70
                                }
-
 
71
                        }
41
                       
72
                       
42
                        for(ThreadLocal<Object> t : threadLocalsCache.values()) {
73
                        for(ThreadLocal<Object> t : threadLocalsCache.values()) {
43
                               
74
                               
44
                                t.set(null);
75
                                t.set(null);
45
                        }
76
                        }
Line 52... Line 83...
52
               
83
               
53
                Scope scope = scopes.get(key);
84
                Scope scope = scopes.get(key);
54
               
85
               
55
                if (scope == Scope.SINGLETON) {
86
                if (scope == Scope.SINGLETON) {
56
                       
87
                       
57
                        return (T) singletonsCache.remove(key);
-
 
-
 
88
                        Object value = singletonsCache.remove(key);
-
 
89
                       
-
 
90
                        if (value != null) {
-
 
91
                               
-
 
92
                                Component comp = beans.get(key);
-
 
93
                               
-
 
94
                                if (comp instanceof Clearable) {
-
 
95
                                       
-
 
96
                                        Clearable<Object> c = (Clearable<Object>) comp;
-
 
97
                                       
-
 
98
                                        c.onCleared(value);
-
 
99
                                }
-
 
100
                        }
-
 
101
                       
-
 
102
                        return (T) value;
58
                       
103
                       
59
                } else if (scope == Scope.THREAD) {
104
                } else if (scope == Scope.THREAD) {
60
                       
105
                       
61
                        ThreadLocal<Object> t = threadLocalsCache.get(key);
106
                        ThreadLocal<Object> t = threadLocalsCache.get(key);
62
                       
107
                       
63
                        if (t != null) {
108
                        if (t != null) {
64
                               
109
                               
65
                                Object o = t.get();
110
                                Object o = t.get();
66
                               
111
                               
67
                                if (o != null) {
112
                                if (o != null) {
-
 
113
                                       
-
 
114
                                        Component comp = beans.get(key);
-
 
115
                                       
-
 
116
                                        if (comp instanceof Clearable) {
-
 
117
                                               
-
 
118
                                                Clearable<Object> c = (Clearable<Object>) comp;
-
 
119
                                               
-
 
120
                                                c.onCleared(o);
-
 
121
                                        }
68
                                       
122
                                       
69
                                        t.set(null);
123
                                        t.set(null);
70
                                       
124
                                       
71
                                        return (T) o;
125
                                        return (T) o;
72
                                }
126
                                }