Example usage for org.apache.commons.bcel6.classfile JavaClass getPackageName

Introduction

In this page you can find the example usage for org.apache.commons.bcel6.classfile JavaClass getPackageName.

Prototype

public String getPackageName() 

Source Link

Usage

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

protected String getInterfacesBlock(JavaClass[] interfaces) {

    if (interfaces == null || interfaces.length == 0)
        return (getJavaClass().isInterface() ? "<" + Constants.OBJC_SYSTEM_CLASS + ">" : "");

    StringBuilder result = new StringBuilder();

    result.append("<");
    result.append(Constants.OBJC_SYSTEM_CLASS);
    result.append(", ");

    for (int i = 0; i < interfaces.length; i++) {
        JavaClass javaInterface = interfaces[i];

        result.append(getPrefix()/*w  w w  .  j av a2  s .  c o  m*/
                + Utils.getShortClassName(javaInterface.getPackageName(), javaInterface.getClassName()));

        if (i + 1 != interfaces.length)
            result.append(", ");
    }

    result.append(">");

    return result.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()));
            }/*from   w w  w  .  j a  v a 2 s . c o 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.InterfaceBuilder.java

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

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

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

        StringBuilder declBuilder = new StringBuilder();

        Method[] methods = javaClass.getMethods();

        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()));
            }//from  ww  w.jav a 2s. c o 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 (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());
        }

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

        String packageName = javaClass.getPackageName();
        String shortClassName = Utils.getShortClassName(packageName, javaClass.getClassName());
        String interfacesBlock = getInterfacesBlock(interfaces);
        String headerImportBlock = getHeaderImportBlock(null, classInterfacesNames, dependencies, false);

        generate(packageName, shortClassName, headerImportBlock, interfacesBlock, declBuilder.toString());
    }
}

---

From source file:ru.objective.jni.tasks.DefaultTask.java

private void parseClass(JavaClass parsedClass) throws Exception {
    if (generatedClasses.indexOf(parsedClass.getClassName()) == -1) {
        generatedClasses.add(parsedClass.getClassName());
    } else {//from   ww  w.j  a v a2  s . c  o  m
        return;
    }

    AbstractBuilder builder = null;

    if (parsedClass.isInterface()) {
        builder = new InterfaceBuilder(parsedClass, prefix, excludes, excludedPackages);
    } else {
        builder = new ClassBuilder(parsedClass, prefix, excludes, excludedPackages);
    }

    JavaClass[] interfaces = builder.getInterfaces();
    JavaClass superClass = builder.getSuperClass();
    HashSet<String> dependencies = builder.getDependencies();

    if (interfaces != null) {
        for (JavaClass javaInterface : interfaces) {
            parseClass(javaInterface);
        }
    }

    if (dependencies != null) {
        for (String dependency : dependencies) {
            parseClass(dependency);
        }
    }

    if (superClass != null) {
        parseClass(superClass);
    }

    String header = builder.getHeader();
    String implementation = builder.getImplementation();

    String packageName = parsedClass.getPackageName();

    generate(packageName, Utils.getShortClassName(packageName, parsedClass.getClassName()), header,
            implementation);
}

---