Example usage for org.apache.commons.bcel6.generic Type toString

List of usage examples for org.apache.commons.bcel6.generic Type toString

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.bcel6.generic.*
  5. Type
  6. toString

Introduction

In this page you can find the example usage for org.apache.commons.bcel6.generic Type toString.

Prototype

@Override
public String toString()

Source Link

Usage

From source file:ru.objective.jni.tasks.builders.AbstractBuilder.java

protected String getHeaderDeclarationMethod(MethodExportInfo info, Method method, boolean overloaded) {
    StringBuilder stringBuilder = new StringBuilder();
    String[] argumentTypes = Utility.methodSignatureArgumentTypes(method.getSignature());
    String name = info.name;/*w ww .  j  av a  2s .c  o m*/

    String methodReturnType = null;

    if (Utils.isConstructor(method)) {
        methodReturnType = "instancetype";

        if (name.equals("<init>"))
            name = "init";
    } else {
        if (Utils.isOccupiedWord(name)) {
            name = "_" + name;
        }

        methodReturnType = Utility.methodSignatureReturnType(method.getSignature()).toString();

        methodReturnType = Utils.getBasicType(methodReturnType);

        if (!Utils.isPrimitive(method.getReturnType())) {
            JavaClass typeJavaClass = OJNIClassLoader.getInstance()
                    .loadClass(method.getReturnType().toString());

            if (typeJavaClass != null && typeJavaClass.isInterface())
                methodReturnType = "id <" + getPrefix() + Utils.getShortClassName(methodReturnType) + ">";
            else
                methodReturnType = getPrefix() + Utils.getShortClassName(methodReturnType) + " *";
        }

        if (Utils.isArrayType(method.getReturnType()))
            methodReturnType = getStringArrayType(methodReturnType, (ArrayType) method.getReturnType());
        else
            methodReturnType = PrimitiveTypeConverter.convertToOBJCType(methodReturnType);
    }
    stringBuilder.append((method.isStatic() ? "+" : "-") + " " + "("
            + PrimitiveTypeConverter.convertToOBJCType(methodReturnType) + ")");

    String[] nameParameters = name.split(":");

    if (info.isCustom)
        overloaded = false;

    LocalVariableTable table = method.getLocalVariableTable();

    if (argumentTypes.length == 0)
        stringBuilder.append(name);

    for (int i = 0, var_index = (method.isStatic() ? 0 : 1); i < argumentTypes.length; i++, var_index++) {
        Type javaType = method.getArgumentTypes()[i];
        String type = argumentTypes[i];

        String variable_name = "";
        if (table == null) {
            variable_name = "arg" + var_index;
        } else {
            LocalVariable lv = table.getLocalVariable(var_index, 0);
            if (lv != null) {
                variable_name = lv.getName();
            }
        }

        if (javaType.equals(Type.LONG) || javaType.equals(Type.DOUBLE))
            var_index++;

        String nameParameter = (i < nameParameters.length ? nameParameters[i] : variable_name);

        type = Utils.getBasicType(type);

        String overloadedParameter = "";

        if (overloaded) {
            overloadedParameter = "With" + (i == 0 ? StringUtils.capitalize(variable_name) : "")
                    + Utils.getShortClassName(type);/*+ StringUtils.capitalize(utils.getShortClassName(type));*/
        }

        if (!Utils.isPrimitive(javaType)) {
            JavaClass argTypeJavaClass = OJNIClassLoader.getInstance().loadClass(javaType.toString());

            if (argTypeJavaClass != null && argTypeJavaClass.isInterface())
                type = "id <" + getPrefix() + Utils.getShortClassName(type) + ">";
            else
                type = getPrefix() + Utils.getShortClassName(type) + " *";
        }

        if (Utils.isArrayType(javaType)) {
            if (overloaded) {
                int dimensions = ((ArrayType) javaType).getDimensions();

                if (dimensions > 1)
                    overloadedParameter += dimensions + "dimArray";
                else
                    overloadedParameter += "Array";
            }
            type = getStringArrayType(type, (ArrayType) javaType);
        } else {
            type = PrimitiveTypeConverter.convertToOBJCType(type);
        }

        if (Utils.isOccupiedWord(variable_name)) {
            variable_name = "_" + variable_name;
        }

        stringBuilder.append(nameParameter + overloadedParameter + ":(" + type + ")" + variable_name + " ");
    }

    stringBuilder.append(";");

    return stringBuilder.toString();
}

