001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */
019: package org.apache.openjpa.enhance;
020:
021: import java.lang.reflect.InvocationHandler;
022: import java.lang.reflect.Proxy;
023: import java.lang.reflect.Method;
024: import java.lang.reflect.Field;
025:
026: import org.apache.openjpa.kernel.OpenJPAStateManager;
027: import org.apache.openjpa.kernel.StateManagerImpl;
028: import org.apache.openjpa.meta.FieldMetaData;
029: import org.apache.openjpa.meta.JavaTypes;
030: import org.apache.openjpa.util.ImplHelper;
031:
032: /**
033: * Helper methods for managed types that use method redefinition for field
034: * tracking.
035: *
036: * @since 1.0.0
037: */
038: public class RedefinitionHelper {
039:
040: /**
041: * Call {@link StateManagerImpl#dirtyCheck} if the argument is a
042: * {@link StateManagerImpl}.
043: */
044: public static void dirtyCheck(StateManager sm) {
045: if (sm instanceof StateManagerImpl)
046: ((StateManagerImpl) sm).dirtyCheck();
047: }
048:
049: /**
050: * Notify the state manager for <code>o</code> (if any) that a field
051: * is about to be accessed.
052: */
053: public static void accessingField(Object o, int absoluteIndex) {
054: PersistenceCapable pc = ImplHelper
055: .toPersistenceCapable(o, null);
056: if (pc == null)
057: return;
058: StateManager sm = pc.pcGetStateManager();
059: if (sm != null)
060: sm.accessingField(absoluteIndex);
061: }
062:
063: /**
064: * Setting state callback.
065: */
066: public static void settingField(Object o, int idx, boolean cur,
067: boolean next) {
068: PersistenceCapable pc = ImplHelper
069: .toPersistenceCapable(o, null);
070: if (pc == null)
071: return;
072: StateManager sm = pc.pcGetStateManager();
073: if (sm != null)
074: sm.settingBooleanField(pc, idx, cur, next,
075: OpenJPAStateManager.SET_USER);
076: }
077:
078: /**
079: * Setting state callback.
080: */
081: public static void settingField(Object o, int idx, char cur,
082: char next) {
083: PersistenceCapable pc = ImplHelper
084: .toPersistenceCapable(o, null);
085: if (pc == null)
086: return;
087: StateManager sm = pc.pcGetStateManager();
088: if (sm != null)
089: sm.settingCharField(pc, idx, cur, next,
090: OpenJPAStateManager.SET_USER);
091: }
092:
093: /**
094: * Setting state callback.
095: */
096: public static void settingField(Object o, int idx, byte cur,
097: byte next) {
098: PersistenceCapable pc = ImplHelper
099: .toPersistenceCapable(o, null);
100: if (pc == null)
101: return;
102: StateManager sm = pc.pcGetStateManager();
103: if (sm != null)
104: sm.settingByteField(pc, idx, cur, next,
105: OpenJPAStateManager.SET_USER);
106: }
107:
108: /**
109: * Setting state callback.
110: */
111: public static void settingField(Object o, int idx, short cur,
112: short next) {
113: PersistenceCapable pc = ImplHelper
114: .toPersistenceCapable(o, null);
115: if (pc == null)
116: return;
117: StateManager sm = pc.pcGetStateManager();
118: if (sm != null)
119: sm.settingShortField(pc, idx, cur, next,
120: OpenJPAStateManager.SET_USER);
121: }
122:
123: /**
124: * Setting state callback.
125: */
126: public static void settingField(Object o, int idx, int cur, int next) {
127: PersistenceCapable pc = ImplHelper
128: .toPersistenceCapable(o, null);
129: if (pc == null)
130: return;
131: StateManager sm = pc.pcGetStateManager();
132: if (sm != null)
133: sm.settingIntField(pc, idx, cur, next,
134: OpenJPAStateManager.SET_USER);
135: }
136:
137: /**
138: * Setting state callback.
139: */
140: public static void settingField(Object o, int idx, long cur,
141: long next) {
142: PersistenceCapable pc = ImplHelper
143: .toPersistenceCapable(o, null);
144: if (pc == null)
145: return;
146: StateManager sm = pc.pcGetStateManager();
147: if (sm != null)
148: sm.settingLongField(pc, idx, cur, next,
149: OpenJPAStateManager.SET_USER);
150: }
151:
152: /**
153: * Setting state callback.
154: */
155: public static void settingField(Object o, int idx, float cur,
156: float next) {
157: PersistenceCapable pc = ImplHelper
158: .toPersistenceCapable(o, null);
159: if (pc == null)
160: return;
161: StateManager sm = pc.pcGetStateManager();
162: if (sm != null)
163: sm.settingFloatField(pc, idx, cur, next,
164: OpenJPAStateManager.SET_USER);
165: }
166:
167: /**
168: * Setting state callback.
169: */
170: public static void settingField(Object o, int idx, double cur,
171: double next) {
172: PersistenceCapable pc = ImplHelper
173: .toPersistenceCapable(o, null);
174: if (pc == null)
175: return;
176: StateManager sm = pc.pcGetStateManager();
177: if (sm != null)
178: sm.settingDoubleField(pc, idx, cur, next,
179: OpenJPAStateManager.SET_USER);
180: }
181:
182: /**
183: * Setting state callback.
184: */
185: public static void settingField(Object o, int idx, String cur,
186: String next) {
187: PersistenceCapable pc = ImplHelper
188: .toPersistenceCapable(o, null);
189: if (pc == null)
190: return;
191: StateManager sm = pc.pcGetStateManager();
192: if (sm != null)
193: sm.settingStringField(pc, idx, cur, next,
194: OpenJPAStateManager.SET_USER);
195: }
196:
197: /**
198: * Setting state callback.
199: */
200: public static void settingField(Object o, int idx, Object cur,
201: Object next) {
202: PersistenceCapable pc = ImplHelper
203: .toPersistenceCapable(o, null);
204: if (pc == null)
205: return;
206: StateManager sm = pc.pcGetStateManager();
207: if (sm != null)
208: sm.settingObjectField(pc, idx, cur, next,
209: OpenJPAStateManager.SET_USER);
210: }
211:
212: /**
213: * Create a container instance that will delegate back to the state
214: * manager to emulate lazy loading. This is used by PC subclasses for
215: * unenhanced types that could not be redefined, and thus do not have
216: * field-interception capabilities. Do this for all collection and
217: * map field types, even if they are in the dfg, in case the fetch
218: * groups are reset at runtime.
219: *
220: * @since 1.1.0
221: */
222: public static void assignLazyLoadProxies(StateManagerImpl sm) {
223: FieldMetaData[] fmds = sm.getMetaData().getFields();
224: for (int i = 0; i < fmds.length; i++) {
225: switch (fmds[i].getTypeCode()) {
226: case JavaTypes.COLLECTION:
227: case JavaTypes.MAP:
228: PersistenceCapable pc = sm.getPersistenceCapable();
229: Field field = (Field) fmds[i].getBackingMember();
230: Reflection.set(pc, field, newLazyLoadingProxy(fmds[i]
231: .getDeclaredType(), i, sm));
232: break;
233: }
234: }
235: }
236:
237: private static Object newLazyLoadingProxy(Class type,
238: final int idx, final StateManagerImpl sm) {
239: InvocationHandler handler = new InvocationHandler() {
240:
241: public Object invoke(Object proxy, Method method,
242: Object[] args) throws Throwable {
243: // this will replace the field in the instance, so the dynamic
244: // proxy should only be called the first time a
245: // lazy-load-proxied field is used in normal usage.
246: Object delegate = sm.fetch(idx);
247: return method.invoke(delegate, args);
248: }
249: };
250: return Proxy.newProxyInstance(type.getClassLoader(),
251: new Class[] { type }, handler);
252: }
253: }
|