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-@year@ by SMB GmbH. All rights reserved.
//
// $Id: OPPHelper.java,v 1.10 2003/11/27 19:30:05 per_nyfelt Exp $
package org.ozoneDB.tools.OPP;

//import org.ozoneDB.DxLib.DxIterator;
//import org.ozoneDB.DxLib.DxTreeSet;

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.HashMap;
import java.util.Map;
import java.io.File;

/**
 * @author <a href="http://www.softwarebuero.de/">SMB</a>
 * @version $Revision: 1.10 $Date: 2003/11/27 19:30:05 $
 */
public class OPPHelper {
    /** @deprecated use org.ozoneDB.core.helper.ReflectionHelper.SIGNATUR_DELIMETER instead
     *  @see org.ozoneDB.core.helper.ReflectionHelper
     */
    public final static String SIGNATURE_DELIMITER = "|";
    private static Map primitives;

    static {
        primitives = new HashMap();
        primitives.put("byte", Byte.TYPE);
        primitives.put("char", Character.TYPE);
        primitives.put("double", Double.TYPE);
        primitives.put("float", Float.TYPE);
        primitives.put("int", Integer.TYPE);
        primitives.put("long", Long.TYPE);
        primitives.put("short", Short.TYPE);
        primitives.put("boolean", Boolean.TYPE);
    }

    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 name = cl.getName();
        return wrappercodeForPrimitive(name);
    }

    public static String wrappercodeForPrimitive(String name) /*throws Exception*/ {
        String ret;
        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;
    }

    /**
     * Checks weather a string representing a build type is a primitive.
     * By using this method in builders and directors we don't need to have access
     * to the classes that the strings represent. This is useful when the direct
     * is not using reflection but rather parsing the build resolver.
     * @param typeName The name of the type to be checked
     * @return true if the typeName represents a primitive
     */
    public static boolean isPrimitive(String typeName) {
        return primitives.keySet().contains(typeName);
    }

    /**
     * For all primitive types in implementationClass return a string like '<varName>.intValue()'.
     */
    public static String returncodeForPrimitive(Class cl, String varName) {
        String name = cl.getName();
        return returncodeForPrimitive(name, varName);
    }

    /**
     * For all primitive types in implementationClass return a string like '<varName>.intValue()'.
     */
    public static String returncodeForPrimitive(String name, String varName) {
        String ret;
        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 IllegalArgumentException("unknown type: '" + name + "'");
        }
        return ret;
    }

    public static String packageName(Class c) {
        String name = c.getName();
        return OPPHelper.packageName(name);
    }

    public static String packageName(String name) {
        int index = name.lastIndexOf('.');
        return index != -1 ? name.substring(0, index) : "";
    }

    public static String simpleClassName(Class c) {
        return simpleClassName(c.getName());
    }

    public static String simpleClassName(String name) {
        int index = name.lastIndexOf('.');
        return index != -1 ? name.substring(index + 1) : name;
    }

    public static String classFileBasename(Class c) {
        return classFileBasename(c.getName());
    }

    public static String classFileBasename(String name) {
        return classFileBasename(name, File.separatorChar);
    }

    public static String classFileBasename(String name, char separator) {
        return name.replace('.', separator);
    }


    public static Pattern newRE(String s, boolean ignoreCase) {
        return ignoreCase ? Pattern.compile(s, Pattern.CASE_INSENSITIVE) : Pattern.compile(s);
    }

    public static boolean reMatch(Object re, String s) {
        Pattern pattern = (Pattern) re;
        //System.out.println("[OPPHelper] - Pattern is " + pattern.pattern());
        Matcher matcher = pattern.matcher(s);
        return matcher.matches();
    }

    public static String reSearch(Object re, String s, int start, int paren) {
        Pattern pattern = (Pattern) re;
        Matcher matcher = pattern.matcher(s);
        if (matcher.find(start)) {
            return matcher.group(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));
    }

    public static Class classForPrimitive(String type) {
        return (Class) primitives.get(type);
    }
}