/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.enhance;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.lang.reflect.Method;
import java.lang.reflect.Field;
import org.apache.openjpa.kernel.OpenJPAStateManager;
import org.apache.openjpa.kernel.StateManagerImpl;
import org.apache.openjpa.meta.FieldMetaData;
import org.apache.openjpa.meta.JavaTypes;
import org.apache.openjpa.util.ImplHelper;
/**
* Helper methods for managed types that use method redefinition for field
* tracking.
*
* @since 1.0.0
*/
public class RedefinitionHelper {
/**
* Call {@link StateManagerImpl#dirtyCheck} if the argument is a
* {@link StateManagerImpl}.
*/
public static void dirtyCheck(StateManager sm) {
if (sm instanceof StateManagerImpl)
((StateManagerImpl) sm).dirtyCheck();
}
/**
* Notify the state manager for <code>o</code> (if any) that a field
* is about to be accessed.
*/
public static void accessingField(Object o, int absoluteIndex) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.accessingField(absoluteIndex);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, boolean cur,
boolean next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingBooleanField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, char cur, char next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingCharField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, byte cur, byte next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingByteField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, short cur, short next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingShortField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, int cur, int next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingIntField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, long cur, long next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingLongField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, float cur, float next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingFloatField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, double cur,
double next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingDoubleField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, String cur,
String next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingStringField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Setting state callback.
*/
public static void settingField(Object o, int idx, Object cur,
Object next) {
PersistenceCapable pc = ImplHelper.toPersistenceCapable(o, null);
if (pc == null)
return;
StateManager sm = pc.pcGetStateManager();
if (sm != null)
sm.settingObjectField(pc, idx, cur, next,
OpenJPAStateManager.SET_USER);
}
/**
* Create a container instance that will delegate back to the state
* manager to emulate lazy loading. This is used by PC subclasses for
* unenhanced types that could not be redefined, and thus do not have
* field-interception capabilities. Do this for all collection and
* map field types, even if they are in the dfg, in case the fetch
* groups are reset at runtime.
*
* @since 1.1.0
*/
public static void assignLazyLoadProxies(StateManagerImpl sm) {
FieldMetaData[] fmds = sm.getMetaData().getFields();
for (int i = 0; i < fmds.length; i++) {
switch (fmds[i].getTypeCode()) {
case JavaTypes.COLLECTION:
case JavaTypes.MAP:
PersistenceCapable pc = sm.getPersistenceCapable();
Field field = (Field) fmds[i].getBackingMember();
Reflection.set(pc, field,
newLazyLoadingProxy(fmds[i].getDeclaredType(), i, sm));
break;
}
}
}
private static Object newLazyLoadingProxy(Class type, final int idx,
final StateManagerImpl sm) {
InvocationHandler handler = new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// this will replace the field in the instance, so the dynamic
// proxy should only be called the first time a
// lazy-load-proxied field is used in normal usage.
Object delegate = sm.fetch(idx);
return method.invoke(delegate, args);
}
};
return Proxy.newProxyInstance(type.getClassLoader(),
new Class[] { type }, handler);
}
}