/*
* Copyright 2010-2012 VMware and contributors
*
* Licensed 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.springsource.loaded.ri;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import org.objectweb.asm.Type;
import org.springsource.loaded.CurrentLiveVersion;
import org.springsource.loaded.FieldMember;
import org.springsource.loaded.GlobalConfiguration;
import org.springsource.loaded.ReloadableType;
import org.springsource.loaded.TypeRegistry;
import org.springsource.loaded.Utils;
import org.springsource.loaded.jvm.JVM;
/**
* This class contains code that is used as support infrastructure to implement Field lookup algorithms.
*
* Mainly, it provides an abstraction to allows Java classes and reloadable types to be treated as instances of a common abstraction
* "FieldProvider" and then implement algorithms to find fields in those providers independent of how the fields are being provided.
*
* @author Kris De Volder
* @since 0.5.0
*/
public class FieldLookup {
private static class JavaFieldRef extends FieldRef {
private Field f;
public JavaFieldRef(Field f) {
this.f = f;
}
@Override
public Field getField() {
return f;
}
@Override
public String getName() {
return f.getName();
}
@Override
public boolean isPublic() {
return Modifier.isPublic(f.getModifiers());
}
}
private static class JavaClassFieldProvider extends FieldProvider {
private Class<?> clazz;
public JavaClassFieldProvider(Class<?> clazz) {
this.clazz = clazz;
}
@Override
List<FieldRef> getFields() {
Field[] fields = clazz.getDeclaredFields();
List<FieldRef> refs = new ArrayList<FieldLookup.FieldRef>();
for (Field f : fields) {
refs.add(new JavaFieldRef(f));
}
return refs;
}
@Override
public boolean isInterface() {
return clazz.isInterface();
}
@Override
public FieldProvider[] getInterfaces() {
Class<?>[] itfs = clazz.getInterfaces();
FieldProvider[] provs = new FieldProvider[itfs.length];
for (int i = 0; i < itfs.length; i++) {
provs[i] = FieldProvider.create(itfs[i]);
}
return provs;
}
@Override
public FieldProvider getSuper() {
Class<?> supr = clazz.getSuperclass();
if (supr != null) {
FieldProvider.create(supr);
}
return null;
}
}
static abstract class FieldRef {
public abstract Field getField();
public abstract String getName();
public abstract boolean isPublic();
}
public static class ReloadedTypeFieldRef extends FieldRef {
private ReloadableType rtype;
private FieldMember f;
public ReloadedTypeFieldRef(ReloadableType rtype, FieldMember f) {
if (GlobalConfiguration.assertsMode) {
Utils.assertTrue(rtype.hasBeenReloaded(), "Not yet reloaded: " + rtype.getName());
}
this.rtype = rtype;
this.f = f;
}
@Override
public Field getField() {
Class<?> declaring = Utils.toClass(rtype);
Class<?> type;
try {
type = Utils.toClass(Type.getType(f.getDescriptor()), rtype.typeRegistry.getClassLoader());
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e);
}
return JVM.newField(declaring, type, f.getModifiers(), f.getName(), f.getGenericSignature());
}
@Override
public String getName() {
return f.getName();
}
@Override
public boolean isPublic() {
return f.isPublic();
}
}
protected static abstract class FieldProvider {
abstract List<FieldRef> getFields();
public abstract boolean isInterface();
public abstract FieldProvider[] getInterfaces();
public abstract FieldProvider getSuper();
public static FieldProvider create(ReloadableType rtype) {
return new ReloadableTypeFieldProvider(rtype);
}
public static FieldProvider create(TypeRegistry typeRegistry, String slashyName) {
if (typeRegistry.isReloadableTypeName(slashyName)) {
return create(typeRegistry.getReloadableType(slashyName));
} else {
try {
return create(Utils.toClass(Type.getObjectType(slashyName), typeRegistry.getClassLoader()));
} catch (ClassNotFoundException e) {
throw new IllegalStateException(e);
}
}
}
public static FieldProvider create(Class<?> clazz) {
return new JavaClassFieldProvider(clazz);
}
}
public static class ReloadableTypeFieldProvider extends FieldProvider {
private ReloadableType rtype;
public ReloadableTypeFieldProvider(ReloadableType rtype) {
this.rtype = rtype;
}
@Override
List<FieldRef> getFields() {
FieldMember[] fields = rtype.getLatestTypeDescriptor().getFields();
List<FieldRef> refs = new ArrayList<FieldRef>(fields.length);
for (FieldMember f : fields) {
refs.add(fieldRef(rtype, f));
}
return refs;
}
private FieldRef fieldRef(ReloadableType rtype, FieldMember f) {
CurrentLiveVersion clv = rtype.getLiveVersion();
if (clv == null) {
//Not yet reloaded... use original field (with fixed mods)
try {
Field jf = rtype.getClazz().getDeclaredField(f.getName());
ReflectiveInterceptor.fixModifier(rtype.getLatestTypeDescriptor(), jf);
return new JavaFieldRef(jf);
} catch (Exception e) {
throw new IllegalStateException(e);
}
} else {
//Already reloaded
return new ReloadedTypeFieldRef(rtype, f);
}
}
@Override
public boolean isInterface() {
return rtype.getLatestTypeDescriptor().isInterface();
}
@Override
public FieldProvider[] getInterfaces() {
String[] superItfs = rtype.getLatestTypeDescriptor().getSuperinterfacesName();
FieldProvider[] superProvs = new FieldProvider[superItfs.length];
for (int i = 0; i < superItfs.length; i++) {
superProvs[i] = FieldProvider.create(rtype.typeRegistry, superItfs[i]);
}
return superProvs;
}
@Override
public FieldProvider getSuper() {
String supr = rtype.getLatestTypeDescriptor().getSupertypeName();
if (supr != null) {
return FieldProvider.create(rtype.typeRegistry, supr);
}
return null;
}
}
}