ocdbuilder.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.
//
// The original code and portions created by SMB are
// Copyright (C) 1997-@year@ by SMB GmbH. All rights reserved.
//
// $Id$
package org.ozoneDB.tools.OPP.srcgen.builder;

import org.ozoneDB.tools.OPP.castor.*;
import org.ozoneDB.tools.OPP.OPPHelper;
import org.ozoneDB.tools.OPP.message.MessageWriter;
import org.ozoneDB.tools.OPP.srcgen.BuilderException;
import org.ozoneDB.tools.OPP.srcgen.ClassBuilder;
import org.ozoneDB.tools.OPP.srcgen.streamfactory.OutputStreamFactory;
import org.ozoneDB.core.Lock;
import org.exolab.castor.xml.Marshaller;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.ValidationException;

import java.lang.reflect.Modifier;
import java.io.*;

/**
 * A builder that builds OCD:s
 * @author Joakim Ohlrogge
 *
 * To change this template use Options | File Templates.
 */
public class OcdBuilder implements ClassBuilder {
    private Writer wr;
    private OzoneClassDescriptor ocd;
    private OutputStreamFactory osf;
    private MessageWriter msgWriter;

    public OcdBuilder(OutputStreamFactory osf) {
        this.osf = osf;
    }

    public void init(MessageWriter msgWriter) {
        this.msgWriter = msgWriter;
    }

    public void beginClass(int modifer, String fullName, String superClass, String interfaces[]) throws BuilderException {
        msgWriter.startGeneration("Generating OCD for " + fullName);
        try {
            wr = new PrintWriter(osf.newInstance(fullName));
        } catch (IOException e) {
            throw new BuilderException(e);
        }
        ocd = new OzoneClassDescriptor();
        Constructors ctrs = new Constructors();
        Methods mthds = new Methods();
        ocd.setConstructors(ctrs);
        ocd.setMethods(mthds);
        if (superClass != null) {
            ocd.setSuperclass(superClass);
        }
        ocd.setName(OPPHelper.simpleClassName(fullName));
        ocd.setPackage(OPPHelper.packageName(fullName));
        if (interfaces != null) {
            for (int i = 0; i < interfaces.length; ++i) {
                ocd.addInterface(interfaces[i]);
            }
        }
    }

    public void makeConstructor(int modifier, ClassBuilder.Parameter parameters[], String exceptions[]) {
        if (Modifier.isPublic(modifier)) {
            PublicConstructor constructor = new PublicConstructor();
            if (parameters != null) {
                for (int i = 0; i < parameters.length; ++i) {
                    constructor.addParameter(parameters[i].getType());
                }
            }
            ocd.getConstructors().addPublicConstructor(constructor);
        }
    }

    public void makeMethod(int modifier, String name, ClassBuilder.Parameter parameters[], String returnType, String exceptions[], int lockLevel) throws BuilderException {
        if (Modifier.isPublic(modifier)) {
            PublicMethod method = new PublicMethod();
            method.setName(name);
            switch (lockLevel) {
                case Lock.LEVEL_NONE:
                    method.setLocklevel("NONE");
                    break;
                case Lock.LEVEL_MAX:
                    method.setLocklevel("MAX");
                    break;
                case Lock.LEVEL_READ:
                    method.setLocklevel("READ");
                    break;
                case Lock.LEVEL_UPGRADE:
                    method.setLocklevel("UPGRADE");
                    break;
                case Lock.LEVEL_WRITE:
                    method.setLocklevel("WRITE");
                    break;
                default:
                    throw new BuilderException("Unsupported lock level for method " + name + " level=" + lockLevel + ".");
            }
            if (parameters != null) {
                for (int i = 0; i < parameters.length; ++i) {
                    method.addParameter(parameters[i].getOrigTypeName());
                }
            }
            ocd.getMethods().addPublicMethod(method);
        }
    }

    public void endClass() throws BuilderException {
        try {
            Marshaller.marshal(ocd, wr);
        } catch (MarshalException e) {
            msgWriter.endGeneration();
            throw new BuilderException(e);
        } catch (ValidationException e) {
            msgWriter.endGeneration();
            throw new BuilderException(e);
        } finally {
            msgWriter.endGeneration();
        }
    }
}