/**

@ApplicationScoped

class MetaInfo extends DestroyableBase {

// the class name

private String className;

// keep public non-static fields

private Map<String, $.T2<String, String>> publicFields;

// keep track @Sensitive fields

private Set<String> sensitiveFields;

private Set<String> passwordFields;

private Map<String, String> fieldAliases;

@Inject

MetaInfo(String className, Map<String, $.T2<String, String>> publicFields, Map<String, String> aliases) {

this.className = className;

this.publicFields = publicFields;

this.sensitiveFields = new HashSet<>();

this.passwordFields = new HashSet<>();

this.fieldAliases = aliases;

}

public String getClassName() {

return className;

}

public void setClassName(String className) {

this.className = className;

}

public Map<String, $.T2<String, String>> getPublicFields() {

return C.Map(publicFields);

}

public void addSensitiveField(String fieldName) {

E.illegalArgumentIf(passwordFields.contains(fieldName), "@Sensitive and @Password cannot be used together");

sensitiveFields.add(fieldName);

}

public void addPasswordField(String fieldName) {

E.illegalArgumentIf(sensitiveFields.contains(fieldName), "@Sensitive and @Password cannot be used together");

passwordFields.add(fieldName);

}

public boolean isSensitive(String fieldName) {

return sensitiveFields.contains(fieldName);

}

public String aliasOf(String fieldName) {

String s = fieldAliases.get(fieldName);

return null == s ? fieldName : s;

}

public boolean isPassword(String fieldName) {

return passwordFields.contains(fieldName);

}

public boolean hasPublicField() {

return !publicFields.isEmpty();

}

@Override

protected void releaseResources() {

publicFields.clear();

}

static boolean isBoolean(String desc) {

return "Z".equals(desc) || "java/lang/Boolean".equals(desc);

}

}

@ApplicationScoped

class MetaInfoManager extends DestroyableBase {

private static final String INTF_SIMPLE_BEAN = SimpleBean.class.getName();

private ClassInfoRepository classInfoRepository;

private Map<String, MetaInfo> registry = new HashMap<>();

@Inject

public MetaInfoManager(AppClassLoader classLoader) {

classInfoRepository = classLoader.classInfoRepository();

}

@Override

protected void releaseResources() {

Destroyable.Util.tryDestroyAll(registry.values(), ApplicationScoped.class);

registry.clear();

}

public void register(MetaInfo metaInfo) {

registry.put(metaInfo.getClassName(), metaInfo);

}

public boolean isPublicField(String className, String field) {

MetaInfo metaInfo = get(className);

return null != metaInfo && metaInfo.publicFields.containsKey(field) && isSimpleBean(className);

}

private boolean isSimpleBean(String className) {

ClassNode node = classInfoRepository.node(className);

if (null == node) {

return false;

}

return node.hasInterface(INTF_SIMPLE_BEAN);

}

public MetaInfo get(String className) {

return registry.get(className);

}

public $.Option<MetaInfo> safeGet(String className) {

return $.some(get(className));

}

}

class ByteCodeScanner extends AppByteCodeScannerBase {

@Override

protected boolean shouldScan(String className) {

return true;

}

@Override

public ByteCodeVisitor byteCodeVisitor() {

return new SimpleBeanByteCodeVisitor();

}

@Override

public void scanFinished(String className) {

}

private static class SimpleBeanByteCodeVisitor extends ByteCodeVisitor {

private static final String ALIAS_DESC = Type.getType(Alias.class).getDescriptor();

private String className;

private boolean isPublicClass;

// key: (desc, signature)

private Map<String, $.T2<String, String>> publicFields = new HashMap<>();

private Map<String, String> aliases = new HashMap<>();

@Override

public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {

if (isPublic(access)) {

isPublicClass = true;

className = Type.getObjectType(name).getClassName();

}

super.visit(version, access, name, signature, superName, interfaces);

}

@Override

public FieldVisitor visitField(int access, final String name, String desc, String signature, Object value) {

FieldVisitor fv = super.visitField(access, name, desc, signature, value);

if (isPublicClass && AsmTypes.isPublic(access) && !AsmTypes.isStatic(access)) {

publicFields.put(name, $.T2(desc, signature));

return new FieldVisitor(ASM5, fv) {

private String alias;

@Override

public AnnotationVisitor visitAnnotation(String desc, boolean visible) {

AnnotationVisitor av = super.visitAnnotation(desc, visible);

if (ALIAS_DESC.equals(desc)) {

return new AnnotationVisitor(ASM5, av) {

@Override

public void visit(String name, Object value) {

alias = S.string(value);

}

};

}

return av;

}

@Override

public void visitEnd() {

if (null != alias && S.neq(name, alias)) {

aliases.put(name, alias);

aliases.put(alias, name);

}

super.visitEnd();

}

};

}

return fv;

}

@Override

public void visitEnd() {

if (isPublicClass) {

Act.app().jobManager().on(SysEventId.APP_CODE_SCANNED, new Runnable() {

@Override

public void run() {

SimpleBean.MetaInfoManager metaInfoManager = Act.app().classLoader().simpleBeanInfoManager();

if (metaInfoManager.isSimpleBean(className)) {

MetaInfo metaInfo = new MetaInfo(className, publicFields, aliases);

metaInfoManager.register(metaInfo);

}

}

});

}

super.visitEnd();

}

}

}

class ByteCodeEnhancer extends AppByteCodeEnhancer<ByteCodeEnhancer> {

public static final int PRIORITY = 9;

private MetaInfoManager metaInfoManager;

private ClassInfoRepository classInfoRepository;

private boolean isSimpleBean = false;

private boolean hasPublicFields = false;

private Map<String, $.T2<String, String>> getters = new HashMap<>();

private Map<String, $.T2<String, String>> setters = new HashMap<>();

private boolean needDefaultConstructor = false;

private String classDesc;

private String superClassDesc;

private MetaInfo metaInfo;

private ClassMetaInfoManager<PasswordMetaInfo> passwordMetaInfoManager;

private PasswordMetaInfo passwordMetaInfo;

public ByteCodeEnhancer() {

}

public ByteCodeEnhancer(ClassVisitor cv) {

super(S.F.startsWith("act.").negate(), cv);

}

@Override

protected Class<ByteCodeEnhancer> subClass() {

return ByteCodeEnhancer.class;

}

@Override

public int priority() {

return PRIORITY;

}

@Override

protected void reset() {

this.isSimpleBean = false;

this.hasPublicFields = false;

this.getters.clear();

this.setters.clear();

this.needDefaultConstructor = false;

this.classDesc = null;

this.superClassDesc = null;

this.metaInfo = null;

super.reset();

}

@Override

public AppByteCodeEnhancer app(App app) {

AppClassLoader classLoader = app.classLoader();

classInfoRepository = classLoader.classInfoRepository();

metaInfoManager = classLoader.simpleBeanInfoManager();

passwordMetaInfoManager = app.classMetaInfoManager(PasswordMetaInfo.class);

return super.app(app);

}

@Override

public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {

classDesc = name;

String className = Type.getObjectType(name).getClassName();

passwordMetaInfo = passwordMetaInfoManager.get(className);

isSimpleBean = metaInfoManager.isSimpleBean(className);

if (isSimpleBean) {

needDefaultConstructor = true;

MetaInfo metaInfo = metaInfoManager.get(className);

superClassDesc = superName;

if (null != metaInfo) {

this.metaInfo = metaInfo;

Map<String, $.T2<String, String>> publicFields = metaInfo.publicFields;

if (!publicFields.isEmpty()) {

getters.putAll(publicFields);

setters.putAll(publicFields);

hasPublicFields = true;

} else {

hasPublicFields = false;

}

}

}

super.visit(version, access, name, signature, superName, interfaces);

}

@Override

public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {

MethodVisitor mv = new PropertyAssignMethodVisitor(super.visitMethod(access, name, desc, signature, exceptions), name);

if (!isSimpleBean) {

return mv;

}

if ("<init>".equals(name) && "()V".equals(desc)) {

needDefaultConstructor = false;

}

if (!hasPublicFields) {

return mv;

}

/*

String getter = fieldNameFromGetterSetter(name, true);

if (null != getter) {

// found getter for the field

getters.remove(getter);

getters.remove(metaInfo.aliasOf(getter));

}

String setter = fieldNameFromGetterSetter(name, false);

if (null != setter) {

// found setter for the field

setters.remove(setter);

setters.remove(metaInfo.aliasOf(setter));

}

return mv;

}

private String fieldNameFromGetterSetter(String methodName, boolean getter) {

if (methodName.startsWith(getter ? "get" : "set")) {

String fieldName = methodName.substring(3);

if (!fieldName.isEmpty()) {

char c = fieldName.charAt(0);

if (Character.isUpperCase(c)) {

return ("" + fieldName.charAt(0)).toLowerCase() + fieldName.substring(1);

}

}

}

return getter ? fieldNameFromBooleanGetter(methodName) : null;

}

private String fieldNameFromGetterSetter(String methodName) {

if (methodName.startsWith("get") || methodName.startsWith("set")) {

String fieldName = methodName.substring(3);

if (!fieldName.isEmpty()) {

char c = fieldName.charAt(0);

if (Character.isUpperCase(c)) {

return ("" + fieldName.charAt(0)).toLowerCase() + fieldName.substring(1);

}

}

}

return fieldNameFromBooleanGetter(methodName);

}

private String fieldNameFromBooleanGetter(String methodName) {

if (methodName.startsWith("is")) {

String fieldName = methodName.substring(2);

if (!fieldName.isEmpty()) {

char c = fieldName.charAt(0);

if (Character.isUpperCase(c)) {

return ("" + fieldName.charAt(0)).toLowerCase() + fieldName.substring(1);

}

}

}

return null;

}

@Override

public void visitEnd() {

if (needDefaultConstructor) {

addDefaultConstructor();

}

if (!getters.isEmpty()) {

addGetters();

}

if (!setters.isEmpty()) {

addSetters();

}

super.visitEnd();

}

private void addDefaultConstructor() {

MethodVisitor mv = visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);

mv.visitCode();

mv.visitVarInsn(ALOAD, 0);

mv.visitMethodInsn(INVOKESPECIAL, superClassDesc, "<init>", "()V", false);

mv.visitInsn(RETURN);

mv.visitMaxs(1, 1);

mv.visitEnd();

}

private void addGetters() {

for (Map.Entry<String, $.T2<String, String>> field : C.list(getters.entrySet())) {

addGetter(field);

}

}

private void addSetters() {

for (Map.Entry<String, $.T2<String, String>> field : C.list(setters.entrySet())) {

addSetter(field);

}

}

private void addGetter(Map.Entry<String, $.T2<String, String>> field) {

String name = field.getKey();

if (metaInfo.isSensitive(name)) {

return;

}

String desc = field.getValue()._1;

String signature = field.getValue()._2;

if (null != signature) {

signature = S.concat("()", signature);

}

MethodVisitor mv = visitMethod(ACC_PUBLIC, getterName(name, MetaInfo.isBoolean(desc)), S.concat("()", desc), signature, null);

mv.visitCode();

mv.visitVarInsn(ALOAD, 0);

mv.visitFieldInsn(GETFIELD, classDesc, name, desc);

mv.visitInsn(returnCode(desc));

if (_D == desc.hashCode() || _J == desc.hashCode()) {

mv.visitMaxs(2, 1);

} else {

mv.visitMaxs(1, 1);

}

mv.visitEnd();

}

private void addSetter(Map.Entry<String, $.T2<String, String>> field) {

String name = field.getKey();

if (metaInfo.isSensitive(name) || null != passwordMetaInfo && passwordMetaInfo.isPasswordField(name)) {

return;

}

String desc = field.getValue()._1;

String signature = field.getValue()._2;

if (null != signature) {

signature = S.concat("(", signature, ")V");

}

MethodVisitor mv = visitMethod(ACC_PUBLIC, setterName(name), S.concat("(", desc, ")V"), signature, null);

mv.visitCode();

mv.visitVarInsn(ALOAD, 0);

mv.visitVarInsn(loadCode(desc), 1);

mv.visitFieldInsn(PUTFIELD, classDesc, name, desc);

mv.visitInsn(RETURN);

if (_D == desc.hashCode() || _J == desc.hashCode()) {

mv.visitMaxs(3, 3);

} else {

mv.visitMaxs(2, 2);

}

mv.visitEnd();

}

private String getterName(String fieldName, boolean isBoolean) {

return (isBoolean ? "is" : "get") + S.capFirst(fieldName);

}

private String setterName(String fieldName) {

return "set" + S.capFirst(fieldName);

}

private static final int _I = 'I';

private static final int _Z = 'Z';

private static final int _S = 'S';

private static final int _B = 'B';

private static final int _C = 'C';

private static final int _D = 'D';

private static final int _J = 'J';

private static final int _F = 'F';

private int loadCode(String desc) {

return loadOrReturnCode(desc, true);

}

private int returnCode(String desc) {

return loadOrReturnCode(desc, false);

}

private int loadOrReturnCode(String desc, boolean load) {

switch (desc.hashCode()) {

case _I:

case _Z:

case _S:

case _B:

case _C:

return load ? ILOAD : IRETURN;

case _J:

return load ? LLOAD : LRETURN;

case _D:

return load ? DLOAD : DRETURN;

case _F:

return load ? FLOAD : FRETURN;

default:

return load ? ALOAD : ARETURN;

}

}

private class PropertyAssignMethodVisitor extends MethodVisitor {

private String fieldName;

public PropertyAssignMethodVisitor(MethodVisitor upstream, String name) {

super(ASM5, upstream);

this.fieldName = fieldNameFromGetterSetter(name);

}

@Override

public void visitFieldInsn(int opcode, String owner, String name, String desc) {

if (shouldReplaceWithGetterOrSetter(owner, name)) {

switch (opcode) {

case PUTFIELD:

visitMethodInsn(INVOKEVIRTUAL, owner, setterName(name), "(" + desc + ")V");

break;

case GETFIELD:

visitMethodInsn(INVOKEVIRTUAL, owner, getterName(name, MetaInfo.isBoolean(desc)), "()" + desc);

break;

default:

throw new IllegalStateException("visitFieldInsn opcode not supported: " + opcode);

}

} else {

super.visitFieldInsn(opcode, owner, name, desc);

}

}

private boolean shouldReplaceWithGetterOrSetter(String owner, String name) {

ClassNode node = classInfoRepository.node(owner);

if (null == node || !node.hasInterface(SimpleBean.class.getName())) {

return false;

}

String ownerClass = Type.getObjectType(owner).getClassName();

MetaInfo metaInfo = metaInfoManager.get(ownerClass);

while (true) {

if (null != metaInfo && metaInfo.publicFields.containsKey(name)) {

return !insideGetterSetter(owner, name, metaInfo.aliasOf(name));

}

node = node.parent();

if (null == node) {

return false;

}

metaInfo = metaInfoManager.get(node.name());

}

}

private boolean insideGetterSetter(String owner, String name, String alias) {

return !(null == fieldName || S.neq(classDesc, owner) || (S.neq(fieldName, name) && S.neq(fieldName, alias)));

}

}

}