View Javadoc

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