generator.java

MobilerRPC enables remote procedure calls between J2ME applications and java sevlet server.

        for(Element constantElement = DOMUtils.getFirstNamedChildElement(element, "constant");
                constantElement != null;
                constantElement = DOMUtils.getNextNamedSiblingElement(constantElement, "constant"))
        {
            constants.add(loadConstant(constantElement));
        }

        // Load methods
        ArrayList methods = new ArrayList();
        for(Element methodElement = DOMUtils.getFirstNamedChildElement(element, "method");
            methodElement != null;
            methodElement = DOMUtils.getNextNamedSiblingElement(methodElement, "method"))
        {
            String methodName = DOMUtils.getAttributeValue(methodElement, "name");
            if(methodName == null)
                throw new InterfaceDefinitionException("Method name not defined.");
            String returnTypeName = DOMUtils.getAttributeValue(methodElement, "returnType");
            // Load return type
            Attribute returnTypeAttr = null;
            if(returnTypeName != null)
            {
                Type returnType = (Type) types.get(returnTypeName);
                if(returnType == null)
                    throw new InterfaceDefinitionException("Return type for method " + methodName +
                            " of interface " + interfaceName + " not found.");
                boolean isArray = methodElement.getAttribute("array").equals("true");
                returnTypeAttr = new Attribute(null, returnType, isArray);
            }
            // Load parameters
            ArrayList parameters = new ArrayList();
            for(Element parameterElement = DOMUtils.getFirstNamedChildElement(methodElement, "parameter");
                parameterElement != null;
                parameterElement = DOMUtils.getNextNamedSiblingElement(parameterElement, "parameter"))
            {
                String parameterName = DOMUtils.getAttributeValue(parameterElement, "name");
                if(parameterName == null)
                    throw new InterfaceDefinitionException("Parameter name for method " + methodName +
                            " in interface " + interfaceName + " not defined.");
                Type parameterType = (Type) types.get(parameterElement.getAttribute("type"));
                if(parameterType == null)
                    throw new InterfaceDefinitionException("Type for parameter " + parameterName + " of method " +
                            methodName + " in interface " + interfaceName + " not found.");
                boolean isArray = parameterElement.getAttribute("array").equals("true");
                parameters.add(new Attribute(parameterName, parameterType, isArray));
            }

            // Load methodExceptions
            ArrayList methodExceptions = new ArrayList();
            String exceptionsString = DOMUtils.getAttributeValue(methodElement, "throws");
            if(exceptionsString != null)
            {
                StringTokenizer st = new StringTokenizer(exceptionsString, ", ", false);
                while(st.hasMoreTokens())
                {
                    String exceptionName = st.nextToken();
                    ExceptionDescription exceptionDescription = (ExceptionDescription) exceptions.get(exceptionName);
                    if(exceptionDescription == null)
                        throw new InterfaceDefinitionException("Exception with name " + exceptionName + " not found.");
                    methodExceptions.add(exceptionDescription);
                }
            }

            Method method = new Method(methodName,
                    returnTypeAttr,
                    (Attribute[]) parameters.toArray(new Attribute[parameters.size()]),
                    (ExceptionDescription[]) methodExceptions.toArray(new ExceptionDescription[methodExceptions.size()]));
            methods.add(method);
        }
        if(methods.size() == 0)
            throw new InterfaceDefinitionException("No method specified for " + interfaceName + " interface.");
        InterfaceDescription interfaceDescription = new InterfaceDescription(interfaceName,
                commonPackageName,
                supportCookie,
                (Method[])methods.toArray(new Method[methods.size()]),
                (Constant[])constants.toArray(new Constant[constants.size()]));
        interfaces.put(interfaceDescription.getName(), interfaceDescription);
    }

    private Constant loadConstant(Element node) throws InterfaceDefinitionException
    {
        String constantName = DOMUtils.getAttributeValue(node, "name");
        if(constantName == null)
            throw new InterfaceDefinitionException("Constant name not defined.");
        Type type = (Type)types.get(node.getAttribute("type"));
        if(type == null)
            throw new InterfaceDefinitionException("Type not found for constant " + constantName + ".");
        boolean isArray = node.getAttribute("array").equals("true");
        String attributeValue = DOMUtils.getAttributeValue(node, "value");
        String elementValue = DOMUtils.getChildElementValue(node, "value");
        if(attributeValue == null && elementValue == null)
            throw new InterfaceDefinitionException("Constant value not defined for constant " + constantName + ".");
        String value = attributeValue != null ? attributeValue : elementValue;
        return new Constant(constantName, type, isArray, value);
    }

    private void addType(Type type)
    {
        types.put(type.getName(), type);
    }

    public void generateFiles() throws IOException
    {
        // Generate structs
        String commonPackagePath = commonPackageName.replace('.', '/');
        File serverCommonPackage = new File(serverDir, commonPackagePath);
        serverCommonPackage.mkdirs();
        File j2meCommonPackage = new File(j2meDir, commonPackagePath);
        j2meCommonPackage.mkdirs();
        Iterator i = structs.values().iterator();
        while(i.hasNext())
        {
            Struct struct = (Struct) i.next();
            File serverFile = new File(serverCommonPackage, struct.getName() + ".java");
            IndentPrintStream file = new IndentPrintStream(new PrintStream(new FileOutputStream(serverFile)));
            struct.generateFile(file);
            file.close();
            File j2meFile = new File(j2meCommonPackage, struct.getName() + ".java");
            file = new IndentPrintStream(new PrintStream(new FileOutputStream(j2meFile)));
            struct.generateFile(file);
            file.close();
        }

        // Generate exceptions
        i = exceptions.values().iterator();
        while(i.hasNext())
        {
            ExceptionDescription exception = (ExceptionDescription) i.next();
            File serverFile = new File(serverCommonPackage, exception.getName() + ".java");
            IndentPrintStream file = new IndentPrintStream(new PrintStream(new FileOutputStream(serverFile)));
            exception.generateFile(file);
            file.close();
            File j2meFile = new File(j2meCommonPackage, exception.getName() + ".java");
            file = new IndentPrintStream(new PrintStream(new FileOutputStream(j2meFile)));
            exception.generateFile(file);
            file.close();
        }

        // Generate interface files
        String serverPackagePath = serverPackageName.replace('.', '/');
        File serverPackageFile = new File(serverDir, serverPackagePath);
        serverPackageFile.mkdirs();
        String j2mePackagePath = j2mePackageName.replace('.', '/');
        File j2mePackageFile = new File(j2meDir, j2mePackagePath);
        j2mePackageFile.mkdirs();
        i = interfaces.values().iterator();
        while(i.hasNext())
        {
            InterfaceDescription interfaceDescription = (InterfaceDescription) i.next();
            File serverFile = new File(serverPackageFile, interfaceDescription.getName() + ".java");
            IndentPrintStream file = new IndentPrintStream(new PrintStream(new FileOutputStream(serverFile)));
            interfaceDescription.generateServerFile(file, serverPackageName);
            file.close();
            File j2meFile = new File(j2mePackageFile, interfaceDescription.getName() + ".java");
            file = new IndentPrintStream(new PrintStream(new FileOutputStream(j2meFile)));
            interfaceDescription.generateJ2MEFile(file, j2mePackageName);
            file.close();
        }

        // Generate java files
        copyFile("DecodeInputStream.txt", "DecodeInputStream.java", serverPackageFile, j2mePackageFile);
        copyFile("EncodeOutputStream.txt", "EncodeOutputStream.java", serverPackageFile, j2mePackageFile);

        // Generate utils file
        UtilsGenerator utilsGenerator = new UtilsGenerator(commonPackageName);
        // Server file
//        File serverUtilFile = new File(serverPackageFile, "Utils.java");
//        IndentPrintStream stream = new IndentPrintStream(new PrintStream(new FileOutputStream(serverUtilFile)));
//        utilsGenerator.generateServerFile(stream, serverPackageName);
//        stream.close();
        // J2ME file
        File j2meUtilFile = new File(j2mePackageFile, "Utils.java");
        IndentPrintStream stream = new IndentPrintStream(new PrintStream(new FileOutputStream(j2meUtilFile)));
        utilsGenerator.generateJ2MEFile(stream, j2mePackageName);
        stream.close();
    }

    private void copyFile(String srcName, String destName, File serverPackage, File j2mePackage) throws IOException
    {
        FileOutputStream serverFile = new FileOutputStream(new File(serverPackage, destName));
        serverFile.write(("package " + serverPackageName + ";\n\n" + FILE_HEADER + "\n\n").getBytes());
        copyResources(srcName, serverFile);
        serverFile.flush();
        serverFile.close();

        FileOutputStream j2meFile = new FileOutputStream(new File(j2mePackage, destName));
        j2meFile.write(("package " + j2mePackageName + ";\n\n" + FILE_HEADER + "\n\n").getBytes());
        copyResources(srcName, j2meFile);
        j2meFile.flush();
        j2meFile.close();
    }

    private void copyResources(String resourceName, OutputStream out) throws IOException
    {
        InputStream resourceInput = null;
        try
        {
            resourceInput = getClass().getResourceAsStream("resources/" + resourceName);
            byte[] buffer = new byte[1024];
            int length = 0;
            while((length = resourceInput.read(buffer)) >= 0)
            {
                out.write(buffer, 0, length);
            }
        }
        finally
        {
            try { resourceInput.close(); } catch(Exception e) {}
        }
    }
}