opphelper.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-2000 by SMB GmbH. All rights reserved.
//
// $Id: OPPHelper.java,v 1.8 2000/10/28 16:55:20 daniela Exp $

package org.ozoneDB.tools.OPP;

import java.lang.reflect.*;
import org.apache.regexp.*;
import org.ozoneDB.core.*;
import org.ozoneDB.DxLib.*;


/**
 * @author <a href="http://www.softwarebuero.de/">SMB</a>
 * @version $Revision: 1.8 $Date: 2000/10/28 16:55:20 $
 */
public class OPPHelper {
    
    
    public static void progressMsg( String msg, boolean quiet ) {
        if (!quiet) {
            System.out.println( msg );
        } 
    } 
    
    
    public static void warnMsg( String filename, int line, String msg ) {
        System.out.println( filename + ":" + line + ": warning: " + msg + "." );
    } 
    
    
    public static void warnMsg( Class cl, String msg ) {
        System.out.println( cl.getName() + ": warning:" + msg );
    } 
    
    
    public static void error( String filename, int line, String msg ) {
        System.out.println( filename + ":" + line + ": error: " + msg );
        System.exit( 1 );
    } 
    
    
    public static void error( Class cl, String msg ) {
        System.out.println( cl.getName() + ": error:" + msg );
        System.exit( 1 );
    } 
    
    
    public static String typecodeForPrimitive( char ch ) throws Exception {
        String ret;
        switch (ch) {
        case 'B':
            ret = "byte";
            break;
        case 'C':
            ret = "char";
            break;
        case 'D':
            ret = "double";
            break;
        case 'F':
            ret = "float";
            break;
        case 'I':
            ret = "int";
            break;
        case 'J':
            ret = "long";
            break;
        case 'S':
            ret = "short";
            break;
        case 'Z':
            ret = "boolean";
            break;
        default:
            throw new Exception( "Unknown type code '" + ch + "'." );
        }
        return ret;
    } 
    
    
    public static String wrappercodeForPrimitive( Class cl ) throws Exception {
        String ret;
        String name = cl.getName();
        if (name.equals( "int" )) {
            ret = "Integer";
        } else if (name.equals( "char" )) {
            ret = "Character";
        } else {
            ret = name.substring( 0, 1 ).toUpperCase() + name.substring( 1 );
        } 
        return ret;
    } 
    
    
    /**
     * For all primitive types in cl return a string like '<varName>.intValue()'.
     */
    public static String returncodeForPrimitive( Class cl, String varName ) throws Exception {
        String ret;
        String name = cl.getName();
        if (name.equals( "int" )) {
            ret = "((Integer)" + varName + ").intValue()";
        } else if (name.equals( "boolean" )) {
            ret = "((Boolean)" + varName + ").booleanValue()";
        } else if (name.equals( "char" )) {
            ret = "((Character)" + varName + ").charValue()";
        } else if (name.equals( "long" )) {
            ret = "((Long)" + varName + ").longValue()";
        } else if (name.equals( "float" )) {
            ret = "((Float)" + varName + ").floatValue()";
        } else if (name.equals( "double" )) {
            ret = "((Double)" + varName + ").doubleValue()";
        } else if (name.equals( "byte" )) {
            ret = "((Byte)" + varName + ").byteValue()";
        } else if (name.equals( "short" )) {
            ret = "((Short)" + varName + ").shortValue()";
        } else {
            throw new Exception( "unknown type: '" + name + "'" );
        } 
        return ret;
    } 
    
    
    public static String signature( Class[] args ) {
        String result = new String();
        for (int i = 0; i < args.length; i++) {
            result = i > 0 ? result + OPP.SIGNATURE_DELIMITER : result;
            result = result + args[i].getName();
        } 
        return "\"" + result + "\"";
    } 
    
    
    public static String packageName( Class c ) {
        String name = c.getName();
        int index = name.lastIndexOf( '.' );
        return index != -1 ? name.substring( 0, index ) : "";
    } 
    
    
    public static String rawClassName( Class c ) {
        return rawClassName( c.getName() );
    } 
    
    
    public static String rawClassName( String name ) {
        int index = name.lastIndexOf( '.' );
        return index != -1 ? name.substring( index + 1 ) : name;
    } 
    
    
    /**
     * Returns the array index of the specified method within the array
     * of methods of this class.
     */
    public static int methodArrayIndex( Method[] methods, Method m ) {
        String mName = m.getName();
        String mSig = OPPHelper.signature( m.getParameterTypes() );
        
        for (int i = 0; i < methods.length; i++) {
            String cName = methods[i].getName();
            String cSig = OPPHelper.signature( methods[i].getParameterTypes() );
            if (mName.equals( cName ) && mSig.equals( cSig )) {
                return i;
            } 
        } 
        throw new RuntimeException( m + ": Unable to find method in class." );
    } 
    
    
    public static Method[] methodsOfClass( Class cl ) {
        Method[] methods = cl.getMethods();
        
        DxTreeSet set = new DxTreeSet();
        
        for (int i = 0; i < methods.length; i++) {
            String name = methods[i].getName();
            String sig = OPPHelper.signature( methods[i].getParameterTypes() );
            set.add( new MethodKey( cl.getName(), name, sig, methods[i] ) );
        } 
        
        DxIterator it = set.iterator();
        for (int i = 0; it.next() != null; i++) {
            MethodKey key = (MethodKey)it.object();
            methods[i] = key.method();
        } 
        return methods;
    } 
    
    
    public static Object newRE( String s, boolean ignoreCase ) throws Exception {
        int flags = ignoreCase ? RE.MATCH_CASEINDEPENDENT : RE.MATCH_NORMAL;
        return new RE( s, flags );
    } 
    
    
    public static boolean reMatch( Object re, String s ) {
        return ((RE)re).match( s );
    } 
    
    
    //   public static int reSearch (Object re, String s, int start) {
    //       for (int i=start; i < s.length(); i++) {
    //           if (((RE)re).match (s, i))
    //               return i;
    //           }
    //       return -1;
    //       }
    
    
    public static String reSearch( Object re, String s, int start, int paren ) {
        for (int i = start; i < s.length(); i++) {
            if (((RE)re).match( s, i )) {
                return ((RE)re).getParen( paren );
            } 
        } 
        return null;
    } 
    
    
    public static void main( String[] av ) throws Exception {
        System.out.println( av[0] );
        
        Object re = newRE( av[0], false );
        System.out.println( reSearch( re, av[1], 0, 0 ) );
    } 
    
}