From source file:ru.objective.jni.tasks.builders.ClassBuilder.java

@Override
protected void build(JavaClass javaClass) throws Exception {

    if (javaClass.isInterface())
        throw new BadParsingException("Cannot build class from interface " + javaClass.toString());

    if (Utils.isExportClass(javaClass, excludes, excludedPackages)) {

        StringBuilder declBuilder = new StringBuilder();
        StringBuilder implBuilder = new StringBuilder();

        Method[] methods = javaClass.getMethods();
        Field[] fields = javaClass.getFields();

        JavaClass[] interfaces = getInterfaces();
        String[] classInterfacesNames = null;

        if (interfaces != null) {
            ArrayList<String> resultInterfaces = new ArrayList<>(interfaces.length);

            for (JavaClass javaInterface : interfaces) {
                resultInterfaces.add(Utils.getShortClassName(javaInterface.getClassName()));
            }/*w  w  w .  j av  a  2  s.co  m*/

            if (resultInterfaces.size() > 0) {
                classInterfacesNames = new String[resultInterfaces.size()];

                resultInterfaces.toArray(classInterfacesNames);
            }
        }

        HashSet<String> methodDependencies = new HashSet<>();

        HashSet<Method> overloadedMethods = Utils.getOverloadedMethods(methods);

        for (Field field : fields) {
            // skip field if excluded
            if (Utils.isClassNameExcluded(field.getType().toString(), excludes, excludedPackages))
                continue;

            String fieldName = Utils.getFieldExportName(field);

            if (fieldName == null)
                continue;

            Type basicFieldType = Utils.basicTypeFromArrayType(field.getType());

            if (!Utils.isPrimitive(basicFieldType))
                methodDependencies.add(basicFieldType.toString());

            String declgetter = getHeaderDeclarationField(fieldName, field, false);
            String declsetter = getHeaderDeclarationField(fieldName, field, true);
            declBuilder.append(declgetter);
            declBuilder.append(System.lineSeparator());
            declBuilder.append(declsetter);
            declBuilder.append(System.lineSeparator());

            String implgetter = getFieldImplementation(field, declgetter, false);
            String implsetter = getFieldImplementation(field, declsetter, true);
            implBuilder.append(implgetter);
            implBuilder.append(System.lineSeparator());
            implBuilder.append(implsetter);
            implBuilder.append(System.lineSeparator());
        }

        for (Method method : methods) {

            MethodExportInfo info = Utils.getMethodExportInfo(method);
            String name = info.name;

            if (name == null)
                continue;

            ArrayList<String> deps = Utils.getMethodNonPrimitiveDependencies(method);

            if (deps != null) {
                boolean found = false;
                for (String dependency : deps) {
                    // skip method if excluded
                    if (Utils.isClassNameExcluded(dependency, excludes, excludedPackages)) {
                        found = true;
                        break;
                    }
                }
                if (found)
                    continue;

                methodDependencies.addAll(deps);
            }

            String decl = getHeaderDeclarationMethod(info, method, overloadedMethods.contains(method));
            declBuilder.append(decl);
            declBuilder.append(System.lineSeparator());

            String impl = getMethodImplementation(method, decl);
            implBuilder.append(impl);
            implBuilder.append(System.lineSeparator());
        }

        // add core string methods decls
        if (getJavaClass().getClassName().equals("java.lang.String")) {
            declBuilder.append("- (instancetype)initWithNSString:(NSString *)string;")
                    .append(System.lineSeparator())
                    .append("+ (instancetype)stringWithNSString:(NSString *)string;")
                    .append(System.lineSeparator()).append("- (NSString *)toNSString;")
                    .append(System.lineSeparator());
        }

        if (methodDependencies.size() > 0) {
            dependencies = methodDependencies;
        }

        String packageName = javaClass.getPackageName();
        String shortClassName = Utils.getShortClassName(packageName, javaClass.getClassName());

        String superClassName = Constants.OBJC_SYSTEM_CLASS;
        String headerImportBlock = "";
        String interfacesBlock = (interfaces != null ? getInterfacesBlock(interfaces) : "");

        JavaClass superClass = getSuperClass();

        if (superClass != null && Utils.isExportClass(superClass, excludes, excludedPackages)) {
            superClassName = superClass.getClassName();
        }

        headerImportBlock = getHeaderImportBlock(superClassName, classInterfacesNames, dependencies, false);

        String implImportBlock = "";
        if (headerImportBlock != null && !headerImportBlock.equals(""))
            implImportBlock = getHeaderImportBlock(superClassName, classInterfacesNames, dependencies, true);

        implBuilder.append(getOJNIMethodsImplementations());

        generate(packageName, shortClassName, interfacesBlock, Utils.getShortClassName(superClassName),
                headerImportBlock, declBuilder.toString(), "", implBuilder.toString(), implImportBlock);
    }
}

