oppbean.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: OPPBean.java,v 1.4.2.1 2004/01/11 20:42:34 per_nyfelt Exp $
package org.ozoneDB.tools.OPP;

import org.ozoneDB.tools.OPP.srcgen.ClassBuilder;
import org.ozoneDB.tools.OPP.srcgen.ClassDirector;
import org.ozoneDB.tools.OPP.srcgen.builder.*;
import org.ozoneDB.tools.OPP.srcgen.builder.CompositeBuilder;
import org.ozoneDB.tools.OPP.srcgen.builder.FactoryBuilder;
import org.ozoneDB.tools.OPP.srcgen.builder.MethodNameUpgradingClassBuilderDecorator;
import org.ozoneDB.tools.OPP.srcgen.builder.OcdBuilder;
import org.ozoneDB.tools.OPP.srcgen.query.ReflectionClassQuery;
import org.ozoneDB.tools.OPP.srcgen.streamfactory.InputStreamFactory;
import org.ozoneDB.tools.OPP.srcgen.streamfactory.FileInputStreamFactory;
import org.ozoneDB.tools.OPP.srcgen.streamfactory.OutputStreamFactory;
import org.ozoneDB.tools.OPP.srcgen.streamfactory.FileOutputStreamFactory;
import org.ozoneDB.tools.OPP.srcgen.direct.ReflectionClassDirector;
import org.ozoneDB.tools.OPP.srcgen.resolve.ClassDescriptorUpdateMethodResolver;
import org.ozoneDB.tools.OPP.srcgen.resolve.CompositeMethodResolver;
import org.ozoneDB.tools.OPP.srcgen.resolve.SourceUpdateMethodResolver;
import org.ozoneDB.tools.OPP.message.CompositeOPPMessageListener;
import org.ozoneDB.tools.OPP.message.MessageWriter;
import org.ozoneDB.tools.OPP.message.SummaryMessageWriterDecorator;

import java.io.*;

/**
 * API for running the OPP code. This class makes it simplier to JUnit test
 * the ant task by being able to testrun the opp functionality without having
 * the ant environment running.<br/>
 *
 * The OPP bean does not have all the functionality that the OPP command line
 * tool does.<br/>
 * <list>
 * <li>The OPPBean does not support compiling proxies or factories</li>
 * <li>The OPPBean does not support odmg postprocessing because the current
 * implementation implies compilation </li>
 *
 * Date: 2003-sep-09
 * Time: 19:53:47
 * @author Joakim Ohlrogge
 */
public class OPPBean {
    private boolean printStackTrace = false;
    private String updateExpression = ".*_update";
    private boolean cache = true;
    private CompositeOPPMessageListener compListener = new CompositeOPPMessageListener();
    private SummaryMessageWriterDecorator summaryListenerDecorator;
    private boolean useOcd = true;
    private boolean useSource = true;
    private boolean generateFactory = true;
    private boolean generateProxy = true;
    private boolean generateOcd = false;

    public OPPBean() {
        summaryListenerDecorator = new SummaryMessageWriterDecorator(compListener);
    }

    public boolean isUseOcd() {
        return useOcd;
    }

    public void setUseOcd(boolean useOcd) {
        this.useOcd = useOcd;
    }

    public boolean isUseSource() {
        return useSource;
    }

    public void setUseSource(boolean useSource) {
        this.useSource = useSource;
    }

    public boolean isGenerateFactory() {
        return generateFactory;
    }

    public void setGenerateFactory(boolean generateFactory) {
        this.generateFactory = generateFactory;
    }

    public boolean isGenerateProxy() {
        return generateProxy;
    }

    public void setGenerateProxy(boolean generateProxy) {
        this.generateProxy = generateProxy;
    }

    public boolean isGenerateOcd() {
        return generateOcd;
    }

    public void setGenerateOcd(boolean generateOcd) {
        this.generateOcd = generateOcd;
    }

    private MessageWriter getSummaryListener() {
        return summaryListenerDecorator;
    }

    public void setCache(boolean cache) {
        this.cache = cache;
    }

    public void setUpdateExpression(String updateExpression) {
        this.updateExpression = updateExpression;
    }

    public void setPrintStackTrace(boolean printStackTrace) {
        this.printStackTrace = printStackTrace;
    }

    public ClassDirector createDirector(InputStreamFactory source, InputStreamFactory ocdsource) {
        CompositeMethodResolver resolver = new CompositeMethodResolver();
        if (source != null) {
            resolver.addResolver(new SourceUpdateMethodResolver(source, getSummaryListener(), new ReflectionClassQuery()));
        }
        if (ocdsource != null) {
            resolver.addResolver(new ClassDescriptorUpdateMethodResolver(ocdsource, getSummaryListener()));
        }
        return new ReflectionClassDirector(getSummaryListener(), resolver);
    }

    /**
     * Creates a class direct for the class identified by the class string.
     * The method resolvers are created based on the value of getUseOcd and getUseSource.
     */
    public ClassDirector createDirector(File sourceDir) {
        InputStreamFactory ocdFactory = null;
        InputStreamFactory sourceFactory = null;
        if (useOcd) {
            ocdFactory = new FileInputStreamFactory(sourceDir, "ocd");
        }
        if (useSource) {
            sourceFactory = new FileInputStreamFactory(sourceDir, "java");
        }
        return createDirector(sourceFactory, ocdFactory);
    }

    public ClassBuilder createBuilder(OutputStreamFactory factory, String factoryPost, OutputStreamFactory proxy, String proxyPost, OutputStreamFactory ocd) {
        CompositeBuilder builder = new CompositeBuilder();
        if (factory != null) {
            builder.addBuilder(new FactoryBuilder(factory, factoryPost));
        }
        if (proxy != null) {
            ClassBuilder proxyBuilder = new ProxyBuilder(proxy, proxyPost, printStackTrace, cache, getSummaryListener());
            // Allow promotion of methods
            MethodNameUpgradingClassBuilderDecorator decorator =
                    new MethodNameUpgradingClassBuilderDecorator(proxyBuilder, updateExpression);
            builder.addBuilder(decorator);
        }
        if (ocd != null) {
            builder.addBuilder(new OcdBuilder(ocd));
        }
        return builder;
    }

    public ClassBuilder createBuilder(File outputDir, String factoryPost, String proxyPost) {
        OutputStreamFactory factoryOsFactory = null;
        OutputStreamFactory proxyOsFactory = null;
        OutputStreamFactory ocdOsFactory = null;
        if (generateFactory) {
            factoryOsFactory = new FileOutputStreamFactory(outputDir, "java");
        }
        if (generateProxy) {
            proxyOsFactory = new FileOutputStreamFactory(outputDir, "java");
        }
        if (generateOcd) {
            ocdOsFactory = new FileOutputStreamFactory(outputDir, "ocd");
        }
        return createBuilder(factoryOsFactory, factoryPost, proxyOsFactory, proxyPost, ocdOsFactory);
    }

    public void addGenrationEventListener(MessageWriter listener) {
        compListener.addListener(listener);
    }

    public void removeGenrationEventListener(MessageWriter listener) {
        compListener.removeListener(listener);
    }
}