opptask.java

Java的面向对象数据库系统的源代码

// You can redistribute this software and/or modify it under the terms of
// the Ozone Library License version 1 published by ozone-db.org.
//
//
// $Id: OPPTask.java,v 1.4 2003/11/27 19:34:05 per_nyfelt Exp $
package org.ozoneDB.tools.OPP;

import org.apache.tools.ant.*;
import org.apache.tools.ant.util.LoaderUtils;
import org.apache.tools.ant.types.FileSet;
import org.apache.tools.ant.types.Path;
import org.ozoneDB.tools.OPP.OPPBean;
import org.ozoneDB.tools.OPP.srcgen.ClassDirector;
import org.ozoneDB.tools.OPP.srcgen.ClassBuilder;
import org.ozoneDB.tools.OPP.srcgen.BuilderException;
import org.ozoneDB.tools.OPP.message.MessageWriter;

import java.io.*;
import java.util.StringTokenizer;

public class OPPTask extends Task {
    private FileSet source;
    File output;
    boolean quiet = false;
    private final OPPBean oppBean = new OPPBean();
    private final MessageWriter genListener = new AntLogOPPGenerationeventListener();
    private Path classPath = null;

    public void setClasspath(Path classpath) {
        this.classPath = classpath;
    }

    public Path createClasspath() {
        if (classPath == null) {
            classPath = new Path(project);
        }
        return classPath.createPath();
    }

    public void addConfiguredSource(FileSet source) {
        this.source = source;
    }

    public void setOutput(File output) {
        this.output = output;
    }

    private String convertFileToClassName(String file) {
        if ((file == null) || file.equals(""))
            return "";
        String token;
        StringBuffer className = new StringBuffer();
        for (StringTokenizer st = new StringTokenizer(file, File.separator); st.hasMoreTokens();) {
            token = st.nextToken();
            if (st.hasMoreTokens()) {
                className.append(token + '.');
            } else {
                className.append(token.substring(0, token.lastIndexOf('.')));
            }
        }
        return className.toString();
    }

    private void verifyParameters() {
        if (output == null) {
            output = getProject().getBaseDir();
        }
        if (source == null) {
            throw new BuildException("resolver must be specified");
        }
    }

    public void setCache(boolean cache) {
        oppBean.setCache(cache);
    }

    /* public void setNoDirectInvokes(boolean noDirectInvokes)
     {
       oppBean.setNoDirectInvokes(noDirectInvokes);
     }*/

    public void setUpdateExpression(String updateExpression) {
        oppBean.setUpdateExpression(updateExpression);
    }

    /* public void setIgnorePackageNames(boolean ignorePackageNames)
     {
       oppBean.setIgnorePackageNames(ignorePackageNames);
     }*/

    /*public void setSaveSource(boolean saveSource)
    {
      oppBean.setSaveSource(saveSource);
    } */

    public void setPrintStackTrace(boolean printStackTrace) {
        oppBean.setPrintStackTrace(printStackTrace);
    }

    void setGenerate_ocd(boolean value) {
        oppBean.setGenerateOcd(value);
    }

    void setGenerate_factory(boolean value) {
        oppBean.setGenerateFactory(value);
    }

    void setGenerate_proxy(boolean value) {
        oppBean.setGenerateProxy(value);
    }

    void setUse_ocd(boolean value) {
        oppBean.setUseOcd(value);
    }

    void setUse_source(boolean value) {
        oppBean.setUseSource(value);
    }

    public void execute() throws BuildException {
        oppBean.addGenrationEventListener(genListener);
        verifyParameters();
        DirectoryScanner scanner = source.getDirectoryScanner(project);
        scanner.scan();
        String files[] = scanner.getIncludedFiles();

        ClassDirector cd = oppBean.createDirector(scanner.getBasedir());
        ClassBuilder cb = oppBean.createBuilder(output, "Factory", "_Proxy");

        for (int i = 0; i < files.length; i++) {
            String className = convertFileToClassName(files[i]);
            final ClassLoader loader = getConfiguredClassLoader();
            final ClassLoader oldLoader = LoaderUtils.getContextClassLoader();
            log("Loader is set");
            try {
                LoaderUtils.setContextClassLoader(loader);
                try {

                    log("Begin build");
                    cd.build(className, cb);
                    log("End build");
                } finally {
                    LoaderUtils.setContextClassLoader(oldLoader);
                }
            } catch (BuilderException e) {
                throw new BuildException(e);
            }
        }
    }

    private ClassLoader getConfiguredClassLoader() {
        if (classPath == null) {
            return this.getClass().getClassLoader();
        } else {
            return new AntClassLoader(this.getClass().getClassLoader(), getProject(), classPath, false);
        }
    }

    class AntLogOPPGenerationeventListener implements MessageWriter {
        public void startGeneration(String object) {
            //
        }

        public void error(String message) {
            log(message, Project.MSG_ERR);
        }

        public void warning(String message) {
            log(message, Project.MSG_WARN);
        }

        public void warning(String filename, int row, String message) {
            log(filename + " [" + row + "]: " + message, Project.MSG_WARN);
        }

        public void info(String message) {
            log(message, Project.MSG_INFO);
        }

        public void debug(String message) {
            log(message, Project.MSG_DEBUG);
        }

        public void endGeneration() {
        }
    }
}