From source file:ru.objective.jni.tasks.builders.ClassBuilder.java

private String getFieldImplementation(Field field, String declaration, boolean setter) {
    StringBuilder builder = new StringBuilder();

    if (setter && field.isFinal())
        return "";

    builder.append(declaration).append(" {").append(System.lineSeparator());

    builder.append("OJNIEnv *__env = [OJNIEnv currentEnv];").append(System.lineSeparator());
    builder.append("jfieldID fid = [[OJNIMidManager sharedManager] fieldIDFor");
    if (field.isStatic())
        builder.append("Static");
    builder.append("Method:@\"" + field.getName() + "\" ");
    builder.append("signature:@\"" + field.getSignature() + "\" inClass:self.class];");
    builder.append(System.lineSeparator());

    Type returnType = field.getType();
    String lowerCaseReturnType = (Utils.isPrimitive(returnType) && !Utils.isArrayType(returnType)
            ? returnType.toString()
            : "object");
    String capitalized = StringUtils.capitalize(lowerCaseReturnType);

    String staticIdentifier = "";
    String selfIdentitifer = "[self javaObject]";

    if (field.isStatic()) {
        staticIdentifier = "Static";
        selfIdentitifer = "[self.class OJNIClass]";
    }//  w w w .  j a  va2  s  .c  om

    if (setter) { // setter
        builder.append("[__env set").append(staticIdentifier).append(capitalized).append("Field:")
                .append(selfIdentitifer).append(" field:fid value:");

        String var_name = "property_" + field.getName();

        if (Utils.isArrayType(returnType)) {
            ArrayType arrayType = (ArrayType) returnType;
            int dimensions = arrayType.getDimensions();
            String typeString = arrayType.getBasicType().toString();
            String capitalizedType = StringUtils.capitalize(typeString);

            // fix Boolean = Bool conflicts
            if (capitalizedType.equals("Bool"))
                capitalizedType = "Boolean";

            if (arrayType.getDimensions() == 1 && Utils.isPrimitive(arrayType)) {
                builder.append("[__env newJava").append(capitalizedType).append("ArrayFromArray:")
                        .append(var_name).append("]");
            } else {
                if (Utils.isPrimitive(arrayType)) {
                    builder.append("[__env newJavaObjectArrayFromArray:").append(var_name)
                            .append(" baseClass:[OJNIPrimitive").append(capitalizedType).append("Array class]")
                            .append(" dimensions:").append(dimensions).append("]");

                } else {
                    JavaClass argTypeJavaClass = OJNIClassLoader.getInstance().loadClass(typeString);

                    String resultClassString = "";
                    if (argTypeJavaClass != null && argTypeJavaClass.isInterface())
                        resultClassString = "@\"" + Utils.getSlashedClassName(typeString) + "\"";
                    else
                        resultClassString = "[" + getPrefix() + Utils.getShortClassName(typeString) + " class]";

                    builder.append("[__env newJavaObjectArrayFromArray:").append(var_name).append(" baseClass:")
                            .append(resultClassString).append(" dimensions:").append(dimensions).append("]");
                }
            }
        } else {
            if (Utils.isPrimitive(returnType)) {
                builder.append(var_name);
            } else {
                builder.append("[").append(var_name).append(" javaObject]");
            }
        }
        builder.append("];");
    } else { // getter
        builder.append("j").append(lowerCaseReturnType).append(" __obj = ").append("[__env get")
                .append(staticIdentifier).append(capitalized).append("Field:").append(selfIdentitifer)
                .append(" field:fid];").append(System.lineSeparator());

        builder.append(generateReturnObject(field.getType()));
    }

    builder.append(System.lineSeparator()).append("}");

    return builder.toString();
}

