KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > debugger > jpda > breakpoints > BreakpointsReader


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 package org.netbeans.modules.debugger.jpda.breakpoints;
21
22 import java.beans.PropertyChangeEvent JavaDoc;
23 import java.beans.PropertyChangeListener JavaDoc;
24 import java.util.Map JavaDoc;
25 import java.util.WeakHashMap JavaDoc;
26
27 import org.netbeans.api.debugger.DebuggerManager;
28 import org.netbeans.api.debugger.Properties;
29 import org.netbeans.api.debugger.jpda.ClassLoadUnloadBreakpoint;
30 import org.netbeans.api.debugger.jpda.ExceptionBreakpoint;
31 import org.netbeans.api.debugger.jpda.FieldBreakpoint;
32 import org.netbeans.api.debugger.jpda.JPDABreakpoint;
33 import org.netbeans.api.debugger.jpda.LineBreakpoint;
34 import org.netbeans.api.debugger.jpda.MethodBreakpoint;
35 import org.netbeans.api.debugger.jpda.ThreadBreakpoint;
36
37
38 /**
39  *
40  * @author Jan Jancura
41  */

42 public class BreakpointsReader implements Properties.Reader, PropertyChangeListener JavaDoc {
43     
44     private Map JavaDoc<JPDABreakpoint, String JavaDoc> cachedClassNames = new WeakHashMap JavaDoc<JPDABreakpoint, String JavaDoc>();
45     private Map JavaDoc<JPDABreakpoint, String JavaDoc> cachedSourceRoots = new WeakHashMap JavaDoc<JPDABreakpoint, String JavaDoc>();
46     
47     
48     public String JavaDoc [] getSupportedClassNames () {
49         return new String JavaDoc[] {
50             JPDABreakpoint.class.getName (),
51         };
52     }
53     
54     synchronized String JavaDoc findCachedClassName(JPDABreakpoint b) {
55         return cachedClassNames.get(b);
56     }
57     
58     synchronized String JavaDoc findCachedSourceRoot(JPDABreakpoint b) {
59         return cachedSourceRoots.get(b);
60     }
61     
62     void storeCachedClassName(JPDABreakpoint b, String JavaDoc className) {
63         synchronized (this) {
64             if (b instanceof LineBreakpoint && !cachedClassNames.containsKey(b)) {
65                 // Line breakpoint, class name is cached for the first time.
66
// We need to listen on URL changes and clear the cache then.
67
b.addPropertyChangeListener(LineBreakpoint.PROP_URL, this);
68             }
69             cachedClassNames.put(b, className);
70         }
71         PersistenceManager.storeBreakpoints();
72     }
73     
74     void storeCachedSourceRoot(JPDABreakpoint b, String JavaDoc sourceRoot) {
75         synchronized (this) {
76             cachedSourceRoots.put(b, sourceRoot);
77         }
78         PersistenceManager.storeBreakpoints();
79     }
80     
81     public Object JavaDoc read (String JavaDoc typeID, Properties properties) {
82         JPDABreakpoint b = null;
83         // Read both LineBreakpoint and LineBreakpoint$LineBreakpointImpl
84
if (typeID.equals (LineBreakpoint.class.getName ()) ||
85                 typeID.equals (LineBreakpoint.class.getName ()+"$LineBreakpointImpl")) {
86             LineBreakpoint lb = LineBreakpoint.create (
87                 properties.getString (LineBreakpoint.PROP_URL, null),
88                 properties.getInt (LineBreakpoint.PROP_LINE_NUMBER, 1)
89             );
90             lb.setCondition (
91                 properties.getString (LineBreakpoint.PROP_CONDITION, "")
92             );
93             lb.setPreferredClassName(
94                 properties.getString(LineBreakpoint.PROP_PREFERRED_CLASS_NAME, null)
95             );
96             synchronized (this) {
97                 cachedClassNames.put(lb, properties.getString("className", null));
98                 // We need to listen on URL changes and clear the cache then.
99
lb.addPropertyChangeListener(LineBreakpoint.PROP_URL, this);
100                 cachedSourceRoots.put(lb, properties.getString("sourceRoot", null));
101             }
102             b = lb;
103         }
104         if (typeID.equals (MethodBreakpoint.class.getName ()) ||
105                 typeID.equals (MethodBreakpoint.class.getName ()+"$MethodBreakpointImpl")) {
106             MethodBreakpoint mb = MethodBreakpoint.create ();
107             mb.setClassFilters (
108                 (String JavaDoc[]) properties.getArray (
109                     MethodBreakpoint.PROP_CLASS_FILTERS,
110                     new String JavaDoc [0]
111                 )
112             );
113             mb.setClassExclusionFilters (
114                 (String JavaDoc[]) properties.getArray (
115                     MethodBreakpoint.PROP_CLASS_EXCLUSION_FILTERS,
116                     new String JavaDoc [0]
117                 )
118             );
119             mb.setMethodName (
120                 properties.getString (MethodBreakpoint.PROP_METHOD_NAME, "")
121             );
122             mb.setCondition (
123                 properties.getString (MethodBreakpoint.PROP_CONDITION, "")
124             );
125             mb.setBreakpointType (
126                 properties.getInt (
127                     MethodBreakpoint.PROP_BREAKPOINT_TYPE,
128                     MethodBreakpoint.TYPE_METHOD_ENTRY
129                 )
130             );
131             synchronized (this) {
132                 cachedSourceRoots.put(mb, properties.getString("sourceRoot", null));
133             }
134             b = mb;
135         }
136         if (typeID.equals (ClassLoadUnloadBreakpoint.class.getName ())) {
137             ClassLoadUnloadBreakpoint cb = ClassLoadUnloadBreakpoint.create (
138                 properties.getInt (
139                     ClassLoadUnloadBreakpoint.PROP_BREAKPOINT_TYPE,
140                     ClassLoadUnloadBreakpoint.TYPE_CLASS_LOADED
141                 )
142             );
143             cb.setClassFilters (
144                 (String JavaDoc[]) properties.getArray (
145                     ClassLoadUnloadBreakpoint.PROP_CLASS_FILTERS,
146                     new String JavaDoc [0]
147                 )
148             );
149             cb.setClassExclusionFilters (
150                 (String JavaDoc[]) properties.getArray (
151                     ClassLoadUnloadBreakpoint.PROP_CLASS_EXCLUSION_FILTERS,
152                     new String JavaDoc [0]
153                 )
154             );
155             synchronized (this) {
156                 cachedSourceRoots.put(cb, properties.getString("sourceRoot", null));
157             }
158             b = cb;
159         }
160         if (typeID.equals (ExceptionBreakpoint.class.getName ())) {
161             ExceptionBreakpoint eb = ExceptionBreakpoint.create (
162                 properties.getString (
163                     ExceptionBreakpoint.PROP_EXCEPTION_CLASS_NAME,
164                     null
165                 ),
166                 properties.getInt (
167                     ExceptionBreakpoint.PROP_CATCH_TYPE,
168                     ExceptionBreakpoint.TYPE_EXCEPTION_CATCHED_UNCATCHED
169                 )
170             );
171             eb.setCondition (
172                 properties.getString (ExceptionBreakpoint.PROP_CONDITION, "")
173             );
174             synchronized (this) {
175                 cachedSourceRoots.put(eb, properties.getString("sourceRoot", null));
176             }
177             b = eb;
178         }
179         if (typeID.equals (FieldBreakpoint.class.getName ()) ||
180                 typeID.equals (FieldBreakpoint.class.getName ()+"$FieldBreakpointImpl")) {
181             FieldBreakpoint fb = FieldBreakpoint.create (
182                 properties.getString (FieldBreakpoint.PROP_CLASS_NAME, null),
183                 properties.getString (FieldBreakpoint.PROP_FIELD_NAME, null),
184                 properties.getInt (
185                     FieldBreakpoint.PROP_BREAKPOINT_TYPE,
186                     FieldBreakpoint.TYPE_ACCESS
187                 )
188             );
189             fb.setCondition (
190                 properties.getString (FieldBreakpoint.PROP_CONDITION, "")
191             );
192             synchronized (this) {
193                 cachedSourceRoots.put(fb, properties.getString("sourceRoot", null));
194             }
195             b = fb;
196         }
197         if (typeID.equals (ThreadBreakpoint.class.getName ())) {
198             ThreadBreakpoint tb = ThreadBreakpoint.create (
199             );
200             tb.setBreakpointType (
201                 properties.getInt (
202                     ThreadBreakpoint.PROP_BREAKPOINT_TYPE,
203                     ThreadBreakpoint.TYPE_THREAD_STARTED_OR_DEATH
204                 )
205             );
206             b = tb;
207         }
208         assert b != null: "Unknown breakpoint type: \""+typeID+"\"";
209         b.setPrintText (
210             properties.getString (JPDABreakpoint.PROP_PRINT_TEXT, "")
211         );
212         b.setGroupName(
213             properties.getString (JPDABreakpoint.PROP_GROUP_NAME, "")
214         );
215         b.setSuspend (
216             properties.getInt (
217                 JPDABreakpoint.PROP_SUSPEND,
218                 JPDABreakpoint.SUSPEND_ALL
219             )
220         );
221         if (properties.getBoolean (JPDABreakpoint.PROP_ENABLED, true))
222             b.enable ();
223         else
224             b.disable ();
225         return b;
226     }
227     
228     public void write (Object JavaDoc object, Properties properties) {
229         JPDABreakpoint b = (JPDABreakpoint) object;
230         properties.setString (
231             JPDABreakpoint.PROP_PRINT_TEXT,
232             b.getPrintText ()
233         );
234         properties.setString (
235             JPDABreakpoint.PROP_GROUP_NAME,
236             b.getGroupName ()
237         );
238         properties.setInt (JPDABreakpoint.PROP_SUSPEND, b.getSuspend ());
239         properties.setBoolean (JPDABreakpoint.PROP_ENABLED, b.isEnabled ());
240         
241         if (object instanceof LineBreakpoint) {
242             LineBreakpoint lb = (LineBreakpoint) object;
243             properties.setString (LineBreakpoint.PROP_URL, lb.getURL ());
244             properties.setInt (
245                 LineBreakpoint.PROP_LINE_NUMBER,
246                 lb.getLineNumber ()
247             );
248             properties.setString (
249                 LineBreakpoint.PROP_CONDITION,
250                 lb.getCondition ()
251             );
252             properties.setString(
253                 LineBreakpoint.PROP_PREFERRED_CLASS_NAME,
254                 lb.getPreferredClassName()
255             );
256             properties.setString("className", findCachedClassName(lb));
257             properties.setString("sourceRoot", findCachedSourceRoot(lb));
258             return;
259         } else
260         if (object instanceof MethodBreakpoint) {
261             MethodBreakpoint mb = (MethodBreakpoint) object;
262             properties.setArray (
263                 MethodBreakpoint.PROP_CLASS_FILTERS,
264                 mb.getClassFilters ()
265             );
266             properties.setArray (
267                 MethodBreakpoint.PROP_CLASS_EXCLUSION_FILTERS,
268                 mb.getClassExclusionFilters ()
269             );
270             properties.setString (
271                 MethodBreakpoint.PROP_METHOD_NAME,
272                 mb.getMethodName ()
273             );
274             properties.setString (
275                 MethodBreakpoint.PROP_CONDITION,
276                 mb.getCondition ()
277             );
278             properties.setInt (
279                 MethodBreakpoint.PROP_BREAKPOINT_TYPE,
280                 mb.getBreakpointType ()
281             );
282             properties.setString("sourceRoot", findCachedSourceRoot(mb));
283             return;
284         } else
285         if (object instanceof ClassLoadUnloadBreakpoint) {
286             ClassLoadUnloadBreakpoint cb = (ClassLoadUnloadBreakpoint) object;
287             properties.setArray (
288                 ClassLoadUnloadBreakpoint.PROP_CLASS_FILTERS,
289                 cb.getClassFilters ()
290             );
291             properties.setArray (
292                 ClassLoadUnloadBreakpoint.PROP_CLASS_EXCLUSION_FILTERS,
293                 cb.getClassExclusionFilters ()
294             );
295             properties.setInt (
296                 ClassLoadUnloadBreakpoint.PROP_BREAKPOINT_TYPE,
297                 cb.getBreakpointType ()
298             );
299             properties.setString("sourceRoot", findCachedSourceRoot(cb));
300             return;
301         } else
302         if (object instanceof ExceptionBreakpoint) {
303             ExceptionBreakpoint eb = (ExceptionBreakpoint) object;
304             properties.setString (
305                 ExceptionBreakpoint.PROP_EXCEPTION_CLASS_NAME,
306                 eb.getExceptionClassName ()
307             );
308             properties.setInt (
309                 ExceptionBreakpoint.PROP_CATCH_TYPE,
310                 eb.getCatchType ()
311             );
312             properties.setString (
313                 ExceptionBreakpoint.PROP_CONDITION,
314                 eb.getCondition ()
315             );
316             properties.setString("sourceRoot", findCachedSourceRoot(eb));
317             return;
318         } else
319         if (object instanceof FieldBreakpoint) {
320             FieldBreakpoint fb = (FieldBreakpoint) object;
321             properties.setString (
322                 FieldBreakpoint.PROP_CLASS_NAME,
323                 fb.getClassName ()
324             );
325             properties.setString (
326                 FieldBreakpoint.PROP_FIELD_NAME,
327                 fb.getFieldName ()
328             );
329             properties.setString (
330                 FieldBreakpoint.PROP_CONDITION,
331                 fb.getCondition ()
332             );
333             properties.setInt (
334                 FieldBreakpoint.PROP_BREAKPOINT_TYPE,
335                 fb.getBreakpointType ()
336             );
337             properties.setString("sourceRoot", findCachedSourceRoot(fb));
338             return;
339         } else
340         if (object instanceof ThreadBreakpoint) {
341             ThreadBreakpoint tb = (ThreadBreakpoint) object;
342             properties.setInt (
343                 ThreadBreakpoint.PROP_BREAKPOINT_TYPE,
344                 tb.getBreakpointType ()
345             );
346             return;
347         }
348         return;
349     }
350
351     public void propertyChange(PropertyChangeEvent JavaDoc evt) {
352         if (LineBreakpoint.PROP_URL.equals(evt.getPropertyName())) {
353             LineBreakpoint lb = (LineBreakpoint) evt.getSource();
354             storeCachedClassName(lb, null);
355         }
356     }
357     
358 }
359
Popular Tags