proxygenerator.java

用Java写的面相对象的数据库管理系统

            } else {
                out.print( "arg" + i );
            } 
        } 
        out.print( "};\n" );
        
        String sig = OPPHelper.signature( ctor.getParameterTypes() );
        out.print( "         OzoneProxy proxy = link.createObject (\"" + cl.getName() 
                + "_Impl\", OzoneInterface.Public, null, " + sig + ", args);\n" );
        out.print( "         remoteID = proxy.remoteID();\n" );
        out.print( "         }\n" );
        
        //exceptions
        boolean alreadyCatched = false;
        for (int i = 0; i < excs.length; i++) {
            out.print( "      catch (" + excs[i].getName() + " e) {\n" );
            out.print( "         e.fillInStackTrace();\n" );
            out.print( "         throw e; }\n" );
            // out.print ("         throw (" + excs[i].getName() + ")e.fillInStackTrace(); }\n");
            if (excs[i].getName().equals( "java.lang.Exception" )) {
                alreadyCatched = true;
            } 
        } 
        if (!alreadyCatched) {
            out.print( "      catch (Exception e) {\n" );
            if (OPP.printStackTrace) {
                out.print( "         e.printStackTrace (System.out);\n" );
            } 
            out.print( "         e.fillInStackTrace();\n" );
            out.print( "         throw new UnexpectedException (e.toString()); }\n" );
        } 
        out.print( "      }\n" );
    } 
    
    
    public void makeMethods() throws Exception {
        Class[] ifs = cl.getInterfaces();
        for (int i = 0; i < ifs.length; i++) {
            // filter interfaces that are not inherited from a OzoneRemote
            // interface
            if (OzoneRemote.class.isAssignableFrom( ifs[i] )) {
                java.lang.reflect.Method[] methods = ifs[i].getMethods();
                for (int j = 0; j < methods.length; j++) {
                    makeMethod( methods[j] );
                } 
            } 
        } 
    } 
    
    
    public void makeMethod( Method m ) throws Exception {
        
        // string buffer to build the signatur of this method
        StringBuffer signaturBuf = new StringBuffer( "" );
        
        signaturBuf.append( "   public " + typecodeForClass( m.getReturnType() ) + " " + m.getName() + " (" );
        
        //argumente in declaration schreiben
        Class[] args = m.getParameterTypes();
        for (int i = 0; i < args.length; i++) {
            if (i != 0) {
                signaturBuf.append( ", " );
            } 
            signaturBuf.append( typecodeForClass( args[i] ) + " arg" + i );
        } 
        signaturBuf.append( ")" );
        
        String signaturStr = signaturBuf.toString();
        //The getMethods() method returns methods twice, if they are
        //declared in different interfaces. So we have to check if this
        //signatur was already proceeded.
        if (doneMethodsIf.contains( signaturStr )) {
            return;
        } 
        
        out.print( "\n\n" );
        out.print( signaturStr );
        
        //exceptions in declaration schreiben
        Class[] excs = m.getExceptionTypes();
        for (int i = 0; i < excs.length; i++) {
            out.print( i == 0 ? " throws " : ", " );
            out.print( excs[i].getName() );
        } 
        out.print( " {\n" );
        
        //implementation
        out.print( "      try {\n" );
        
        boolean update = OPPHelper.reMatch( re, m.getName() ) || updateMethodsIf.contains( m.getName() );
        String sig = OPPHelper.signature( m.getParameterTypes() );
        if (update && !quiet) {
            System.out.println( "      " + m.getName() + " (" + sig + ")" );
        } 
        
        // code to directly invoke the target method
        if (cache) {
            out.print( "         Object target = link.fetch (this, " + (update 
                    ? "Lock.LEVEL_WRITE" 
                    : "Lock.LEVEL_READ") + ");\n" );
            out.print( "         if (target != null) {\n" );
            
            // convert arguments if needed
            for (int i = 0; i < args.length; i++) {
                if (!args[i].isPrimitive()) {
                    out.print( "            arg" + i + " = (" + typecodeForClass( args[i] ) 
                            + ")ResultConverter.substituteOzoneCompatibles (arg" + i + ");\n" );
                } 
            } 
            
            if (!m.getReturnType().getName().equals( "void" )) {
                if (!m.getReturnType().isPrimitive()) {
                    out.print( "            return (" + typecodeForClass( m.getReturnType() ) 
                            + ")ResultConverter.substituteOzoneCompatibles (((" + cl.getName() + ")target)." 
                            + m.getName() + "(" );
                } else {
                    out.print( "            return ((" + cl.getName() + ")target)." + m.getName() + "(" );
                } 
            } else {
                out.print( "            ((" + cl.getName() + ")target)." + m.getName() + "(" );
            } 
            
            for (int i = 0; i < args.length; i++) {
                out.print( i > 0 ? ", " : "" );
                out.print( "arg" + i );
            } 
            if (!m.getReturnType().getName().equals( "void" )) {
                if (!m.getReturnType().isPrimitive()) {
                    out.print( ")" );
                } 
            } 
            out.print( ");\n" );
            out.print( "            }\n" );
            out.print( "         else {\n" );
        } 
        
        //array of arguments
        out.print( "            Object[] args = {" );
        for (int i = 0; i < args.length; i++) {
            out.print( i > 0 ? ", " : "" );
            if (args[i].isPrimitive()) {
                out.print( "new " + OPPHelper.wrappercodeForPrimitive( args[i] ) + "(arg" + i + ")" );
            } else {
                out.print( "arg" + i );
            } 
        } 
        out.print( "};\n" );
        
        out.print( "            Object result = link.invoke (this, " + OPPHelper.methodArrayIndex( methods,
                m ) + ", args, " + (update
                ? "Lock.LEVEL_WRITE" 
                : "Lock.LEVEL_READ") + ");\n" );
        // out.print ("         result = link.invoke (this, \"" + m.getName() + "\", " + sig + ", args, " + (update ? "Lock.LEVEL_WRITE" : "Lock.LEVEL_READ") + ");\n");
        
        // return value
        if (!m.getReturnType().getName().equals( "void" )) {
            if (m.getReturnType().isPrimitive()) {
                out.print( "            return " + OPPHelper.returncodeForPrimitive( m.getReturnType(),
                        "result" ) + ";\n" );
            } else {
                out.print( "            return (" + typecodeForClass( m.getReturnType() ) + ")result;\n" );
            } 
        } 
        
        if (cache) {
            out.print( "            }\n" );
        } 
        
        out.print( "         }\n" );
        
        // user defined exceptions
        boolean excAlreadyCatched = false;
        boolean rtAlreadyCatched = false;
        for (int i = 0; i < excs.length; i++) {
            out.print( "      catch (" + excs[i].getName() + " e) {\n" );
            if (OPP.printStackTrace) {
                out.print( "         e.printStackTrace (System.out);\n" );
            } 
            out.print( "         e.fillInStackTrace();\n" );
            out.print( "         throw e;\n" );
            out.print( "         }\n" );
            // out.print ("         throw (" + excs[i].getName() + ")e.fillInStackTrace(); }\n");
            
            if (excs[i].getName().equals( "java.lang.Exception" )) {
                excAlreadyCatched = true;
            } 
            if (excs[i].getName().equals( "java.lang.RuntimeException" )) {
                rtAlreadyCatched = true;
            } 
        } 
        
        // runtime exceptions
        if (!rtAlreadyCatched && !excAlreadyCatched) {
            out.print( "      catch (RuntimeException e) {\n" );
            if (OPP.printStackTrace) {
                out.print( "         e.printStackTrace (System.out);\n" );
            } 
            out.print( "         e.fillInStackTrace();\n" );
            out.print( "         throw e;\n" );
            out.print( "         }\n" );
        } 
        
        // all exceptions left
        if (!excAlreadyCatched) {
            out.print( "      catch (Exception e) {\n" );
            if (OPP.printStackTrace) {
                out.print( "         e.printStackTrace (System.out);\n" );
            } 
            out.print( "         e.fillInStackTrace();\n" );
            out.print( "         throw new UnexpectedException (e.toString());\n" );
            out.print( "         }\n" );
        } 
        
        out.print( "      }\n" );
        
        // save proceeded methods
        doneMethodsIf.addForKey( signaturStr, signaturStr );
    } 
    
    
    /**
     * Gives the Java source code for the type of the specified class.
     */
    protected String typecodeForClass( Class cl ) throws Exception {
        String name = cl.getName();
        String ret = "";
        
        //      // primitive type
        //      if (name.length() == 1) {
        //         // throw new Exception ("Primitive types are not allowed as argument or return type!");
        //          ret = typecodeForPrimitive (name.charAt(0));
        //          }
        //
        //      // array of references
        //      else  if (name.startsWith("[L"))
        //          ret = name.substring (2, name.length() - 1) + "[]";
        //
        //      // array of primitive types
        //      else  if (name.startsWith("["))
        //          ret = typecodeForPrimitive(name.charAt(1)) + "[]";
        
        // array
        if (cl.isArray()) {
            while (cl.isArray()) {
                ret = ret + "[]";
                cl = cl.getComponentType();
            } 
            ret = cl.getName() + ret;
        } else {
            
            // normal reference and primitive types
            ret = name;
        } 
        return ret;
    } 
    
}