View Javadoc

1   /*
2    * Copyright 2005 The Apache Software Foundation.
3    * 
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at 
7    * 
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    * 
10   * Unless required by applicable law or agreed to in writing, software 
11   * distributed under the License is distributed on an "AS IS" BASIS, 
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
13   * See the License for the specific language governing permissions and 
14   * limitations under the License.
15   */
16  
17  
18  package org.apache.jdo.impl.enhancer.meta.util;
19  
20  import org.apache.jdo.impl.enhancer.meta.EnhancerMetaData;
21  import org.apache.jdo.impl.enhancer.meta.EnhancerMetaDataFatalError;
22  import org.apache.jdo.impl.enhancer.meta.EnhancerMetaDataUserException;
23  import org.apache.jdo.impl.enhancer.util.Support;
24  
25  
26  
27  
28  public final class EnhancerMetaDataTimer
29      extends Support
30      implements EnhancerMetaData
31  {
32      // delegate
33      final protected EnhancerMetaData delegate;
34  
35      /***
36       * Creates an instance.
37       */
38      public EnhancerMetaDataTimer(EnhancerMetaData delegate)
39          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
40      {
41          affirm(delegate);
42          this.delegate = delegate;
43      }
44  
45      public String getDeclaringClass(String classPath, String fieldName)
46          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
47      {
48          try {
49              timer.push("EnhancerMetaData.getDeclaringClass(String,String)",
50                         "EnhancerMetaData.getDeclaringClass(" + classPath 
51                         + ", " + fieldName + ")");
52              return delegate.getDeclaringClass(classPath, fieldName);
53          } finally {
54              timer.pop();
55          }
56      }
57  
58      public void declareField(String classPath,
59                               String fieldName,
60                               String signature)
61          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
62      {
63          try {
64              timer.push("EnhancerMetaData.declareField(String,String,String)",
65                         "EnhancerMetaData.declareField(" + classPath
66                         + ", " + fieldName + ", " + signature + ")");
67              delegate.declareField(classPath, fieldName, signature);
68          } finally {
69              timer.pop();
70          }
71      }
72      
73      public boolean isPersistenceCapableClass(String classPath)
74          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
75      {
76          try {
77              timer.push("EnhancerMetaData.isPersistenceCapableClass(String)",
78                         "EnhancerMetaData.isPersistenceCapableClass(" + classPath + ")");
79              return delegate.isPersistenceCapableClass(classPath);
80          } finally {
81              timer.pop();
82          }
83      }
84  
85      public boolean isSerializableClass(String classPath)
86          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
87      {
88          try {
89              timer.push("EnhancerMetaData.isSerializableClass(String)",
90                         "EnhancerMetaData.isSerializableClass(" + classPath + ")");
91              return delegate.isSerializableClass(classPath);
92          } finally {
93              timer.pop();
94          }
95      }
96  
97      public boolean isKnownUnenhancableClass(String classPath)
98          throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
99      {
100         try {
101             timer.push("EnhancerMetaData.isKnownUnenhancableClass(String)",
102                        "EnhancerMetaData.isKnownUnenhancableClass(" + classPath + ")");
103             return delegate.isKnownUnenhancableClass(classPath);
104         } finally {
105             timer.pop();
106         }
107     }
108 
109     public boolean isPersistenceCapableRootClass(String classPath)
110         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
111     {
112         try {
113             timer.push("EnhancerMetaData.isPersistenceCapableRootClass(String)",
114                        "EnhancerMetaData.isPersistenceCapableRootClass(" + classPath + ")");
115             return delegate.isPersistenceCapableRootClass(classPath);
116         } finally {
117             timer.pop();
118         }
119     }
120 
121     public String getPersistenceCapableRootClass(String classPath)
122         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
123     {
124         try {
125             timer.push("EnhancerMetaData.getPersistenceCapableRootClass(String)",
126                        "EnhancerMetaData.getPersistenceCapableRootClass(" + classPath + ")");
127             return delegate.getPersistenceCapableRootClass(classPath);
128         } finally {
129             timer.pop();
130         }
131     }
132 
133     public String getPersistenceCapableSuperClass(String classPath)
134         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
135     {
136         try {
137             timer.push("EnhancerMetaData.getPersistenceCapableSuperClass(String)",
138                        "EnhancerMetaData.getPersistenceCapableSuperClass(" + classPath + ")");
139             return delegate.getPersistenceCapableSuperClass(classPath);
140         } finally {
141             timer.pop();
142         }
143     }
144 
145     public String getKeyClass(String classPath)
146         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
147     {
148         try {
149             timer.push("EnhancerMetaData.getKeyClass(String)",
150                        "EnhancerMetaData.getKeyClass(" + classPath + ")");
151             return delegate.getKeyClass(classPath);
152         } finally {
153             timer.pop();
154         }
155     }
156 
157     public String getSuperKeyClass(String classPath)
158         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
159     {
160         try {
161             timer.push("EnhancerMetaData.getSuperKeyClass(String)",
162                        "EnhancerMetaData.getSuperKeyClass(" + classPath + ")");
163             return delegate.getSuperKeyClass(classPath);
164         } finally {
165             timer.pop();
166         }
167     }
168 
169     public boolean isKnownNonManagedField(String classPath,
170                                           String fieldName,
171                                           String fieldSig)
172         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
173     {
174         try {
175             timer.push("EnhancerMetaData.isKnownNonManagedField(String,String,String)",
176                        "EnhancerMetaData.isKnownNonManagedField(" + classPath
177                        + ", " + fieldName + ", " + fieldSig + ")");
178             return delegate.isKnownNonManagedField(classPath,
179                                                    fieldName, fieldSig);
180         } finally {
181             timer.pop();
182         }
183     }
184 
185     public boolean isManagedField(String classPath, String fieldName)
186         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
187     {
188         try {
189             timer.push("EnhancerMetaData.isManagedField(String,String)",
190                        "EnhancerMetaData.isManagedField(" + classPath
191                        + ", " + fieldName + ")");
192             return delegate.isManagedField(classPath, fieldName);
193         } finally {
194             timer.pop();
195         }
196     }
197 
198     public boolean isPersistentField(String classPath, String fieldName)
199         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
200     {
201         try {
202             timer.push("EnhancerMetaData.isPersistentField(String,String)",
203                        "EnhancerMetaData.isPersistentField(" + classPath
204                        + ", " + fieldName + ")");
205             return delegate.isPersistentField(classPath, fieldName);
206         } finally {
207             timer.pop();
208         }
209     }
210 
211     public boolean isTransactionalField(String classPath, String fieldName)
212         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
213     {
214         try {
215             timer.push("EnhancerMetaData.isTransactionalField(String,String)",
216                        "EnhancerMetaData.isTransactionalField(" + classPath
217                        + ", " + fieldName + ")");
218             return delegate.isTransactionalField(classPath, fieldName);
219         } finally {
220             timer.pop();
221         }
222     }
223 
224     public boolean isKeyField(String classPath, String fieldName)
225         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
226     {
227         try {
228             timer.push("EnhancerMetaData.isKeyField(String,String)",
229                        "EnhancerMetaData.isKeyField(" + classPath
230                        + ", " + fieldName + ")");
231             return delegate.isKeyField(classPath, fieldName);
232         } finally {
233             timer.pop();
234         }
235     }
236 
237     public boolean isDefaultFetchGroupField(String classPath, String fieldName)
238         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
239     {
240         try {
241             timer.push("EnhancerMetaData.isDefaultFetchGroupField(String,fieldName)",
242                        "EnhancerMetaData.isDefaultFetchGroupField(" + classPath
243                        + ", " + fieldName + ")");
244             return delegate.isDefaultFetchGroupField(classPath, fieldName);
245         } finally {
246             timer.pop();
247         }
248     }
249 
250     public int getFieldFlags(String classPath, String fieldName)
251         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
252     {
253         try {
254             timer.push("EnhancerMetaData.getFieldFlags(String, String)",
255                        "EnhancerMetaData.getFieldFlags(" + classPath
256                        + ", " + fieldName + ")");
257             return delegate.getFieldFlags(classPath, fieldName);
258         } finally {
259             timer.pop();
260         }
261     }
262 
263     public int getFieldNumber(String classPath, String fieldName)
264         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
265     {
266         try {
267             timer.push("EnhancerMetaData.getFieldNumber(String, String)",
268                        "EnhancerMetaData.getFieldNumber(" + classPath
269                        + ", " + fieldName + ")");
270             return delegate.getFieldNumber(classPath, fieldName);
271         } finally {
272             timer.pop();
273         }
274     }
275 
276     public String[] getManagedFields(String classPath)
277         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
278     {
279         try {
280             timer.push("EnhancerMetaData.getManagedFields(String)",
281                        "EnhancerMetaData.getmanagedFields(" + classPath + ")");
282             return delegate.getManagedFields(classPath);
283         } finally {
284             timer.pop();
285         }
286     }
287 
288     public String[] getKeyFields(String classPath)
289         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
290     {
291         try {
292             timer.push("EnhancerMetaData.getKeyFields(String)",
293                        "EnhancerMetaData.getKeyFields(" + classPath + ")");
294             return delegate.getKeyFields(classPath);
295         } finally {
296             timer.pop();
297         }
298     }
299 
300 
301     public int[] getFieldFlags(String classPath, String[] fieldNames)
302         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
303     {
304         try {
305             timer.push("EnhancerMetaData.getFieldFlags(String, String[])",
306                        "EnhancerMetaData.getFieldFlags(" + classPath + ")");
307             return delegate.getFieldFlags(classPath, fieldNames);
308         } finally {
309             timer.pop();
310         }
311     }
312 
313 
314     public int[] getFieldNumber(String classPath, String[] fieldNames)
315         throws EnhancerMetaDataUserException, EnhancerMetaDataFatalError
316     {
317         try {
318             timer.push("EnhancerMetaData.getFieldNumber(String, String[])",
319                        "EnhancerMetaData.getFieldNumber(" + classPath + ")");
320             return delegate.getFieldNumber(classPath, fieldNames);
321         } finally {
322             timer.pop();
323         }
324     }
325 }