From source file:ru.objective.jni.tasks.builders.ClassBuilder.java

public String generateCallMethod(Method method, String vars) {
    StringBuilder builder = new StringBuilder();

    Type returnType = method.getReturnType();

    if (Utils.isArrayType(returnType) || !Utils.isPrimitive(returnType)) {
        if (method.isStatic())
            builder.append("jobject __obj = [__env callStaticObject");
        else//  ww  w . j a va2  s  .c  o m
            builder.append("jobject __obj = [__env callObject");
    } else {
        builder.append("j").append(returnType.toString()).append(" __obj = [__env call");
        if (method.isStatic())
            builder.append("Static");
        builder.append(StringUtils.capitalize(returnType.toString()));

    }

    if (method.isStatic())
        builder.append("MethodOnClass:[self.class OJNIClass] method:mid");
    else
        builder.append("MethodOnObject:[self javaObject] method:mid");

    builder.append(vars).append("];").append(System.lineSeparator());

    return builder.toString();
}

From source file:ru.objective.jni.tasks.builders.ClassBuilder.java

public String generateReturnObject(Type returnType) {
    StringBuilder builder = new StringBuilder();

    if (Utils.isArrayType(returnType)) {
        ArrayType arrReturnType = (ArrayType) returnType;
        int dimensions = arrReturnType.getDimensions();
        String capitalizedType = StringUtils.capitalize(arrReturnType.getBasicType().toString());

        // fix Boolean = Bool conflicts
        if (capitalizedType.equals("Bool"))
            capitalizedType = "Boolean";

        if (Utils.isPrimitive(arrReturnType)) {
            if (dimensions == 1) {
                builder.append("OJNIPrimitiveArray *__return = ");
                builder.append("[__env primitive").append(capitalizedType).append("ArrayFromJavaArray:__obj];");
            } else {
                builder.append("NSArray *__return = ");
                builder.append("[__env newArrayFromJavaObjectArray:__obj baseClass:[OJNIPrimitive")
                        .append(capitalizedType).append("Array class] classPrefix:@\"").append(getPrefix())
                        .append("\" dimensions:").append(dimensions).append("];");
            }/*w  w w.  j  a  v  a2 s.  c o m*/
        } else {
            builder.append("NSArray *__return = ");
            builder.append(
                    "[__env newArrayFromJavaObjectArray:__obj baseClass:[OJNIJavaObject class] classPrefix:@\"")
                    .append(getPrefix()).append("\" dimensions:").append(dimensions).append("];");
        }
    } else {
        if (Utils.isPrimitive(returnType)) {
            builder.append(PrimitiveTypeConverter.convertToOBJCType(returnType.toString()))
                    .append(" __return = ");
            builder.append("__obj;");
        } else {
            builder.append("id __return = ");
            builder.append("[OJNIJavaObject retrieveFromJavaObject:__obj classPrefix:@\"").append(getPrefix())
                    .append("\"];");
        }
    }

    builder.append(System.lineSeparator()).append("return __return;");

    return builder.toString();
}

From source file:ru.objective.jni.utils.Utils.java

public static ArrayList<String> getMethodNonPrimitiveDependencies(Method method) {
    Type returnType = basicTypeFromArrayType(method.getReturnType());
    Type[] argumentTypes = method.getArgumentTypes();

    ArrayList<String> dependencies = new ArrayList<>();

    for (Type argumentType : argumentTypes) {
        argumentType = basicTypeFromArrayType(argumentType);
        if (!isPrimitive(argumentType)) {
            dependencies.add(argumentType.toString());
        }/*from   ww  w .j ava  2 s  . c  o  m*/
    }

    if (!isPrimitive(returnType))
        dependencies.add(returnType.toString());

    if (dependencies.size() == 0)
        return null;

    return dependencies;
}