svnno****@sourc*****
svnno****@sourc*****
2009年 4月 3日 (金) 16:01:54 JST
Revision: 3079
http://svn.sourceforge.jp/view?root=jiemamy&view=rev&rev=3079
Author: j5ik2o
Date: 2009-04-03 16:01:54 +0900 (Fri, 03 Apr 2009)
Log Message:
-----------
ユーティリティクラスを追加しました。
Added Paths:
-----------
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassLoaderUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassTraversal.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/CollectionsUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/EnumerationIterator.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FieldUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileInputStreamUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileOutputStreamUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/GenericUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/InputStreamUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarFileUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarInputStreamUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarURLConnectionUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/MethodUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/OutputStreamUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ReflectionUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceBundleUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceTraversal.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourcesUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/URLUtil.java
charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ZipFileUtil.java
-------------- next part --------------
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassLoaderUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassLoaderUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassLoaderUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,255 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.util.Enumeration;
+import java.util.Iterator;
+
+import org.jiemamy.composer.importer.exception.ClassNotFoundRuntimeException;
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link ClassLoader}を扱うためのユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public class ClassLoaderUtil {
+
+ private static final Method FIND_LOADED_CLASS_METHOD = getFindLoadedClassMethod();
+
+ private static final Method DEFINE_CLASS_METHOD = getDefineClassMethod();
+
+ private static final Method DEFINE_PACKAGE_METHOD = getDefinePackageMethod();
+
+
+ /**
+ * バイトの配列を<code>Class</code>クラスのインスタンスに変換する。
+ *
+ * @param classLoader バイナリデータから<code>Class</code>クラスのインスタンスに変換するクラスローダ
+ * @param className クラスのバイナリ名
+ * @param bytes クラスデータを構成するバイト列
+ * @param offset クラスデータ<code>bytes</code>の開始オフセット
+ * @param length クラスデータの長さ
+ * @return 指定されたクラスデータから作成された<code>Class</code>オブジェクト
+ */
+ public static Class<?> defineClass(final ClassLoader classLoader, final String className, final byte[] bytes,
+ final int offset, final int length) {
+ return (Class<?>) MethodUtil.invoke(DEFINE_CLASS_METHOD, classLoader, new Object[] {
+ className,
+ bytes,
+ Integer.valueOf(offset),
+ Integer.valueOf(length)
+ });
+ }
+
+ /**
+ * 指定の<code>ClassLoader</code>で名前を使ってパッケージを定義する。
+ *
+ * @param classLoader パッケージを定義するクラスローダ
+ * @param name パッケージ名
+ * @param specTitle 仕様のタイトル
+ * @param specVersion 仕様のバージョン
+ * @param specVendor 仕様のベンダー
+ * @param implTitle 実装のタイトル
+ * @param implVersion 実装のバージョン
+ * @param implVendor 実装のベンダー
+ * @param sealBase <code>null</code>でない場合、このパッケージは指定されたコードソース<code>URL</code>オブジェクトを考慮してシールされる。そうでない場合、パッケージはシールされない
+ * @return 新しく定義された<code>Package</code>オブジェクト
+ */
+ public static Package definePackage(final ClassLoader classLoader, final String name, final String specTitle,
+ final String specVersion, final String specVendor, final String implTitle, final String implVersion,
+ final String implVendor, final URL sealBase) {
+ return (Package) MethodUtil.invoke(DEFINE_PACKAGE_METHOD, classLoader, new Object[] {
+ name,
+ specTitle,
+ specVersion,
+ specVendor,
+ implTitle,
+ implVersion,
+ implVendor,
+ sealBase
+ });
+ }
+
+ /**
+ * 指定のクラスローダまたはその祖先のクラスローダが、 このバイナリ名を持つクラスの起動ローダとしてJava仮想マシンにより記録されていた場合は、
+ * 指定されたバイナリ名を持つクラスを取得する。 記録されていなかった場合は<code>null</code>を取得する。
+ *
+ * @param classLoader クラスローダ
+ * @param className クラスのバイナリ名
+ * @return <code>Class</code>オブジェクト。クラスがロードされていない場合は<code>null</code>
+ */
+ public static Class<?> findLoadedClass(final ClassLoader classLoader, final String className) {
+ for (ClassLoader loader = classLoader; loader != null; loader = loader.getParent()) {
+ final Class<?> clazz = (Class<?>) MethodUtil.invoke(FIND_LOADED_CLASS_METHOD, loader, new Object[] {
+ className
+ });
+ if (clazz != null) {
+ return clazz;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * クラスローダを取得する。
+ *
+ * @param targetClass ターゲット・クラス
+ * @return クラスローダ
+ */
+ public static ClassLoader getClassLoader(final Class<?> targetClass) {
+ final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+ if (contextClassLoader != null) {
+ return contextClassLoader;
+ }
+
+ final ClassLoader targetClassLoader = targetClass.getClassLoader();
+ final ClassLoader thisClassLoader = ClassLoaderUtil.class.getClassLoader();
+ if (targetClassLoader != null && thisClassLoader != null) {
+ if (isAncestor(thisClassLoader, targetClassLoader)) {
+ return thisClassLoader;
+ }
+ return targetClassLoader;
+ }
+ if (targetClassLoader != null) {
+ return targetClassLoader;
+ }
+ if (thisClassLoader != null) {
+ return thisClassLoader;
+ }
+
+ final ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
+ if (systemClassLoader != null) {
+ return systemClassLoader;
+ }
+
+ throw new IllegalStateException();
+ }
+
+ private static Method getDefineClassMethod() {
+ final Method method = ClassUtil.getDeclaredMethod(ClassLoader.class, "defineClass", new Class[] {
+ String.class,
+ byte[].class,
+ int.class,
+ int.class
+ });
+ method.setAccessible(true);
+ return method;
+ }
+
+ private static Method getDefinePackageMethod() {
+ final Method method = ClassUtil.getDeclaredMethod(ClassLoader.class, "definePackage", new Class[] {
+ String.class,
+ String.class,
+ String.class,
+ String.class,
+ String.class,
+ String.class,
+ String.class,
+ URL.class
+ });
+ method.setAccessible(true);
+ return method;
+ }
+
+ private static Method getFindLoadedClassMethod() {
+ final Method method = ClassUtil.getDeclaredMethod(ClassLoader.class, "findLoadedClass", new Class[] {
+ String.class
+ });
+ method.setAccessible(true);
+ return method;
+ }
+
+ /**
+ * {@link #getClassLoader(Class)}が返すクラスローダから指定された名前を持つすべてのリソースを検索する。
+ *
+ * @param targetClass ターゲット・クラス
+ * @param name リソース名
+ * @return リソースに対するURL。オブジェクトの列挙。リソースが見つからなかった場合、列挙は空になる。クラスローダがアクセスを持たないリソースは列挙に入らない
+ * @see java.lang.ClassLoader#getResources(String)
+ */
+ public static Iterator<?> getResources(final Class<?> targetClass, final String name) {
+ return getResources(getClassLoader(targetClass), name);
+ }
+
+ /**
+ * 指定のクラスローダから指定された名前を持つすべてのリソースを検索する。
+ *
+ * @param loader クラスローダ
+ * @param name リソース名
+ * @return リソースに対するURL。オブジェクトの列挙。リソースが見つからなかった場合、列挙は空になる。クラスローダがアクセスを持たないリソースは列挙に入らない
+ */
+ public static Iterator<URL> getResources(final ClassLoader loader, final String name) {
+ try {
+ final Enumeration<URL> e = loader.getResources(name);
+ return new EnumerationIterator<URL>(e);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * コンテキストクラスローダから指定された名前を持つすべてのリソースを検索する。
+ *
+ * @param name リソース名
+ * @return リソースに対するURL。オブジェクトの列挙。リソースが見つからなかった場合、列挙は空になる。クラスローダがアクセスを持たないリソースは列挙に入らない
+ */
+ public static Iterator<URL> getResources(final String name) {
+ return getResources(Thread.currentThread().getContextClassLoader(), name);
+ }
+
+ /**
+ * クラスローダ<code>other</code>がクラスローダ<code>cl</code>の祖先なら<code>true</code>を取得する。
+ *
+ * @param cl クラスローダ
+ * @param other クラスローダ
+ * @return クラスローダ<code>other</code>がクラスローダ<code>cl</code>の祖先なら<code>true</code>
+ */
+ protected static boolean isAncestor(ClassLoader cl, final ClassLoader other) {
+ while (cl != null) {
+ if (cl == other) {
+ return true;
+ }
+ cl = cl.getParent();
+ }
+ return false;
+ }
+
+ /**
+ * 指定されたバイナリ名を持つクラスをロードする。
+ *
+ * @param loader クラスローダ
+ * @param className クラスのバイナリ名
+ * @return 結果の<code>Class</code>オブジェクト
+ * @throws ClassNotFoundRuntimeException クラスが見つからなかった場合
+ */
+ public static Class<?> loadClass(final ClassLoader loader, final String className) {
+ try {
+ return loader.loadClass(className);
+ } catch (final ClassNotFoundException e) {
+ throw new ClassNotFoundRuntimeException(e);
+ }
+ }
+
+ private ClassLoaderUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassLoaderUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassTraversal.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassTraversal.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassTraversal.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+/**
+ * クラスを横断して処理するためのハンドらクラス。
+ *
+ * @author j5ik2o
+ */
+public class ClassTraversal {
+
+ /**
+ * クラスを横断して処理するためのハンドラインターフェイス。
+ *
+ */
+ public interface ClassHandler {
+
+ /**
+ * クラスを処理する。
+ *
+ * @param packageName パッケージ名
+ * @param shortClassName クラス名
+ */
+ void processClass(String packageName, String shortClassName);
+ }
+
+
+ private static final String CLASS_SUFFIX = ".class";
+
+ private static final String WAR_FILE_EXTENSION = ".war";
+
+ private static final String WEB_INF_CLASSES_PATH = "WEB-INF/classes/";
+
+
+ /**
+ * rootディレクトリ配下を処理します。
+ *
+ * @param rootDir ルートディレクトリ
+ * @param handler ハンドラ
+ */
+ public static void forEach(final File rootDir, final ClassHandler handler) {
+ forEach(rootDir, null, handler);
+ }
+
+ /**
+ * rootディレクトリ配下でrootパッケージ名配下を処理します。
+ *
+ * @param rootDir ルートディレクトリ
+ * @param rootPackage ルートパッケージ
+ * @param handler ハンドラ
+ */
+ public static void forEach(final File rootDir, final String rootPackage, final ClassHandler handler) {
+ final File packageDir = getPackageDir(rootDir, rootPackage);
+ if (packageDir.exists()) {
+ traverseFileSystem(packageDir, rootPackage, handler);
+ }
+ }
+
+ /**
+ * 指定されたjarファイルを処理します。
+ *
+ * @param jarFile Jarファイル
+ * @param handler ハンドラ
+ */
+ public static void forEach(final JarFile jarFile, final ClassHandler handler) {
+ final boolean hasWarExtension = jarFile.getName().endsWith(WAR_FILE_EXTENSION);
+ final Enumeration<JarEntry> enumeration = jarFile.entries();
+ while (enumeration.hasMoreElements()) {
+ final JarEntry entry = enumeration.nextElement();
+ final String entryName = entry.getName().replace('\\', '/');
+ if (entryName.endsWith(CLASS_SUFFIX)) {
+ final int startPos =
+ hasWarExtension && entryName.startsWith(WEB_INF_CLASSES_PATH) ? WEB_INF_CLASSES_PATH.length()
+ : 0;
+ final String className =
+ entryName.substring(startPos, entryName.length() - CLASS_SUFFIX.length()).replace('/', '.');
+ final int pos = className.lastIndexOf('.');
+ final String packageName = (pos == -1) ? null : className.substring(0, pos);
+ final String shortClassName = (pos == -1) ? className : className.substring(pos + 1);
+ handler.processClass(packageName, shortClassName);
+ }
+ }
+ }
+
+ private static File getPackageDir(final File rootDir, final String rootPackage) {
+ File packageDir = rootDir;
+ if (rootPackage != null) {
+ final String[] names = rootPackage.split("\\.");
+ for (String name : names) {
+ packageDir = new File(packageDir, name);
+ }
+ }
+ return packageDir;
+ }
+
+ private static void traverseFileSystem(final File dir, final String packageName, final ClassHandler handler) {
+ final File[] files = dir.listFiles();
+ for (int i = 0; i < files.length; ++i) {
+ final File file = files[i];
+ final String fileName = file.getName();
+ if (file.isDirectory()) {
+ traverseFileSystem(file, ClassUtil.concatName(packageName, fileName), handler);
+ } else if (fileName.endsWith(".class")) {
+ final String shortClassName = fileName.substring(0, fileName.length() - CLASS_SUFFIX.length());
+ handler.processClass(packageName, shortClassName);
+ }
+ }
+ }
+
+ private ClassTraversal() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassTraversal.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,459 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.lang.StringUtils;
+
+import org.jiemamy.composer.importer.exception.ClassNotFoundRuntimeException;
+import org.jiemamy.composer.importer.exception.IllegalAccessRuntimeException;
+import org.jiemamy.composer.importer.exception.InstantiationRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchConstructorRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchFieldRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchMethodRuntimeException;
+
+/**
+ * {@link Class}用のユーティリティクラスです。
+ *
+ * @author j5ik2o
+ *
+ */
+public class ClassUtil {
+
+ private static Map<Class<?>, Class<?>> wrapperToPrimitiveMap = new HashMap<Class<?>, Class<?>>();
+
+ private static Map<Class<?>, Class<?>> primitiveToWrapperMap = new HashMap<Class<?>, Class<?>>();
+
+ private static Map<String, Class<?>> primitiveClsssNameMap = new HashMap<String, Class<?>>();
+
+ static {
+ wrapperToPrimitiveMap.put(Character.class, Character.TYPE);
+ wrapperToPrimitiveMap.put(Byte.class, Byte.TYPE);
+ wrapperToPrimitiveMap.put(Short.class, Short.TYPE);
+ wrapperToPrimitiveMap.put(Integer.class, Integer.TYPE);
+ wrapperToPrimitiveMap.put(Long.class, Long.TYPE);
+ wrapperToPrimitiveMap.put(Double.class, Double.TYPE);
+ wrapperToPrimitiveMap.put(Float.class, Float.TYPE);
+ wrapperToPrimitiveMap.put(Boolean.class, Boolean.TYPE);
+
+ primitiveToWrapperMap.put(Character.TYPE, Character.class);
+ primitiveToWrapperMap.put(Byte.TYPE, Byte.class);
+ primitiveToWrapperMap.put(Short.TYPE, Short.class);
+ primitiveToWrapperMap.put(Integer.TYPE, Integer.class);
+ primitiveToWrapperMap.put(Long.TYPE, Long.class);
+ primitiveToWrapperMap.put(Double.TYPE, Double.class);
+ primitiveToWrapperMap.put(Float.TYPE, Float.class);
+ primitiveToWrapperMap.put(Boolean.TYPE, Boolean.class);
+
+ primitiveClsssNameMap.put(Character.TYPE.getName(), Character.TYPE);
+ primitiveClsssNameMap.put(Byte.TYPE.getName(), Byte.TYPE);
+ primitiveClsssNameMap.put(Short.TYPE.getName(), Short.TYPE);
+ primitiveClsssNameMap.put(Integer.TYPE.getName(), Integer.TYPE);
+ primitiveClsssNameMap.put(Long.TYPE.getName(), Long.TYPE);
+ primitiveClsssNameMap.put(Double.TYPE.getName(), Double.TYPE);
+ primitiveClsssNameMap.put(Float.TYPE.getName(), Float.TYPE);
+ primitiveClsssNameMap.put(Boolean.TYPE.getName(), Boolean.TYPE);
+ }
+
+
+ /**
+ * クラス名の要素を結合する。
+ *
+ * @param s1 パッケージ名
+ * @param s2 パッケージ名もしくはクラス名
+ * @return 結合された名前
+ */
+ public static String concatName(String s1, String s2) {
+ if (StringUtils.isEmpty(s1) && StringUtils.isEmpty(s2)) {
+ return null;
+ }
+ if (!StringUtils.isEmpty(s1) && StringUtils.isEmpty(s2)) {
+ return s1;
+ }
+ if (StringUtils.isEmpty(s1) && !StringUtils.isEmpty(s2)) {
+ return s2;
+ }
+ return s1 + '.' + s2;
+ }
+
+ /**
+ * プリミティブクラスの場合は、ラッパークラスに変換する。
+ *
+ * @param className クラス名
+ * @return {@link Class}
+ * @throws ClassNotFoundRuntimeException {@link ClassNotFoundException}がおきた場合
+ * @see #forName(String)
+ */
+ public static Class<?> convertClass(String className) throws ClassNotFoundRuntimeException {
+ Class<?> clazz = primitiveClsssNameMap.get(className);
+ if (clazz != null) {
+ return clazz;
+ }
+ return forName(className);
+ }
+
+ /**
+ * {@link Class}を取得する。
+ *
+ * @param className クラス名
+ * @return {@link Class}
+ * @throws ClassNotFoundRuntimeException {@link ClassNotFoundException}がおきた場合
+ * @see Class#forName(String)
+ */
+ public static Class<?> forName(String className) throws ClassNotFoundRuntimeException {
+
+ ClassLoader loader = Thread.currentThread().getContextClassLoader();
+ try {
+ return Class.forName(className, true, loader);
+ } catch (ClassNotFoundException ex) {
+ throw new ClassNotFoundRuntimeException(className, ex);
+ }
+ }
+
+ /**
+ * {@link Constructor}を返します。
+ *
+ * @param clazz クラス
+ * @param argTypes 引数
+ * @return {@link Constructor}
+ * @throws NoSuchConstructorRuntimeException {@link NoSuchMethodException}がおきた場合
+ * @see Class#getConstructor(Class[])
+ */
+ public static Constructor<?> getConstructor(Class<?> clazz, Class<?>[] argTypes)
+ throws NoSuchConstructorRuntimeException {
+ try {
+ return clazz.getConstructor(argTypes);
+ } catch (NoSuchMethodException ex) {
+ throw new NoSuchConstructorRuntimeException(clazz, argTypes, ex);
+ }
+ }
+
+ /**
+ * そのクラスに宣言されている {@link Constructor}を取得する。
+ *
+ * @param clazz クラス
+ * @param argTypes 引数
+ * @return {@link Constructor}
+ * @throws NoSuchConstructorRuntimeException {@link NoSuchMethodException}がおきた場合
+ * @see Class#getDeclaredConstructor(Class[])
+ */
+ public static Constructor<?> getDeclaredConstructor(Class<?> clazz, Class<?>[] argTypes)
+ throws NoSuchConstructorRuntimeException {
+ try {
+ return clazz.getDeclaredConstructor(argTypes);
+ } catch (NoSuchMethodException ex) {
+ throw new NoSuchConstructorRuntimeException(clazz, argTypes, ex);
+ }
+ }
+
+ /**
+ * そのクラスに宣言されている {@link Field}を取得する。
+ *
+ * @param clazz クラス
+ * @param fieldName フィールド名
+ * @return {@link Field}
+ * @throws NoSuchFieldRuntimeException {@link NoSuchFieldException}がおきた場合
+ * @see Class#getDeclaredField(String)
+ */
+ public static Field getDeclaredField(Class<?> clazz, String fieldName) throws NoSuchFieldRuntimeException {
+ try {
+ return clazz.getDeclaredField(fieldName);
+ } catch (NoSuchFieldException ex) {
+ throw new NoSuchFieldRuntimeException(clazz, fieldName, ex);
+ }
+ }
+
+ /**
+ * このクラスに定義された{@link Field フィールド}をクラスファイルに定義された順番で取得する。
+ *
+ * @param clazz
+ * 対象のクラス
+ * @return このクラスに定義されたフィールドの配列
+ */
+// public static Field[] getDeclaredFields(final Class clazz) {
+// final ClassPool pool = ClassPoolUtil.getClassPool(clazz);
+// final CtClass ctClass = ClassPoolUtil.toCtClass(pool, clazz);
+// final CtField[] ctFields = ctClass.getDeclaredFields();
+// final int size = ctFields.length;
+// final Field[] fields = new Field[size];
+// for (int i = 0; i < size; ++i) {
+// fields[i] = ClassUtil.getDeclaredField(clazz, ctFields[i].getName());
+// }
+// return fields;
+// }
+ /**
+ * そのクラスに宣言されている {@link Method}を取得する。
+ *
+ * @param clazz クラス
+ * @param methodName メソッド名
+ * @param argTypes 引数
+ * @return {@link Method} メソッド
+ * @throws NoSuchMethodRuntimeException {@link NoSuchMethodException}がおきた場合
+ * @see Class#getDeclaredMethod(String, Class[])
+ */
+ public static Method getDeclaredMethod(Class<?> clazz, String methodName, Class<?>[] argTypes)
+ throws NoSuchMethodRuntimeException {
+
+ try {
+ return clazz.getDeclaredMethod(methodName, argTypes);
+ } catch (NoSuchMethodException ex) {
+ throw new NoSuchMethodRuntimeException(clazz, methodName, argTypes, ex);
+ }
+ }
+
+ /**
+ * {@link Field}を取得する。
+ *
+ * @param clazz クラス
+ * @param fieldName フィールド名
+ * @return {@link Field}
+ * @throws NoSuchFieldRuntimeException {@link NoSuchFieldException}がおきた場合
+ * @see Class#getField(String)
+ */
+ public static Field getField(Class<?> clazz, String fieldName) throws NoSuchFieldRuntimeException {
+ try {
+ return clazz.getField(fieldName);
+ } catch (NoSuchFieldException ex) {
+ throw new NoSuchFieldRuntimeException(clazz, fieldName, ex);
+ }
+ }
+
+ /**
+ * {@link Method}を取得する。
+ *
+ * @param clazz クラス
+ * @param methodName メソッド名
+ * @param argTypes 引数
+ * @return {@link Method}
+ * @throws NoSuchMethodRuntimeException {@link NoSuchMethodException}がおきた場合
+ * @see Class#getMethod(String, Class[])
+ */
+ public static Method getMethod(Class<?> clazz, String methodName, Class<?>[] argTypes)
+ throws NoSuchMethodRuntimeException {
+
+ try {
+ return clazz.getMethod(methodName, argTypes);
+ } catch (NoSuchMethodException ex) {
+ throw new NoSuchMethodRuntimeException(clazz, methodName, argTypes, ex);
+ }
+ }
+
+ /**
+ * パッケージ名を取得する。
+ *
+ * @param clazz クラス
+ * @return パッケージ名
+ */
+ public static String getPackageName(Class<?> clazz) {
+ String fqcn = clazz.getName();
+ int pos = fqcn.lastIndexOf('.');
+ if (pos > 0) {
+ return fqcn.substring(0, pos);
+ }
+ return null;
+ }
+
+ /**
+ * ラッパークラスをプリミティブクラスに変換する。
+ *
+ * @param clazz クラス
+ * @return プリミティブクラス
+ */
+ public static Class<?> getPrimitiveClass(Class<?> clazz) {
+ return wrapperToPrimitiveMap.get(clazz);
+ }
+
+ /**
+ * ラッパークラスならプリミティブクラスに、 そうでなければそのままクラスを取得する。
+ *
+ * @param clazz クラス
+ * @return {@link Class}
+ */
+ public static Class<?> getPrimitiveClassIfWrapper(Class<?> clazz) {
+ Class<?> ret = getPrimitiveClass(clazz);
+ if (ret != null) {
+ return ret;
+ }
+ return clazz;
+ }
+
+ /**
+ * クラス名をリソースパスに変換する。
+ *
+ * @param clazz クラス
+ * @return リソースパス
+ * @see #getResourcePath(String)
+ */
+ public static String getResourcePath(Class<?> clazz) {
+ return getResourcePath(clazz.getName());
+ }
+
+ /**
+ * クラス名をリソースパスに変換する。
+ *
+ * @param className クラス名
+ * @return リソースパス
+ */
+ public static String getResourcePath(String className) {
+ return StringUtils.replace(className, ".", "/") + ".class";
+ }
+
+ /**
+ * FQCNからパッケージ名を除いた名前を取得する。
+ *
+ * @param clazz クラス
+ * @return FQCNからパッケージ名を除いた名前
+ * @see #getShortClassName(String)
+ */
+ public static String getShortClassName(Class<?> clazz) {
+ return getShortClassName(clazz.getName());
+ }
+
+ /**
+ * FQCNからパッケージ名を除いた名前を取得する。
+ *
+ * @param className クラス名
+ * @return FQCNからパッケージ名を除いた名前
+ */
+ public static String getShortClassName(String className) {
+ int i = className.lastIndexOf('.');
+ if (i > 0) {
+ return className.substring(i + 1);
+ }
+ return className;
+ }
+
+ /**
+ * 配列の場合は要素のクラス名、それ以外はクラス名そのものを返します。
+ *
+ * @param clazz クラス
+ * @return クラス名
+ */
+ public static String getSimpleClassName(final Class<?> clazz) {
+ if (clazz.isArray()) {
+ return getSimpleClassName(clazz.getComponentType()) + "[]";
+ }
+ return clazz.getName();
+ }
+
+ /**
+ * プリミティブクラスをラッパークラスに変換する。
+ *
+ * @param clazz クラス
+ * @return {@link Class}
+ */
+ public static Class<?> getWrapperClass(Class<?> clazz) {
+ return primitiveToWrapperMap.get(clazz);
+ }
+
+ /**
+ * プリミティブの場合はラッパークラス、そうでない場合はもとのクラスを取得する。
+ *
+ * @param clazz クラス
+ * @return {@link Class}
+ */
+ public static Class<?> getWrapperClassIfPrimitive(Class<?> clazz) {
+ Class<?> ret = getWrapperClass(clazz);
+ if (ret != null) {
+ return ret;
+ }
+ return clazz;
+ }
+
+ /**
+ * 代入可能かどうかをチェックする。
+ *
+ * @param toClass 代入先のクラス
+ * @param fromClass 代入元のクラス
+ * @return 代入可能かどうか
+ * @see Class#isAssignableFrom(Class)
+ */
+ public static boolean isAssignableFrom(Class<?> toClass, Class<?> fromClass) {
+ if (toClass == Object.class && !fromClass.isPrimitive()) {
+ return true;
+ }
+ if (toClass.isPrimitive()) {
+ fromClass = getPrimitiveClassIfWrapper(fromClass);
+ }
+ return toClass.isAssignableFrom(fromClass);
+ }
+
+ /**
+ * 新しいインスタンスを作成する。
+ *
+ * @param clazz クラス
+ * @return 新しいインスタンス
+ * @throws InstantiationRuntimeException {@link InstantiationException}がおきた場合
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}がおきた場合
+ * @see Class#newInstance()
+ */
+ public static Object newInstance(Class<?> clazz) throws InstantiationRuntimeException,
+ IllegalAccessRuntimeException {
+ try {
+ return clazz.newInstance();
+ } catch (InstantiationException ex) {
+ throw new InstantiationRuntimeException(clazz, ex);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalAccessRuntimeException(clazz, ex);
+ }
+ }
+
+ /**
+ * 新しいインスタンスを作成する。
+ *
+ * @param className クラス名
+ * @return 新しいインスタンス
+ * @throws ClassNotFoundRuntimeException {@link ClassNotFoundException}がおきた場合
+ * @throws InstantiationRuntimeException {@link InstantiationException}がおきた場合
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}がおきた場合
+ * @see #newInstance(Class)
+ */
+ public static Object newInstance(String className) throws ClassNotFoundRuntimeException,
+ InstantiationRuntimeException, IllegalAccessRuntimeException {
+ return newInstance(forName(className));
+ }
+
+ /**
+ * FQCNをパッケージ名とFQCNからパッケージ名を除いた名前に分割する。
+ *
+ * @param className クラス名
+ * @return パッケージ名とFQCNからパッケージ名を除いた名前
+ */
+ public static String[] splitPackageAndShortClassName(String className) {
+ String[] ret = new String[2];
+ int i = className.lastIndexOf('.');
+ if (i > 0) {
+ ret[0] = className.substring(0, i);
+ ret[1] = className.substring(i + 1);
+ } else {
+ ret[1] = className;
+ }
+ return ret;
+ }
+
+ /**
+ *
+ */
+ private ClassUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ClassUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/CollectionsUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/CollectionsUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/CollectionsUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,995 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.PriorityQueue;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.Stack;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.Vector;
+import java.util.WeakHashMap;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.DelayQueue;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.PriorityBlockingQueue;
+
+/**
+ * Genericsや可変長を活用するコレクションのためのユーティリティ。
+ *
+ * @author j5ik2o
+ */
+public class CollectionsUtil {
+
+ /**
+ * {@link ArrayBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayBlockingQueue}の要素型
+ * @param capacity キューの容量
+ * @return {@link ArrayBlockingQueue}の新しいインスタンス
+ * @see ArrayBlockingQueue#ArrayBlockingQueue(int)
+ */
+ public static <E>ArrayBlockingQueue<E> newArrayBlockingQueue(final int capacity) {
+ return new ArrayBlockingQueue<E>(capacity);
+ }
+
+ /**
+ * {@link ArrayBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayBlockingQueue}の要素型
+ * @param capacity キューの容量
+ * @param fair {@code true}の場合、挿入または削除時にブロックされたスレッドに対するキューアクセス
+ * @return {@link ArrayBlockingQueue}の新しいインスタンス
+ * @see ArrayBlockingQueue#ArrayBlockingQueue(int, boolean)
+ */
+ public static <E>ArrayBlockingQueue<E> newArrayBlockingQueue(final int capacity, final boolean fair) {
+ return new ArrayBlockingQueue<E>(capacity, fair);
+ }
+
+ /**
+ * {@link ArrayBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayBlockingQueue}の要素型
+ * @param capacity キューの容量
+ * @param fair {@code true}の場合、挿入または削除時にブロックされたスレッドに対するキューアクセス
+ * @param c 最初に含む要素のコレクション
+ * @return {@link ArrayBlockingQueue}の新しいインスタンス
+ * @see ArrayBlockingQueue#ArrayBlockingQueue(int, boolean, Collection)
+ */
+ public static <E>ArrayBlockingQueue<E> newArrayBlockingQueue(final int capacity, final boolean fair,
+ final Collection<? extends E> c) {
+ return new ArrayBlockingQueue<E>(capacity, fair, c);
+ }
+
+ /**
+ * {@link ArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayList}の要素型
+ * @return {@link ArrayList}の新しいインスタンス
+ * @see ArrayList#ArrayList()
+ */
+ public static <E>ArrayList<E> newArrayList() {
+ return new ArrayList<E>();
+ }
+
+ /**
+ * {@link ArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayList}の要素型
+ * @param c 要素がリストに配置されるコレクション
+ * @return {@link ArrayList}の新しいインスタンス
+ * @see ArrayList#ArrayList(Collection)
+ */
+ public static <E>ArrayList<E> newArrayList(final Collection<? extends E> c) {
+ return new ArrayList<E>(c);
+ }
+
+ /**
+ * {@link ArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ArrayList}の要素型
+ * @param initialCapacity リストの初期容量
+ * @return {@link ArrayList}の新しいインスタンス
+ * @see ArrayList#ArrayList(int)
+ */
+ public static <E>ArrayList<E> newArrayList(final int initialCapacity) {
+ return new ArrayList<E>(initialCapacity);
+ }
+
+ /**
+ * {@link ConcurrentHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link ConcurrentHashMap}のキーの型
+ * @param <V> {@link ConcurrentHashMap}の値の型
+ * @return {@link ConcurrentHashMap}の新しいインスタンス
+ * @see ConcurrentHashMap#ConcurrentHashMap()
+ */
+ public static <K, V>ConcurrentHashMap<K, V> newConcurrentHashMap() {
+ return new ConcurrentHashMap<K, V>();
+ }
+
+ /**
+ * {@link ConcurrentHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link ConcurrentHashMap}のキーの型
+ * @param <V> {@link ConcurrentHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @return {@link ConcurrentHashMap}の新しいインスタンス
+ * @see ConcurrentHashMap#ConcurrentHashMap(int)
+ */
+ public static <K, V>ConcurrentHashMap<K, V> newConcurrentHashMap(final int initialCapacity) {
+ return new ConcurrentHashMap<K, V>(initialCapacity);
+ }
+
+ /**
+ * {@link ConcurrentHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link ConcurrentHashMap}のキーの型
+ * @param <V> {@link ConcurrentHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @param loadFactor サイズ変更の制御に使用される負荷係数のしきい値
+ * @param concurrencyLevel 同時更新を行うスレッドの推定数
+ * @return {@link ConcurrentHashMap}の新しいインスタンス
+ * @see ConcurrentHashMap#ConcurrentHashMap(int, float, int)
+ */
+ public static <K, V>ConcurrentHashMap<K, V> newConcurrentHashMap(final int initialCapacity, final float loadFactor,
+ final int concurrencyLevel) {
+ return new ConcurrentHashMap<K, V>(initialCapacity, loadFactor, concurrencyLevel);
+ }
+
+ /**
+ * {@link ConcurrentHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link ConcurrentHashMap}のキーの型
+ * @param <V> {@link ConcurrentHashMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link ConcurrentHashMap}の新しいインスタンス
+ * @see ConcurrentHashMap#ConcurrentHashMap(Map)
+ */
+ public static <K, V>ConcurrentHashMap<K, V> newConcurrentHashMap(final Map<? extends K, ? extends V> m) {
+ return new ConcurrentHashMap<K, V>(m);
+ }
+
+ /**
+ * {@link ConcurrentLinkedQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ConcurrentLinkedQueue}の要素型
+ * @return {@link ConcurrentLinkedQueue}の新しいインスタンス
+ * @see ConcurrentLinkedQueue#ConcurrentLinkedQueue()
+ */
+ public static <E>ConcurrentLinkedQueue<E> newConcurrentLinkedQueue() {
+ return new ConcurrentLinkedQueue<E>();
+ }
+
+ /**
+ * {@link ConcurrentLinkedQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link ConcurrentLinkedQueue}の要素型
+ * @param c 最初に含む要素のコレクション
+ * @return {@link ConcurrentLinkedQueue}の新しいインスタンス
+ * @see ConcurrentLinkedQueue#ConcurrentLinkedQueue(Collection)
+ */
+ public static <E>ConcurrentLinkedQueue<E> newConcurrentLinkedQueue(final Collection<? extends E> c) {
+ return new ConcurrentLinkedQueue<E>(c);
+ }
+
+ /**
+ * {@link CopyOnWriteArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArrayList}の要素型
+ * @return {@link CopyOnWriteArrayList}の新しいインスタンス
+ * @see CopyOnWriteArrayList#CopyOnWriteArrayList()
+ */
+ public static <E>CopyOnWriteArrayList<E> newCopyOnWriteArrayList() {
+ return new CopyOnWriteArrayList<E>();
+ }
+
+ /**
+ * {@link CopyOnWriteArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArrayList}の要素型
+ * @param c 最初に保持していた要素のコレクション
+ * @return {@link CopyOnWriteArrayList}の新しいインスタンス
+ * @see CopyOnWriteArrayList#CopyOnWriteArrayList(Collection)
+ */
+ public static <E>CopyOnWriteArrayList<E> newCopyOnWriteArrayList(final Collection<? extends E> c) {
+ return new CopyOnWriteArrayList<E>(c);
+ }
+
+ /**
+ * {@link CopyOnWriteArrayList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArrayList}の要素型
+ * @param toCopyIn 配列 (この配列のコピーは内部配列として使用される)
+ * @return {@link CopyOnWriteArrayList}の新しいインスタンス
+ * @see CopyOnWriteArrayList#CopyOnWriteArrayList(Object[])
+ */
+ public static <E>CopyOnWriteArrayList<E> newCopyOnWriteArrayList(final E[] toCopyIn) {
+ return new CopyOnWriteArrayList<E>(toCopyIn);
+ }
+
+ /**
+ * {@link CopyOnWriteArraySet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArraySet}の要素型
+ * @return {@link CopyOnWriteArraySet}の新しいインスタンス
+ * @see CopyOnWriteArraySet#CopyOnWriteArraySet()
+ */
+ public static <E>CopyOnWriteArraySet<E> newCopyOnWriteArraySet() {
+ return new CopyOnWriteArraySet<E>();
+ }
+
+ /**
+ * {@link CopyOnWriteArraySet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArraySet}の要素型
+ * @param c コレクション
+ * @return {@link CopyOnWriteArraySet}の新しいインスタンス
+ * @see CopyOnWriteArraySet#CopyOnWriteArraySet(Collection)
+ */
+ public static <E>CopyOnWriteArraySet<E> newCopyOnWriteArraySet(final Collection<? extends E> c) {
+ return new CopyOnWriteArraySet<E>(c);
+ }
+
+ /**
+ * {@link DelayQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArraySet}の要素型
+ * @return {@link DelayQueue}の新しいインスタンス
+ * @see DelayQueue#DelayQueue()
+ */
+ public static <E extends Delayed>DelayQueue<E> newDelayQueue() {
+ return new DelayQueue<E>();
+ }
+
+ /**
+ * {@link DelayQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link CopyOnWriteArraySet}の要素型
+ * @param c コレクション
+ * @return {@link DelayQueue}の新しいインスタンス
+ * @see DelayQueue#DelayQueue(Collection)
+ */
+ public static <E extends Delayed>DelayQueue<E> newDelayQueue(final Collection<? extends E> c) {
+ return new DelayQueue<E>(c);
+ }
+
+ /**
+ * {@link HashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link HashMap}のキーの型
+ * @param <V> {@link HashMap}の値の型
+ * @return {@link HashMap}の新しいインスタンス
+ * @see HashMap#HashMap()
+ */
+ public static <K, V>HashMap<K, V> newHashMap() {
+ return new HashMap<K, V>();
+ }
+
+ /**
+ * {@link HashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link HashMap}のキーの型
+ * @param <V> {@link HashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @return {@link HashMap}の新しいインスタンス
+ * @see HashMap#HashMap(int)
+ */
+ public static <K, V>HashMap<K, V> newHashMap(final int initialCapacity) {
+ return new HashMap<K, V>(initialCapacity);
+ }
+
+ /**
+ * {@link HashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link HashMap}のキーの型
+ * @param <V> {@link HashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @param loadFactor サイズ変更の制御に使用される負荷係数のしきい値
+ * @return {@link HashMap}の新しいインスタンス
+ * @see HashMap#HashMap(int, float)
+ */
+ public static <K, V>HashMap<K, V> newHashMap(final int initialCapacity, final float loadFactor) {
+ return new HashMap<K, V>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link HashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link HashMap}のキーの型
+ * @param <V> {@link HashMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link HashMap}の新しいインスタンス
+ * @see HashMap#HashMap(int, float)
+ */
+ public static <K, V>HashMap<K, V> newHashMap(final Map<? extends K, ? extends V> m) {
+ return new HashMap<K, V>(m);
+ }
+
+ /**
+ * {@link HashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link HashSet}の要素型
+ * @return {@link HashSet}の新しいインスタンス
+ * @see HashSet#HashSet()
+ */
+ public static <E>HashSet<E> newHashSet() {
+ return new HashSet<E>();
+ }
+
+ /**
+ * {@link HashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link HashSet}の要素型
+ * @param c 要素がセットに配置されるコレクション
+ * @return {@link HashSet}の新しいインスタンス
+ * @see HashSet#HashSet()
+ */
+ public static <E>HashSet<E> newHashSet(final Collection<? extends E> c) {
+ return new HashSet<E>(c);
+ }
+
+ /**
+ * {@link HashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link HashSet}の要素型
+ * @param initialCapacity 初期容量
+ * @return {@link HashSet}の新しいインスタンス
+ * @see HashSet#HashSet()
+ */
+ public static <E>HashSet<E> newHashSet(final int initialCapacity) {
+ return new HashSet<E>(initialCapacity);
+ }
+
+ /**
+ * {@link HashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link HashSet}の要素型
+ * @param initialCapacity 初期容量
+ * @param loadFactor 負荷係数
+ * @return {@link HashSet}の新しいインスタンス
+ * @see HashSet#HashSet()
+ */
+ public static <E>HashSet<E> newHashSet(final int initialCapacity, final float loadFactor) {
+ return new HashSet<E>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link Hashtable}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link Hashtable}のキーの型
+ * @param <V> {@link Hashtable}の値の型
+ * @return {@link Hashtable}の新しいインスタンス
+ * @see Hashtable#Hashtable()
+ */
+ public static <K, V>Hashtable<K, V> newHashtable() {
+ return new Hashtable<K, V>();
+ }
+
+ /**
+ * {@link Hashtable}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link Hashtable}のキーの型
+ * @param <V> {@link Hashtable}の値の型
+ * @param initialCapacity ハッシュテーブルの初期容量
+ * @return {@link Hashtable}の新しいインスタンス
+ * @see Hashtable#Hashtable(int)
+ */
+ public static <K, V>Hashtable<K, V> newHashtable(final int initialCapacity) {
+ return new Hashtable<K, V>(initialCapacity);
+ }
+
+ /**
+ * {@link Hashtable}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link Hashtable}のキーの型
+ * @param <V> {@link Hashtable}の値の型
+ * @param initialCapacity ハッシュテーブルの初期容量
+ * @param loadFactor ハッシュテーブルの負荷係数
+ * @return {@link Hashtable}の新しいインスタンス
+ * @see Hashtable#Hashtable(int, float)
+ */
+ public static <K, V>Hashtable<K, V> newHashtable(final int initialCapacity, final float loadFactor) {
+ return new Hashtable<K, V>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link Hashtable}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link Hashtable}のキーの型
+ * @param <V> {@link Hashtable}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link Hashtable}の新しいインスタンス
+ * @see Hashtable#Hashtable(Map)
+ */
+ public static <K, V>Hashtable<K, V> newHashtable(final Map<? extends K, ? extends V> m) {
+ return new Hashtable<K, V>(m);
+ }
+
+ /**
+ * {@link IdentityHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link IdentityHashMap}のキーの型
+ * @param <V> {@link IdentityHashMap}の値の型
+ * @return {@link IdentityHashMap}の新しいインスタンス
+ * @see IdentityHashMap#IdentityHashMap()
+ */
+ public static <K, V>IdentityHashMap<K, V> newIdentityHashMap() {
+ return new IdentityHashMap<K, V>();
+ }
+
+ /**
+ * {@link IdentityHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link IdentityHashMap}のキーの型
+ * @param <V> {@link IdentityHashMap}の値の型
+ * @param expectedMaxSize マップの予想最大サイズ
+ * @return {@link IdentityHashMap}の新しいインスタンス
+ * @see IdentityHashMap#IdentityHashMap(int)
+ */
+ public static <K, V>IdentityHashMap<K, V> newIdentityHashMap(final int expectedMaxSize) {
+ return new IdentityHashMap<K, V>(expectedMaxSize);
+ }
+
+ /**
+ * {@link IdentityHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link IdentityHashMap}のキーの型
+ * @param <V> {@link IdentityHashMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link IdentityHashMap}の新しいインスタンス
+ * @see IdentityHashMap#IdentityHashMap(Map)
+ */
+ public static <K, V>IdentityHashMap<K, V> newIdentityHashMap(final Map<? extends K, ? extends V> m) {
+ return new IdentityHashMap<K, V>(m);
+ }
+
+ /**
+ * {@link LinkedBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedBlockingQueue}の要素型
+ * @return {@link LinkedBlockingQueue}の新しいインスタンス
+ * @see LinkedBlockingQueue#LinkedBlockingQueue()
+ */
+ public static <E>LinkedBlockingQueue<E> newLinkedBlockingQueue() {
+ return new LinkedBlockingQueue<E>();
+ }
+
+ /**
+ * {@link LinkedBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedBlockingQueue}の要素型
+ * @param c 最初に含む要素のコレクション
+ * @return {@link LinkedBlockingQueue}の新しいインスタンス
+ * @see LinkedBlockingQueue#LinkedBlockingQueue(Collection)
+ */
+ public static <E>LinkedBlockingQueue<E> newLinkedBlockingQueue(final Collection<? extends E> c) {
+ return new LinkedBlockingQueue<E>(c);
+ }
+
+ /**
+ * {@link LinkedBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedBlockingQueue}の要素型
+ * @param initialCapacity このキューの容量
+ * @return {@link LinkedBlockingQueue}の新しいインスタンス
+ * @see LinkedBlockingQueue#LinkedBlockingQueue(int)
+ */
+ public static <E>LinkedBlockingQueue<E> newLinkedBlockingQueue(final int initialCapacity) {
+ return new LinkedBlockingQueue<E>(initialCapacity);
+ }
+
+ /**
+ * {@link LinkedHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link LinkedHashMap}のキーの型
+ * @param <V> {@link LinkedHashMap}の値の型
+ * @return {@link LinkedHashMap}の新しいインスタンス
+ * @see LinkedHashMap#LinkedHashMap()
+ */
+ public static <K, V>LinkedHashMap<K, V> newLinkedHashMap() {
+ return new LinkedHashMap<K, V>();
+ }
+
+ /**
+ * {@link LinkedHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link LinkedHashMap}のキーの型
+ * @param <V> {@link LinkedHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @return {@link LinkedHashMap}の新しいインスタンス
+ * @see LinkedHashMap#LinkedHashMap(int)
+ */
+ public static <K, V>LinkedHashMap<K, V> newLinkedHashMap(final int initialCapacity) {
+ return new LinkedHashMap<K, V>(initialCapacity);
+ }
+
+ /**
+ * {@link LinkedHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link LinkedHashMap}のキーの型
+ * @param <V> {@link LinkedHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @param loadFactor 負荷係数
+ * @return {@link LinkedHashMap}の新しいインスタンス
+ * @see LinkedHashMap#LinkedHashMap(int, float)
+ */
+ public static <K, V>LinkedHashMap<K, V> newLinkedHashMap(final int initialCapacity, final float loadFactor) {
+ return new LinkedHashMap<K, V>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link LinkedHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link LinkedHashMap}のキーの型
+ * @param <V> {@link LinkedHashMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link LinkedHashMap}の新しいインスタンス
+ * @see LinkedHashMap#LinkedHashMap(Map)
+ */
+ public static <K, V>LinkedHashMap<K, V> newLinkedHashMap(final Map<? extends K, ? extends V> m) {
+ return new LinkedHashMap<K, V>(m);
+ }
+
+ /**
+ * {@link LinkedHashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedHashSet}の要素型
+ * @return {@link LinkedHashSet}の新しいインスタンス
+ * @see LinkedHashSet#LinkedHashSet()
+ */
+ public static <E>LinkedHashSet<E> newLinkedHashSet() {
+ return new LinkedHashSet<E>();
+ }
+
+ /**
+ * {@link LinkedHashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedHashSet}の要素型
+ * @param c 要素がセットに配置されるコレクション
+ * @return {@link LinkedHashSet}の新しいインスタンス
+ * @see LinkedHashSet#LinkedHashSet(Collection)
+ */
+ public static <E>LinkedHashSet<E> newLinkedHashSet(final Collection<? extends E> c) {
+ return new LinkedHashSet<E>(c);
+ }
+
+ /**
+ * {@link LinkedHashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedHashSet}の要素型
+ * @param initialCapacity 初期容量
+ * @return {@link LinkedHashSet}の新しいインスタンス
+ * @see LinkedHashSet#LinkedHashSet(int)
+ */
+ public static <E>LinkedHashSet<E> newLinkedHashSet(final int initialCapacity) {
+ return new LinkedHashSet<E>(initialCapacity);
+ }
+
+ /**
+ * {@link LinkedHashSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedHashSet}の要素型
+ * @param initialCapacity 初期容量
+ * @param loadFactor 負荷係数
+ * @return {@link LinkedHashSet}の新しいインスタンス
+ * @see LinkedHashSet#LinkedHashSet(int, float)
+ */
+ public static <E>LinkedHashSet<E> newLinkedHashSet(final int initialCapacity, final float loadFactor) {
+ return new LinkedHashSet<E>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link LinkedList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedList}の要素型
+ * @return {@link LinkedList}の新しいインスタンス
+ * @see LinkedList#LinkedList()
+ */
+ public static <E>LinkedList<E> newLinkedList() {
+ return new LinkedList<E>();
+ }
+
+ /**
+ * {@link LinkedList}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link LinkedList}の要素型
+ * @param c 要素がリストに配置されるコレクション
+ * @return {@link LinkedList}の新しいインスタンス
+ * @see LinkedList#LinkedList(Collection)
+ */
+ public static <E>LinkedList<E> newLinkedList(final Collection<? extends E> c) {
+ return new LinkedList<E>(c);
+ }
+
+ /**
+ * {@link PriorityBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityBlockingQueue}の要素型
+ * @return {@link PriorityBlockingQueue}の新しいインスタンス
+ * @see PriorityBlockingQueue#PriorityBlockingQueue()
+ */
+ public static <E>PriorityBlockingQueue<E> newPriorityBlockingQueue() {
+ return new PriorityBlockingQueue<E>();
+ }
+
+ /**
+ * {@link PriorityBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityBlockingQueue}の要素型
+ * @param c 最初に含む要素のコレクション
+ * @return {@link PriorityBlockingQueue}の新しいインスタンス
+ * @see PriorityBlockingQueue#PriorityBlockingQueue(Collection)
+ */
+ public static <E>PriorityBlockingQueue<E> newPriorityBlockingQueue(final Collection<? extends E> c) {
+ return new PriorityBlockingQueue<E>(c);
+ }
+
+ /**
+ * {@link PriorityBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityBlockingQueue}の要素型
+ * @param initialCapacity この優先度キューの初期容量
+ * @return {@link PriorityBlockingQueue}の新しいインスタンス
+ * @see PriorityBlockingQueue#PriorityBlockingQueue(int)
+ */
+ public static <E>PriorityBlockingQueue<E> newPriorityBlockingQueue(final int initialCapacity) {
+ return new PriorityBlockingQueue<E>(initialCapacity);
+ }
+
+ /**
+ * {@link PriorityBlockingQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityBlockingQueue}の要素型
+ * @param initialCapacity この優先度キューの初期容量
+ * @param comparator この優先度キューの順序付けに使用するコンパレータ
+ * @return {@link PriorityBlockingQueue}の新しいインスタンス
+ * @see PriorityBlockingQueue#PriorityBlockingQueue(int, Comparator)
+ */
+ public static <E>PriorityBlockingQueue<E> newPriorityBlockingQueue(final int initialCapacity,
+ final Comparator<? super E> comparator) {
+ return new PriorityBlockingQueue<E>(initialCapacity, comparator);
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue()
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue() {
+ return new PriorityQueue<E>();
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @param c 要素が優先度キューに配置されるコレクション
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue(Collection)
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue(final Collection<? extends E> c) {
+ return new PriorityQueue<E>(c);
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @param initialCapacity この優先度キューの初期容量
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue(int)
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue(final int initialCapacity) {
+ return new PriorityQueue<E>(initialCapacity);
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @param initialCapacity この優先度キューの初期容量
+ * @param comparator この優先度キューの順序付けに使用するコンパレータ
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue(int, Comparator)
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue(final int initialCapacity, final Comparator<? super E> comparator) {
+ return new PriorityQueue<E>(initialCapacity, comparator);
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @param c 要素が優先度キューに配置されるコレクション
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue(PriorityQueue)
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue(final PriorityQueue<? extends E> c) {
+ return new PriorityQueue<E>(c);
+ }
+
+ /**
+ * {@link PriorityQueue}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link PriorityQueue}の要素型
+ * @param c 要素が優先度キューに配置されるコレクション
+ * @return {@link PriorityQueue}の新しいインスタンス
+ * @see PriorityQueue#PriorityQueue(SortedSet)
+ */
+ public static <E>PriorityQueue<E> newPriorityQueue(final SortedSet<? extends E> c) {
+ return new PriorityQueue<E>(c);
+ }
+
+ /**
+ * {@link Stack}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link Stack}の要素型
+ * @return {@link Stack}の新しいインスタンス
+ * @see Stack#Stack()
+ */
+ public static <E>Stack<E> newStack() {
+ return new Stack<E>();
+ }
+
+ /**
+ * {@link TreeMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link TreeMap}のキーの型
+ * @param <V> {@link TreeMap}の値の型
+ * @return {@link TreeMap}の新しいインスタンス
+ * @see TreeMap#TreeMap()
+ */
+ public static <K, V>TreeMap<K, V> newTreeMap() {
+ return new TreeMap<K, V>();
+ }
+
+ /**
+ * {@link TreeMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link TreeMap}のキーの型
+ * @param <V> {@link TreeMap}の値の型
+ * @param c {@link Comparator}
+ * @return {@link TreeMap}の新しいインスタンス
+ * @see TreeMap#TreeMap()
+ */
+ public static <K, V>TreeMap<K, V> newTreeMap(final Comparator<? super K> c) {
+ return new TreeMap<K, V>(c);
+ }
+
+ /**
+ * {@link TreeMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link TreeMap}のキーの型
+ * @param <V> {@link TreeMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link TreeMap}の新しいインスタンス
+ * @see TreeMap#TreeMap(Map)
+ */
+ public static <K, V>TreeMap<K, V> newTreeMap(final Map<? extends K, ? extends V> m) {
+ return new TreeMap<K, V>(m);
+ }
+
+ /**
+ * {@link TreeMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link TreeMap}のキーの型
+ * @param <V> {@link TreeMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link TreeMap}の新しいインスタンス
+ * @see TreeMap#TreeMap(SortedMap)
+ */
+ public static <K, V>TreeMap<K, V> newTreeMap(final SortedMap<K, ? extends V> m) {
+ return new TreeMap<K, V>(m);
+ }
+
+ /**
+ * {@link TreeSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link TreeSet}の要素型
+ * @return {@link TreeSet}の新しいインスタンス
+ * @see TreeSet#TreeSet()
+ */
+ public static <E>TreeSet<E> newTreeSet() {
+ return new TreeSet<E>();
+ }
+
+ /**
+ * {@link TreeSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link TreeSet}の要素型
+ * @param c 要素がセットに配置されるコレクション
+ * @return {@link TreeSet}の新しいインスタンス
+ * @see TreeSet#TreeSet(Collection)
+ */
+ public static <E>TreeSet<E> newTreeSet(final Collection<? extends E> c) {
+ return new TreeSet<E>(c);
+ }
+
+ /**
+ * {@link TreeSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link TreeSet}の要素型
+ * @param c このセットをソートするために使用されるコンパレータ
+ * @return {@link TreeSet}の新しいインスタンス
+ * @see TreeSet#TreeSet(Comparator)
+ */
+ public static <E>TreeSet<E> newTreeSet(final Comparator<? super E> c) {
+ return new TreeSet<E>(c);
+ }
+
+ /**
+ * {@link TreeSet}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link TreeSet}の要素型
+ * @param s 要素がセットに配置されるコレクション
+ * @return {@link TreeSet}の新しいインスタンス
+ * @see TreeSet#TreeSet(SortedSet)
+ */
+ public static <E>TreeSet<E> newTreeSet(final SortedSet<? extends E> s) {
+ return new TreeSet<E>(s);
+ }
+
+ /**
+ * {@link Vector}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link Vector}の要素型
+ * @return {@link Vector}の新しいインスタンス
+ * @see Vector#Vector()
+ */
+ public static <E>Vector<E> newVector() {
+ return new Vector<E>();
+ }
+
+ /**
+ * {@link Vector}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link Vector}の要素型
+ * @param c 要素がセットに配置されるコレクション
+ * @return {@link Vector}の新しいインスタンス
+ * @see Vector#Vector(Collection)
+ */
+ public static <E>Vector<E> newVector(final Collection<? extends E> c) {
+ return new Vector<E>(c);
+ }
+
+ /**
+ * {@link Vector}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link Vector}の要素型
+ * @param initialCapacity {@link Vector}の初期容量
+ * @return {@link Vector}の新しいインスタンス
+ * @see Vector#Vector(int)
+ */
+ public static <E>Vector<E> newVector(final int initialCapacity) {
+ return new Vector<E>(initialCapacity);
+ }
+
+ /**
+ * {@link Vector}の新しいインスタンスを作成する。
+ *
+ * @param <E> {@link Vector}の要素型
+ * @param initialCapacity {@link Vector}の初期容量
+ * @param capacityIncrement {@link Vector}があふれたときに増加される容量
+ * @return {@link Vector}の新しいインスタンス
+ * @see Vector#Vector(int, int)
+ */
+ public static <E>Vector<E> newVector(final int initialCapacity, final int capacityIncrement) {
+ return new Vector<E>(initialCapacity, capacityIncrement);
+ }
+
+ /**
+ * {@link WeakHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link WeakHashMap}のキーの型
+ * @param <V> {@link WeakHashMap}の値の型
+ * @return {@link WeakHashMap}の新しいインスタンス
+ * @see WeakHashMap#WeakHashMap()
+ */
+ public static <K, V>WeakHashMap<K, V> newWeakHashMap() {
+ return new WeakHashMap<K, V>();
+ }
+
+ /**
+ * {@link WeakHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link WeakHashMap}のキーの型
+ * @param <V> {@link WeakHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @return {@link WeakHashMap}の新しいインスタンス
+ * @see WeakHashMap#WeakHashMap(int)
+ */
+ public static <K, V>WeakHashMap<K, V> newWeakHashMap(final int initialCapacity) {
+ return new WeakHashMap<K, V>(initialCapacity);
+ }
+
+ /**
+ * {@link WeakHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link WeakHashMap}のキーの型
+ * @param <V> {@link WeakHashMap}の値の型
+ * @param initialCapacity 初期容量
+ * @param loadFactor サイズ変更の制御に使用される負荷係数のしきい値
+ * @return {@link WeakHashMap}の新しいインスタンス
+ * @see WeakHashMap#WeakHashMap(int, float)
+ */
+ public static <K, V>WeakHashMap<K, V> newWeakHashMap(final int initialCapacity, final float loadFactor) {
+ return new WeakHashMap<K, V>(initialCapacity, loadFactor);
+ }
+
+ /**
+ * {@link WeakHashMap}の新しいインスタンスを作成する。
+ *
+ * @param <K> {@link WeakHashMap}のキーの型
+ * @param <V> {@link WeakHashMap}の値の型
+ * @param m 作成されるマップに配置されるマップ
+ * @return {@link WeakHashMap}の新しいインスタンス
+ * @see WeakHashMap#WeakHashMap(Map)
+ */
+ public static <K, V>WeakHashMap<K, V> newWeakHashMap(final Map<? extends K, ? extends V> m) {
+ return new WeakHashMap<K, V>(m);
+ }
+
+ /**
+ * マップが指定されたキーを含んでいない場合は、キーを指定された値に関連付けます。
+ * <p>
+ * マップがすでに指定されたキーを含んでいる場合は、 キーに関連づけられている値を返します。 マップは変更されず、 指定された値は使われません。
+ * マップがまだ指定されたキーを含んでいない場合は、 指定された値を値を返します。 マップは変更され、指定されたキーと指定された値が関連づけられます。
+ * いずれの場合も、返される値はマップがその時点でキーと関連づけている値です。
+ * </p>
+ *
+ * @param <K> {@link HashMap}のキーの型
+ * @param <V> {@link HashMap}の値の型
+ * @param map マップ
+ * @param key 指定される値が関連付けられるキー
+ * @param value 指定されるキーに関連付けられる値
+ * @return 指定されたキーと関連付けられていた以前の値または、キーに関連付けられる値
+ * @see ConcurrentHashMap#putIfAbsent(Object, Object)
+ */
+ public static <K, V>V putIfAbsent(final ConcurrentMap<K, V> map, final K key, final V value) {
+ V exists = map.putIfAbsent(key, value);
+ if (exists != null) {
+ return exists;
+ }
+ return value;
+ }
+
+ private CollectionsUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/CollectionsUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/EnumerationIterator.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/EnumerationIterator.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/EnumerationIterator.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.util.Enumeration;
+import java.util.Iterator;
+
+/**
+ * {@link Enumeration}を {@link Iterator}にするためのアダブタです。
+ *
+ * @param <E> 要素
+ * @author j5ik2o
+ */
+public class EnumerationIterator<E> implements Iterator<E> {
+
+ private Enumeration<E> enumeration = null;
+
+
+ /**
+ * {@link EnumerationIterator}を作成します。
+ *
+ * @param e {@link Enumeration}
+ */
+ public EnumerationIterator(final Enumeration<E> e) {
+ if (e == null) {
+ throw new NullPointerException("Enumeration");
+ }
+ this.enumeration = e;
+ }
+
+ public boolean hasNext() {
+ return enumeration.hasMoreElements();
+ }
+
+ public E next() {
+ return enumeration.nextElement();
+ }
+
+ public void remove() {
+ throw new UnsupportedOperationException("remove");
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/EnumerationIterator.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FieldUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FieldUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FieldUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import org.jiemamy.composer.importer.exception.IllegalAccessRuntimeException;
+
+/**
+ * {@link Field}用のユーティリティクラスです。
+ *
+ * @author j5ik2o
+ */
+public class FieldUtil {
+
+ /**
+ * {@link #getElementTypeOfCollectionFromFieldType(Field)}への定数参照です
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_COLLECTION_FROM_FIELD_TYPE_METHOD =
+ getElementTypeFromFieldTypeMethod("Collection");
+
+ /**
+ * {@link #getElementTypeOfListFromFieldType(Field)}への定数参照です
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_LIST_FROM_FIELD_TYPE_METHOD =
+ getElementTypeFromFieldTypeMethod("List");
+
+ /**
+ * {@link #getElementTypeOfSetFromFieldType(Field)}への定数参照です
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_SET_FROM_FIELD_TYPE_METHOD =
+ getElementTypeFromFieldTypeMethod("Set");
+
+
+ /**
+ * {@link Field}の値をオブジェクトとして取得する。
+ *
+ * @param field フィールド
+ * @param target ターゲット
+ * @return {@link Object}
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}がおきた場合
+ * @see Field#get(Object)
+ */
+ public static Object get(Field field, Object target) throws IllegalAccessRuntimeException {
+ try {
+ return field.get(target);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), ex);
+ }
+ }
+
+ /**
+ * <code>ReflectionUtil#getElementTypeOf<var>Xxx</var>FromFieldType()</code>
+ * の {@link Method}を取得する。
+ *
+ * @param type 取得するメソッドが対象とする型名
+ * @return
+ * <code>ReflectionUtil#getElementTypeOf<var>Xxx</var>FromFieldType()</code>
+ * の{@link Method}
+ */
+ protected static Method getElementTypeFromFieldTypeMethod(final String type) {
+ try {
+ final Class<?> reflectionUtilClass = ReflectionUtil.class;
+ return reflectionUtilClass.getMethod("getElementTypeOf" + type + "FromFieldType", new Class[] {
+ Field.class
+ });
+ } catch (Throwable ignore) {
+ //ignore
+ }
+ return null;
+ }
+
+ /**
+ * Java5以上の場合は、指定されたフィールドのパラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return フィールドのパラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollectionFromFieldType(final Field field) {
+ if (GET_ELEMENT_TYPE_OF_COLLECTION_FROM_FIELD_TYPE_METHOD == null) {
+ return null;
+ }
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_COLLECTION_FROM_FIELD_TYPE_METHOD, null, new Object[] {
+ field
+ });
+ }
+
+ /**
+ * 指定されたフィールドのパラメタ化されたリストの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return フィールドのパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromFieldType(final Field field) {
+ if (GET_ELEMENT_TYPE_OF_LIST_FROM_FIELD_TYPE_METHOD == null) {
+ return null;
+ }
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_LIST_FROM_FIELD_TYPE_METHOD, null, new Object[] {
+ field
+ });
+ }
+
+ /**
+ * 指定されたフィールドのパラメタ化されたセットの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return フィールドのパラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSetFromFieldType(final Field field) {
+ if (GET_ELEMENT_TYPE_OF_SET_FROM_FIELD_TYPE_METHOD == null) {
+ return null;
+ }
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_SET_FROM_FIELD_TYPE_METHOD, null, new Object[] {
+ field
+ });
+ }
+
+ /**
+ * staticな {@link Field}の値をintとして取得する。
+ *
+ * @param field フィールド
+ * @return intの値
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see #getInt(Field, Object)
+ */
+ public static int getInt(Field field) throws IllegalAccessRuntimeException {
+ return getInt(field, null);
+ }
+
+ /**
+ * {@link Field}の値をintとして取得する。
+ *
+ * @param field フィールド
+ * @param target ターゲット
+ * @return intの値
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see Field#getInt(Object)
+ */
+ public static int getInt(Field field, Object target) throws IllegalAccessRuntimeException {
+ try {
+ return field.getInt(target);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), ex);
+ }
+ }
+
+ /**
+ * staticな {@link Field}の値を {@link String}として取得する。
+ *
+ * @param field フィールド
+ * @return {@link String}の値
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see #getString(Field, Object)
+ */
+ public static String getString(Field field) throws IllegalAccessRuntimeException {
+ return getString(field, null);
+ }
+
+ /**
+ * {@link Field}の値を {@link String}として取得する。
+ *
+ * @param field フィールド
+ * @param target ターゲット
+ * @return {@link String}の値
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see Field#get(Object)
+ */
+ public static String getString(Field field, Object target) throws IllegalAccessRuntimeException {
+
+ try {
+ return (String) field.get(target);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), ex);
+ }
+ }
+
+ /**
+ * インスタンスフィールドがどうかを取得する。
+ *
+ * @param field フィールド
+ * @return インスタンスフィールドかどうか
+ */
+ public static boolean isInstanceField(Field field) {
+ int mod = field.getModifiers();
+ return !Modifier.isStatic(mod) && !Modifier.isFinal(mod);
+ }
+
+ /**
+ * パブリックフィールドかどうかを取得する。
+ *
+ * @param field フィールド
+ * @return パブリックフィールドかどうか
+ */
+ public static boolean isPublicField(Field field) {
+ int mod = field.getModifiers();
+ return Modifier.isPublic(mod);
+ }
+
+ /**
+ * {@link Field}に値を設定する。
+ *
+ * @param field フィールド
+ * @param target ターゲット
+ * @param value 値
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see Field#set(Object, Object)
+ */
+ public static void set(Field field, Object target, Object value) throws IllegalAccessRuntimeException {
+ try {
+ field.set(target, value);
+ } catch (IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), e);
+ } catch (IllegalArgumentException e) {
+// Class clazz = field.getDeclaringClass();
+// Class fieldClass = field.getType();
+// Class valueClass = value == null ? null : value.getClass();
+// Class targetClass = target == null ? null : target.getClass();
+ throw new IllegalArgumentException(e);
+ }
+
+ }
+
+ private FieldUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FieldUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileInputStreamUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileInputStreamUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileInputStreamUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link FileInputStream}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ *
+ */
+public class FileInputStreamUtil {
+
+ /**
+ * {@link FileInputStream}を作成する。
+ *
+ * @param file ファイル
+ * @return {@link FileInputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ * @see FileInputStream#FileInputStream(File)
+ */
+ public static FileInputStream create(File file) throws IORuntimeException {
+ try {
+ return new FileInputStream(file);
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private FileInputStreamUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileInputStreamUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileOutputStreamUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileOutputStreamUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileOutputStreamUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link FileOutputStream}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ *
+ */
+public class FileOutputStreamUtil {
+
+ /**
+ * {@link FileOutputStream}を作成する。
+ *
+ * @param file ファイル
+ * @return {@link FileOutputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ * @see FileOutputStream#FileOutputStream(File)
+ */
+ public static FileOutputStream create(File file) throws IORuntimeException {
+ try {
+ return new FileOutputStream(file);
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private FileOutputStreamUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileOutputStreamUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URL;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link File}を扱うユーティリティ・クラス。
+ *
+ * @author j5ik2o
+ */
+public class FileUtil {
+
+ /** バッファサイズ */
+ private static final int BUFF_SIZE = 1024;
+
+
+ /**
+ * <code>src</code>の内容を<code>dest</code>にコピーします。
+ *
+ * @param src コピー元のファイル
+ * @param dest コピー先のファイル
+ */
+ public static void copy(File src, File dest) {
+ if (dest.canWrite() == false || (dest.exists() && dest.canWrite() == false)) {
+ return;
+ }
+ BufferedInputStream in = null;
+ BufferedOutputStream out = null;
+ try {
+ in = new BufferedInputStream(FileInputStreamUtil.create(src));
+ out = new BufferedOutputStream(FileOutputStreamUtil.create(dest));
+ byte[] buf = new byte[BUFF_SIZE];
+ int length;
+ while (-1 < (length = in.read(buf))) {
+ out.write(buf, 0, length);
+ out.flush();
+ }
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ } finally {
+ InputStreamUtil.close(in);
+ OutputStreamUtil.close(out);
+ }
+ }
+
+ /**
+ * ファイルの内容をバイト配列に読み込む。
+ *
+ * @param file ファイル
+ * @return ファイルの内容を読み込んだバイト配列
+ */
+ public static byte[] getBytes(File file) {
+ return InputStreamUtil.getBytes(FileInputStreamUtil.create(file));
+ }
+
+ /**
+ * この抽象パス名の正規の形式を返します。
+ *
+ * @param file ファイル
+ * @return この抽象パス名と同じファイルまたはディレクトリを示す正規パス名文字列
+ */
+ public static String getCanonicalPath(File file) {
+ try {
+ return file.getCanonicalPath();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * この抽象パス名を<code>file:</code> URLに変換します。
+ *
+ * @param file ファイル
+ * @return ファイルURLを表すURLオブジェクト
+ */
+ public static URL toURL(final File file) {
+ try {
+ return file.toURL();
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * バイトの配列をファイルに書き出します。
+ *
+ * @param path ファイルのパス
+ * @param data バイトの配列
+ * @throws NullPointerException pathやdataがnullの場合。
+ */
+ public static void write(String path, byte[] data) {
+ if (path == null) {
+ throw new NullPointerException("path");
+ }
+ if (data == null) {
+ throw new NullPointerException("data");
+ }
+ write(path, data, 0, data.length);
+ }
+
+ /**
+ * バイトの配列をファイルに書き出します。
+ *
+ * @param path ファイルのパス
+ * @param data バイトの配列
+ * @param offset オフセット
+ * @param length 配列の長さ
+ * @throws NullPointerException pathやdataがnullの場合。
+ */
+ public static void write(String path, byte[] data, int offset, int length) {
+ if (path == null) {
+ throw new NullPointerException("path");
+ }
+ if (data == null) {
+ throw new NullPointerException("data");
+ }
+ try {
+ OutputStream out = new BufferedOutputStream(new FileOutputStream(path));
+ try {
+ out.write(data, offset, length);
+ } finally {
+ out.close();
+ }
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private FileUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/FileUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/GenericUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/GenericUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/GenericUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,475 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.GenericDeclaration;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Genericsを扱うためのユーティリティ・クラス。
+ *
+ * @author j5ik2o
+ */
+public abstract class GenericUtil {
+
+ /**
+ * パラメータ化された型(クラスまたはインタフェース)が持つ型変数および型引数を集めて<code>map</code>に追加する。
+ *
+ * @param clazz クラス
+ * @param type 型
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ */
+ protected static void gatherTypeVariables(final Class<?> clazz, final Type type,
+ final Map<TypeVariable<?>, Type> map) {
+ if (clazz == null) {
+ return;
+ }
+ gatherTypeVariables(type, map);
+
+ final Class<?> superClass = clazz.getSuperclass();
+ final Type superClassType = clazz.getGenericSuperclass();
+ if (superClass != null) {
+ gatherTypeVariables(superClass, superClassType, map);
+ }
+
+ final Class<?>[] interfaces = clazz.getInterfaces();
+ final Type[] interfaceTypes = clazz.getGenericInterfaces();
+ for (int i = 0; i < interfaces.length; ++i) {
+ gatherTypeVariables(interfaces[i], interfaceTypes[i], map);
+ }
+ }
+
+ /**
+ * パラメータ化された型(クラスまたはインタフェース)が持つ型変数および型引数を集めて<code>map</code>に追加する。
+ *
+ * @param type 型
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ */
+ protected static void gatherTypeVariables(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (ParameterizedType.class.isInstance(type)) {
+ final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
+ final TypeVariable<?>[] typeVariables =
+ GenericDeclaration.class.cast(parameterizedType.getRawType()).getTypeParameters();
+ final Type[] actualTypes = parameterizedType.getActualTypeArguments();
+ for (int i = 0; i < actualTypes.length; ++i) {
+ map.put(typeVariables[i], actualTypes[i]);
+ }
+ }
+ }
+
+ /**
+ * <code>type</code>の実際の型を取得する。
+ * <ul>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type タイプ
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return <code>type</code>の実際の型
+ */
+ public static Class<?> getActualClass(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (Class.class.isInstance(type)) {
+ return Class.class.cast(type);
+ }
+ if (ParameterizedType.class.isInstance(type)) {
+ return getActualClass(ParameterizedType.class.cast(type).getRawType(), map);
+ }
+ if (WildcardType.class.isInstance(type)) {
+ return getActualClass(WildcardType.class.cast(type).getUpperBounds()[0], map);
+ }
+ if (TypeVariable.class.isInstance(type)) {
+ return getActualClass(map.get(TypeVariable.class.cast(type)), map);
+ }
+ if (GenericArrayType.class.isInstance(type)) {
+ final GenericArrayType genericArrayType = GenericArrayType.class.cast(type);
+ final Class<?> componentClass = getActualClass(genericArrayType.getGenericComponentType(), map);
+ return Array.newInstance(componentClass, 0).getClass();
+ }
+ return null;
+ }
+
+ /**
+ * パラメータ化された型を要素とする配列の実際の要素型を取得する。
+ * <ul>
+ * <li><code>type</code>がパラメータ化された型の配列でない場合は<code>null</code>を取得する。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された型を要素とする配列
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された型を要素とする配列の実際の要素型
+ */
+ public static Class<?> getActualElementClassOfArray(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!GenericArrayType.class.isInstance(type)) {
+ return null;
+ }
+ return getActualClass(GenericArrayType.class.cast(type).getGenericComponentType(), map);
+ }
+
+ /**
+ * パラメータ化された{@link Collection}の実際の要素型を返す。
+ * <ul>
+ * <li><code>type</code>がパラメータ化された{@link Collection}でない場合は<code>null</code>
+ * を返す。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された{@link Collection}
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された{@link Collection}の実際の要素型
+ */
+ public static Class<?> getActualElementClassOfCollection(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!isTypeOf(type, Collection.class)) {
+ return null;
+ }
+ return getActualClass(getGenericParameter(type, 0), map);
+ }
+
+ /**
+ * パラメータ化された{@link List}の実際の要素型を取得する。
+ * <ul>
+ * <li><code>type</code>がパラメータ化された{@link List}でない場合は<code>null</code>を返す。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された{@link List}
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された{@link List}の実際の要素型
+ */
+ public static Class<?> getActualElementClassOfList(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!isTypeOf(type, List.class)) {
+ return null;
+ }
+ return getActualClass(getGenericParameter(type, 0), map);
+ }
+
+ /**
+ * パラメータ化された{@link Set}の実際の要素型を取得する。
+ * <ul>
+ * <li><code>type</code>がパラメータ化された{@link Set}でない場合は<code>null</code>を返す。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された{@link Set}
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された{@link Set}の実際の要素型
+ */
+ public static Class<?> getActualElementClassOfSet(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!isTypeOf(type, Set.class)) {
+ return null;
+ }
+ return getActualClass(getGenericParameter(type, 0), map);
+ }
+
+ /**
+ * パラメータ化された{@link Map}のキーの実際の型を取得する。
+ * <ul>
+ * <li>キー型がパラメータ化された{@link Map}でない場合は<code>null</code>を返す。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された{@link Map}
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された{@link Map}のキーの実際の型
+ */
+ public static Class<?> getActualKeyClassOfMap(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!isTypeOf(type, Map.class)) {
+ return null;
+ }
+ return getActualClass(getGenericParameter(type, 0), map);
+ }
+
+ /**
+ * パラメータ化された{@link Map}の値の実際の型を取得する。
+ * <ul>
+ * <li><code>type</code>がパラメータ化された{@link Map}でない場合は<code>null</code>を返す。</li>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が型変数の場合はその変数の実際の型引数を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type パラメータ化された{@link Map}
+ * @param map パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ * @return パラメータ化された{@link Map}の値の実際の型
+ */
+ public static Class<?> getActualValueClassOfMap(final Type type, final Map<TypeVariable<?>, Type> map) {
+ if (!isTypeOf(type, Map.class)) {
+ return null;
+ }
+ return getActualClass(getGenericParameter(type, 1), map);
+ }
+
+ /**
+ * パラメータ化された型を要素とする配列の要素型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された型の配列でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された型を要素とする配列
+ * @return パラメータ化された型を要素とする配列の要素型
+ */
+ public static Type getElementTypeOfArray(final Type type) {
+ if (!GenericArrayType.class.isInstance(type)) {
+ return null;
+ }
+ return GenericArrayType.class.cast(type).getGenericComponentType();
+ }
+
+ /**
+ * パラメータ化された{@link Collection}の要素型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された{@link List}でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された{@link List}
+ * @return パラメータ化された{@link List}の要素型
+ */
+ public static Type getElementTypeOfCollection(final Type type) {
+ if (!isTypeOf(type, Collection.class)) {
+ return null;
+ }
+ return getGenericParameter(type, 0);
+ }
+
+ /**
+ * パラメータ化された{@link List}の要素型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された{@link List}でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された{@link List}
+ * @return パラメータ化された{@link List}の要素型
+ */
+ public static Type getElementTypeOfList(final Type type) {
+ if (!isTypeOf(type, List.class)) {
+ return null;
+ }
+ return getGenericParameter(type, 0);
+ }
+
+ /**
+ * パラメータ化された{@link Set}の要素型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された{@link Set}でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された{@link Set}
+ * @return パラメータ化された{@link Set}の要素型
+ */
+ public static Type getElementTypeOfSet(final Type type) {
+ if (!isTypeOf(type, Set.class)) {
+ return null;
+ }
+ return getGenericParameter(type, 0);
+ }
+
+ /**
+ * <code>type</code>の型引数の配列を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された型でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type タイプ
+ * @return <code>type</code>の型引数の配列
+ */
+ public static Type[] getGenericParameter(final Type type) {
+ if (ParameterizedType.class.isInstance(type)) {
+ return ParameterizedType.class.cast(type).getActualTypeArguments();
+ }
+ if (GenericArrayType.class.isInstance(type)) {
+ return getGenericParameter(GenericArrayType.class.cast(type).getGenericComponentType());
+ }
+ return new Type[0];
+ }
+
+ /**
+ * 指定された位置の<code>type</code>の型引数を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された型でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type タイプ
+ * @param index 位置
+ * @return 指定された位置の<code>type</code>の型引数
+ */
+ public static Type getGenericParameter(final Type type, final int index) {
+ if (!ParameterizedType.class.isInstance(type)) {
+ return null;
+ }
+ final Type[] genericParameter = getGenericParameter(type);
+ if (genericParameter == null) {
+ return null;
+ }
+ return genericParameter[index];
+ }
+
+ /**
+ * パラメータ化された{@link Map}のキーの型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された{@link Map}でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された{@link Map}
+ * @return パラメータ化された{@link Map}のキーの型
+ */
+ public static Type getKeyTypeOfMap(final Type type) {
+ if (!isTypeOf(type, Map.class)) {
+ return null;
+ }
+ return getGenericParameter(type, 0);
+ }
+
+ /**
+ * <code>type</code>の原型を取得する。
+ * <ul>
+ * <li><code>type</code>が<code>Class</code>の場合はそのまま返す。</li>
+ * <li><code>type</code>がパラメータ化された型の場合はその原型を返す。</li>
+ * <li><code>type</code>がワイルドカード型の場合は(最初の)上限境界を返す。</li>
+ * <li><code>type</code>が配列の場合はその要素の実際の型の配列を返す。</li>
+ * <li>その他の場合は<code>null</code>を返す。</li>
+ * </ul>
+ *
+ * @param type タイプ
+ * @return <code>type</code>の原型
+ */
+ public static Class<?> getRawClass(final Type type) {
+ if (Class.class.isInstance(type)) {
+ return Class.class.cast(type);
+ }
+ if (ParameterizedType.class.isInstance(type)) {
+ final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
+ return getRawClass(parameterizedType.getRawType());
+ }
+ if (WildcardType.class.isInstance(type)) {
+ final WildcardType wildcardType = WildcardType.class.cast(type);
+ final Type[] types = wildcardType.getUpperBounds();
+ return getRawClass(types[0]);
+ }
+ if (GenericArrayType.class.isInstance(type)) {
+ final GenericArrayType genericArrayType = GenericArrayType.class.cast(type);
+ final Class<?> rawClass = getRawClass(genericArrayType.getGenericComponentType());
+ return Array.newInstance(rawClass, 0).getClass();
+ }
+ return null;
+ }
+
+ /**
+ * パラメータ化された型(クラスまたはインタフェース)が持つ型変数をキー、型引数を値とする{@link Map}を取得する。
+ *
+ * @param clazz パラメータ化された型(クラスまたはインタフェース)
+ * @return パラメータ化された型が持つ型変数をキー、型引数を値とする{@link Map}
+ */
+ public static Map<TypeVariable<?>, Type> getTypeVariableMap(final Class<?> clazz) {
+ final Map<TypeVariable<?>, Type> map = CollectionsUtil.newLinkedHashMap();
+
+ final Class<?> superClass = clazz.getSuperclass();
+ final Type superClassType = clazz.getGenericSuperclass();
+ if (superClass != null) {
+ gatherTypeVariables(superClass, superClassType, map);
+ }
+
+ final Class<?>[] interfaces = clazz.getInterfaces();
+ final Type[] interfaceTypes = clazz.getGenericInterfaces();
+ for (int i = 0; i < interfaces.length; ++i) {
+ gatherTypeVariables(interfaces[i], interfaceTypes[i], map);
+ }
+
+ return map;
+ }
+
+ /**
+ * パラメータ化された{@link Map}の値の型を取得する。
+ * <p>
+ * <code>type</code>がパラメータ化された{@link Map}でない場合は<code>null</code>を返す。
+ * </p>
+ *
+ * @param type パラメータ化された{@link Map}
+ * @return パラメータ化された{@link Map}の値の型
+ */
+ public static Type getValueTypeOfMap(final Type type) {
+ if (!isTypeOf(type, Map.class)) {
+ return null;
+ }
+ return getGenericParameter(type, 1);
+ }
+
+ /**
+ * <code>type</code>の原型が<code>clazz</code>に代入可能であれば<code>true</code>を、
+ * それ以外の場合は<code>false</code>を取得する。
+ *
+ * @param type タイプ
+ * @param clazz クラス
+ * @return <code>type</code>の原型が<code>clazz</code>に代入可能であれば<code>true</code>
+ */
+ public static boolean isTypeOf(final Type type, final Class<?> clazz) {
+ if (Class.class.isInstance(type)) {
+ return clazz.isAssignableFrom(Class.class.cast(type));
+ }
+ if (ParameterizedType.class.isInstance(type)) {
+ final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
+ return isTypeOf(parameterizedType.getRawType(), clazz);
+ }
+ return false;
+ }
+
+ private GenericUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/GenericUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/InputStreamUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/InputStreamUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/InputStreamUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link InputStream}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ *
+ */
+public class InputStreamUtil {
+
+ /** TODO for kato */
+ private static final int BUFF_SIZE = 8192;
+
+
+ /**
+ * {@link InputStream#available()}の例外処理をラップしたメソッド。
+ *
+ * @param is {@link InputStream}
+ * @return 可能なサイズ
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static int available(InputStream is) throws IORuntimeException {
+ try {
+ return is.available();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * {@link InputStream}を閉じる。
+ *
+ * @param is {@link InputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ * @see InputStream#close()
+ */
+ public static void close(InputStream is) throws IORuntimeException {
+ if (is == null) {
+ return;
+ }
+ try {
+ is.close();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * {@link InputStream}の内容を {@link OutputStream}にコピーします。
+ *
+ * @param is {@link InputStream}
+ * @param os {@link OutputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static final void copy(InputStream is, OutputStream os) throws IORuntimeException {
+ byte[] buf = new byte[BUFF_SIZE];
+ try {
+ int n = 0;
+ while ((n = is.read(buf, 0, buf.length)) != -1) {
+ os.write(buf, 0, n);
+ }
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * {@link InputStream}からbyteの配列を取得します。
+ *
+ * @param is {@link InputStream}
+ * @return byteの配列
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static final byte[] getBytes(InputStream is) throws IORuntimeException {
+ byte[] bytes = null;
+ byte[] buf = new byte[BUFF_SIZE];
+ try {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ int n = 0;
+ while ((n = is.read(buf, 0, buf.length)) != -1) {
+ baos.write(buf, 0, n);
+ }
+ bytes = baos.toByteArray();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ } finally {
+ if (is != null) {
+ close(is);
+ }
+ }
+ return bytes;
+ }
+
+ private InputStreamUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/InputStreamUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarFileUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarFileUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarFileUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,132 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.jar.JarFile;
+import java.util.zip.ZipEntry;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link JarFile}を扱うユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public class JarFileUtil {
+
+ /**
+ * Jarファイルを閉じる。
+ *
+ * @param jarFile Jarファイル
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static void close(final JarFile jarFile) {
+ try {
+ jarFile.close();
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたJarファイルを読み取るための<code>JarFile</code>を作成する。
+ *
+ * @param file ファイル
+ * @return 指定されたJarファイルを読み取るための<code>JarFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static JarFile create(final File file) {
+ try {
+ return new JarFile(file);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたJarファイルを読み取るための<code>JarFile</code>を作成する。
+ *
+ * @param file ファイルパス
+ * @return 指定されたJarファイルを読み取るための<code>JarFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static JarFile create(final String file) {
+ try {
+ return new JarFile(file);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたJarファイルエントリの内容を読み込むための入力ストリームを取得する。
+ *
+ * @param file Jarファイル
+ * @param entry Jarファイルエントリ
+ * @return 指定されたJarファイルエントリの内容を読み込むための入力ストリーム
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static InputStream getInputStream(final JarFile file, final ZipEntry entry) {
+ try {
+ return file.getInputStream(entry);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * URLで指定されたJarファイルを読み取るための<code>JarFile</code>を作成する。
+ *
+ * @param jarUrl Jarファイルを示すURL
+ * @return 指定されたJarファイルを読み取るための<code>JarFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static JarFile toJarFile(final URL jarUrl) {
+ final URLConnection con = URLUtil.openConnection(jarUrl);
+ if (con instanceof JarURLConnection) {
+ return JarURLConnectionUtil.getJarFile((JarURLConnection) con);
+ }
+ return create(new File(toJarFilePath(jarUrl)));
+ }
+
+ /**
+ * URLで指定されたJarファイルのパスを返します。
+ *
+ * @param jarUrl Jarファイルを示すURL
+ * @return URLで指定されたJarファイルのパス
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static String toJarFilePath(final URL jarUrl) {
+ final URL nestedUrl = URLUtil.create(jarUrl.getPath());
+ final String nestedUrlPath = nestedUrl.getPath();
+ final int pos = nestedUrlPath.lastIndexOf('!');
+ final String jarFilePath = nestedUrlPath.substring(0, pos);
+ final File jarFile = new File(URLUtil.decode(jarFilePath, "UTF8"));
+ return FileUtil.getCanonicalPath(jarFile);
+ }
+
+ private JarFileUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarFileUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarInputStreamUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarInputStreamUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarInputStreamUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.JarEntry;
+import java.util.jar.JarInputStream;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link JarInputStream}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public class JarInputStreamUtil {
+
+ /**
+ * {@link JarInputStream}を作成する。
+ *
+ * @param is {@link InputStream}
+ * @return {@link JarInputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ * @see JarInputStream#JarInputStream(InputStream)
+ */
+ public static JarInputStream create(final InputStream is) throws IORuntimeException {
+ try {
+ return new JarInputStream(is);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * {@link JarInputStream#getNextJarEntry()}の例外処理をラップするメソッド。
+ *
+ * @param is {@link JarInputStream}
+ * @return {@link JarEntry}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ * @see JarInputStream#getNextJarEntry()
+ */
+ public static JarEntry getNextJarEntry(final JarInputStream is) throws IORuntimeException {
+ try {
+ return is.getNextJarEntry();
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private JarInputStreamUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarInputStreamUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarURLConnectionUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarURLConnectionUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarURLConnectionUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.IOException;
+import java.net.JarURLConnection;
+import java.util.jar.JarFile;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link JarURLConnection}用のユーティリティクラスです。
+ *
+ * @author j5ik2o
+ *
+ */
+public class JarURLConnectionUtil {
+
+ /**
+ * {@link JarURLConnection#getJarFile()}の例外処理をラップするメソッドです。
+ *
+ * @param conn {@link JarURLConnection}
+ * @return {@link JarFile}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static JarFile getJarFile(JarURLConnection conn) throws IORuntimeException {
+ try {
+ return conn.getJarFile();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private JarURLConnectionUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/JarURLConnectionUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/MethodUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/MethodUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/MethodUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,364 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+import org.jiemamy.composer.importer.exception.IllegalAccessRuntimeException;
+import org.jiemamy.composer.importer.exception.InvocationTargetRuntimeException;
+
+/**
+ * {@link Method}用のユーティリティクラスです。
+ *
+ * @author j5ik2o
+ *
+ */
+public class MethodUtil {
+
+ /** TODO for kato */
+ private static final int BUFF_SIZE = 100;
+
+ private static final Method IS_BRIDGE_METHOD = getIsBridgeMethod();
+
+ private static final Method IS_SYNTHETIC_METHOD = getIsSyntheticMethod();
+
+ /**
+ * {@link #getElementTypeOfCollectionFromParameterType(Method, int)}への定数参照。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_COLLECTION_FROM_PARAMETER_METHOD =
+ getElementTypeFromParameterMethod("Collection");
+
+ /**
+ * {@link #getElementTypeOfCollectionFromReturnType(Method)}への定数参照。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_COLLECTION_FROM_RETURN_METHOD =
+ getElementTypeFromReturnMethod("Collection");
+
+ /**
+ * {@link #getElementTypeOfListFromParameterType(Method, int)}への定数参照。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_LIST_FROM_PARAMETER_METHOD =
+ getElementTypeFromParameterMethod("List");
+
+ /**
+ * {@link #getElementTypeOfListFromReturnType(Method)}への定数参照。。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_LIST_FROM_RETURN_METHOD = getElementTypeFromReturnMethod("List");
+
+ /**
+ * {@link #getElementTypeOfSetFromParameterType(Method, int)}への定数参照。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_SET_FROM_PARAMETER_METHOD =
+ getElementTypeFromParameterMethod("Set");
+
+ /**
+ * {@link #getElementTypeOfSetFromReturnType(Method)}への定数参照。。
+ */
+ protected static final Method GET_ELEMENT_TYPE_OF_SET_FROM_RETURN_METHOD = getElementTypeFromReturnMethod("Set");
+
+
+ /**
+ * <code>ReflectionUtil#getElementTypeOf<var>Xxx</var>FromParameter</code>の{@link Method}を取得する。
+ *
+ * @param type 取得するメソッドが対象とする型名
+ *
+ * @return {@link Method}
+ */
+ protected static Method getElementTypeFromParameterMethod(final String type) {
+ try {
+ final Class<?> reflectionUtilClass = ReflectionUtil.class;
+ return reflectionUtilClass.getMethod("getElementTypeOf" + type + "FromParameterType", new Class[] {
+ Method.class,
+ int.class
+ });
+ } catch (final Throwable ignore) {
+ // ignore
+ }
+ return null;
+ }
+
+ /**
+ * <code>ReflectionUtil#getElementTypeOf<var>Xxx</var>FromReturn</code>の{@link Method}を取得する。
+ *
+ * @param type 取得するメソッドが対象とする型名
+ * @return {@link Method}
+ */
+ protected static Method getElementTypeFromReturnMethod(final String type) {
+ try {
+ final Class<?> reflectionUtilClass = ReflectionUtil.class;
+ return reflectionUtilClass.getMethod("getElementTypeOf" + type + "FromReturnType", new Class[] {
+ Method.class
+ });
+ } catch (final Throwable ignore) {
+ // ignore
+ }
+ return null;
+ }
+
+ /**
+ * メソッドの引数型 (パラメタ化されたコレクション)の要素型を取得する。
+ *
+ * @param method メソッド
+ * @param position パラメタ化されたコレクションが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollectionFromParameterType(final Method method, final int position) {
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_COLLECTION_FROM_PARAMETER_METHOD, null, new Object[] {
+ method,
+ Integer.valueOf(position)
+ });
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollectionFromReturnType(final Method method) {
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_COLLECTION_FROM_RETURN_METHOD, null, new Object[] {
+ method
+ });
+ }
+
+ /**
+ * メソッドの引数型 (パラメタ化されたリスト) の要素型を取得する。
+ *
+ * @param method メソッド
+ * @param position パラメタ化されたリストが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromParameterType(final Method method, final int position) {
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_LIST_FROM_PARAMETER_METHOD, null, new Object[] {
+ method,
+ Integer.valueOf(position)
+ });
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたリストの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromReturnType(final Method method) {
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_LIST_FROM_RETURN_METHOD, null, new Object[] {
+ method
+ });
+ }
+
+ /**
+ * メソッドの引数型 (パラメタ化されたセット) の要素型を取得する。
+ *
+ * @param method メソッド
+ * @param position パラメタ化されたコレクションが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSetFromParameterType(final Method method, final int position) {
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_SET_FROM_PARAMETER_METHOD, null, new Object[] {
+ method,
+ Integer.valueOf(position)
+ });
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたセットの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSetFromReturnType(final Method method) {
+ if (GET_ELEMENT_TYPE_OF_SET_FROM_RETURN_METHOD == null) {
+ return null;
+ }
+ return (Class<?>) MethodUtil.invoke(GET_ELEMENT_TYPE_OF_SET_FROM_RETURN_METHOD, null, new Object[] {
+ method
+ });
+ }
+
+ private static Method getIsBridgeMethod() {
+ try {
+ return Method.class.getMethod("isBridge", null);
+ } catch (final NoSuchMethodException e) {
+ return null;
+ }
+ }
+
+ private static Method getIsSyntheticMethod() {
+ try {
+ return Method.class.getMethod("isSynthetic", null);
+ } catch (final NoSuchMethodException e) {
+ return null;
+ }
+ }
+
+ /**
+ * シグニチャを取得する。
+ *
+ * @param methodName メソッド名
+ * @param argTypes 引数
+ * @return シグニチャ
+ */
+ public static String getSignature(String methodName, Class<?>[] argTypes) {
+ StringBuffer buf = new StringBuffer(BUFF_SIZE);
+ buf.append(methodName);
+ buf.append("(");
+ if (argTypes != null) {
+ for (int i = 0; i < argTypes.length; ++i) {
+ if (i > 0) {
+ buf.append(", ");
+ }
+ buf.append(argTypes[i].getName());
+ }
+ }
+ buf.append(")");
+ return buf.toString();
+ }
+
+ /**
+ * シグニチャを取得する。
+ *
+ * @param methodName メソッド名
+ * @param methodArgs メソッドの引数
+ * @return シグニチャ
+ */
+ public static String getSignature(String methodName, Object[] methodArgs) {
+ StringBuffer buf = new StringBuffer(BUFF_SIZE);
+ buf.append(methodName);
+ buf.append("(");
+ if (methodArgs != null) {
+ for (int i = 0; i < methodArgs.length; ++i) {
+ if (i > 0) {
+ buf.append(", ");
+ }
+ if (methodArgs[i] != null) {
+ buf.append(methodArgs[i].getClass().getName());
+ } else {
+ buf.append("null");
+ }
+ }
+ }
+ buf.append(")");
+ return buf.toString();
+ }
+
+ /**
+ * {@link Method#invoke(Object, Object[])}の例外処理をラップする。
+ *
+ * @param method メソッド
+ * @param target ターゲット
+ * @param args 引数
+ * @return 戻り値
+ * @throws InvocationTargetRuntimeException {@link InvocationTargetException}が発生した場合
+ * @throws IllegalAccessRuntimeException {@link IllegalAccessException}が発生した場合
+ * @see Method#invoke(Object, Object[])
+ */
+ public static Object invoke(Method method, Object target, Object[] args) throws InvocationTargetRuntimeException,
+ IllegalAccessRuntimeException {
+ try {
+ return method.invoke(target, args);
+ } catch (InvocationTargetException ex) {
+ Throwable t = ex.getCause();
+ if (t instanceof RuntimeException) {
+ throw (RuntimeException) t;
+ }
+ if (t instanceof Error) {
+ throw (Error) t;
+ }
+ throw new InvocationTargetRuntimeException(method.getDeclaringClass(), ex);
+ } catch (IllegalAccessException ex) {
+ throw new IllegalAccessRuntimeException(method.getDeclaringClass(), ex);
+ }
+ }
+
+ /**
+ * <code>abstract</code>かどうかを取得する。
+ *
+ * @param method メソッド
+ * @return <code>abstract</code>かどうか
+ */
+ public static boolean isAbstract(Method method) {
+ int mod = method.getModifiers();
+ return Modifier.isAbstract(mod);
+ }
+
+ /**
+ * ブリッジメソッドかどうか取得する。
+ *
+ * @param method {@link Method}
+ * @return ブリッジメソッドかどうか
+ */
+ public static boolean isBridgeMethod(final Method method) {
+ if (IS_BRIDGE_METHOD == null) {
+ return false;
+ }
+ return ((Boolean) MethodUtil.invoke(IS_BRIDGE_METHOD, method, null)).booleanValue();
+ }
+
+ /**
+ * equalsメソッドかどうかを取得する。
+ *
+ * @param method {@link Method}
+ * @return equalsメソッドかどうか
+ */
+ public static boolean isEqualsMethod(Method method) {
+ return method != null && method.getName().equals("equals") && method.getReturnType() == boolean.class
+ && method.getParameterTypes().length == 1 && method.getParameterTypes()[0] == Object.class;
+ }
+
+ /**
+ * hashCodeメソッドかどうか取得する。
+ *
+ * @param method {@link Method}
+ * @return hashCodeメソッドかどうか
+ */
+ public static boolean isHashCodeMethod(Method method) {
+ return method != null && method.getName().equals("hashCode") && method.getReturnType() == int.class
+ && method.getParameterTypes().length == 0;
+ }
+
+ /**
+ * 合成メソッドかどうかを取得する。
+ *
+ * @param method {@link Method}
+ * @return 合成メソッドかどうか
+ */
+ public static boolean isSyntheticMethod(final Method method) {
+ if (IS_SYNTHETIC_METHOD == null) {
+ return false;
+ }
+ return ((Boolean) MethodUtil.invoke(IS_SYNTHETIC_METHOD, method, null)).booleanValue();
+ }
+
+ /**
+ * toStringメソッドかどうか取得する。
+ *
+ * @param method {@link Method}
+ * @return toStringメソッドかどうか
+ */
+ public static boolean isToStringMethod(Method method) {
+ return method != null && method.getName().equals("toString") && method.getReturnType() == String.class
+ && method.getParameterTypes().length == 0;
+ }
+
+ private MethodUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/MethodUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/OutputStreamUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/OutputStreamUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/OutputStreamUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link OutputStream}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public final class OutputStreamUtil {
+
+ /**
+ * {@link OutputStream}を閉じます。
+ *
+ * @param out {@link OutputStream}
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static void close(OutputStream out) throws IORuntimeException {
+ if (out == null) {
+ return;
+ }
+ try {
+ out.close();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * {@link OutputStream}をflushします。
+ *
+ * @param out {@link OutputStream}
+ */
+ public static void flush(OutputStream out) {
+ if (out == null) {
+ return;
+ }
+ try {
+ out.flush();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ private OutputStreamUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/OutputStreamUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ReflectionUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ReflectionUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ReflectionUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,510 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Type;
+
+import org.jiemamy.composer.importer.exception.ClassNotFoundRuntimeException;
+import org.jiemamy.composer.importer.exception.IllegalAccessRuntimeException;
+import org.jiemamy.composer.importer.exception.InstantiationRuntimeException;
+import org.jiemamy.composer.importer.exception.InvocationTargetRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchConstructorRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchFieldRuntimeException;
+import org.jiemamy.composer.importer.exception.NoSuchMethodRuntimeException;
+
+
+/**
+ * リフレクションのためのユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public abstract class ReflectionUtil {
+
+ /**
+ * 現在のスレッドのコンテキストクラスローダを使って、 指定された文字列名を持つクラスまたはインタフェースに関連付けられた、
+ * {@link Class}オブジェクトを取得する。
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param className 要求するクラスの完全修飾名
+ * @return 指定された名前を持つクラスの{@link Class}オブジェクト
+ * @throws ClassNotFoundRuntimeException クラスが見つからなかった場合
+ * @see Class#forName(String)
+ */
+ public static <T>Class<T> forName(final String className) throws ClassNotFoundRuntimeException {
+ return forName(className, Thread.currentThread().getContextClassLoader());
+ }
+
+ /**
+ * 指定されたクラスローダを使って、 指定された文字列名を持つクラスまたはインタフェースに関連付けられた{@link Class}オブジェクトを取得する。
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param className 要求するクラスの完全修飾名
+ * @param loader クラスのロード元である必要があるクラスローダ
+ * @return 指定された名前を持つクラスの{@link Class}オブジェクト
+ * @throws ClassNotFoundRuntimeException クラスが見つからなかった場合
+ * @see Class#forName(String, boolean, ClassLoader)
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>Class<T> forName(final String className, final ClassLoader loader)
+ throws ClassNotFoundRuntimeException {
+ try {
+ return (Class<T>) Class.forName(className, true, loader);
+ } catch (final ClassNotFoundException e) {
+ throw new ClassNotFoundRuntimeException(e);
+ }
+ }
+
+ /**
+ * 現在のスレッドのコンテキストクラスローダを使って、 指定された文字列名を持つクラスまたはインタフェースに関連付けられた、
+ * {@link Class}オブジェクトを取得する。
+ * <p>
+ * クラスが見つからなかった場合は{@code null}を取得する。
+ * </p>
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param className 要求するクラスの完全修飾名
+ * @return 指定された名前を持つクラスの{@link Class}オブジェクト
+ * @see Class#forName(String)
+ */
+ public static <T>Class<T> forNameNoException(final String className) {
+ return forNameNoException(className, Thread.currentThread().getContextClassLoader());
+ }
+
+ /**
+ * 指定されたクラスローダを使って、 指定された文字列名を持つクラスまたはインタフェースに関連付けられた、 {@link Class}オブジェクトを取得する。
+ * <p>
+ * クラスが見つからなかった場合は{@code null}を取得する。
+ * </p>
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param className 要求するクラスの完全修飾名
+ * @param loader クラスのロード元である必要があるクラスローダ
+ * @return 指定された名前を持つクラスの{@link Class}オブジェクト
+ * @see Class#forName(String)
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>Class<T> forNameNoException(final String className, final ClassLoader loader) {
+ try {
+ return (Class<T>) Class.forName(className, true, loader);
+ } catch (final Throwable ignore) {
+ return null;
+ }
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスの指定された{@code public}コンストラクタをリフレクトする{@link Constructor}オブジェクトを取得する。
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param argTypes パラメータ配列
+ * @return 指定された{@code argTypes}と一致する{@code public}コンストラクタの{@link Constructor}オブジェクト
+ * @throws NoSuchConstructorRuntimeException 一致するコンストラクタが見つからない場合
+ * @see Class#getConstructor(Class[])
+ */
+ public static <T>Constructor<T> getConstructor(final Class<T> clazz, final Class<?>... argTypes)
+ throws NoSuchConstructorRuntimeException {
+ try {
+ return clazz.getConstructor(argTypes);
+ } catch (final NoSuchMethodException e) {
+ throw new NoSuchConstructorRuntimeException(clazz, argTypes, e);
+ }
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスまたはインタフェースの指定されたコンストラクタをリフレクトする{@link Constructor}オブジェクトを取得する。
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param argTypes パラメータ配列
+ * @return 指定された{@code argTypes}と一致するコンストラクタの{@link Constructor}オブジェクト
+ * @throws NoSuchConstructorRuntimeException 一致するコンストラクタが見つからない場合
+ * @see Class#getDeclaredConstructor(Class[])
+ */
+ public static <T>Constructor<T> getDeclaredConstructor(final Class<T> clazz, final Class<?>... argTypes)
+ throws NoSuchConstructorRuntimeException {
+ try {
+ return clazz.getDeclaredConstructor(argTypes);
+ } catch (final NoSuchMethodException e) {
+ throw new NoSuchConstructorRuntimeException(clazz, argTypes, e);
+ }
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスまたはインタフェースの指定された宣言フィールドをリフレクトする{@link Field}オブジェクトを取得する。
+ *
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param name フィールド名
+ * @return {@code name}で指定されたこのクラスの{@link Field}オブジェクト
+ * @throws NoSuchFieldRuntimeException 指定された名前のフィールドが見つからない場合
+ * @see Class#getDeclaredField(String)
+ */
+ public static Field getDeclaredField(final Class<?> clazz, final String name) throws NoSuchFieldRuntimeException {
+ try {
+ return clazz.getDeclaredField(name);
+ } catch (final NoSuchFieldException e) {
+ throw new NoSuchFieldRuntimeException(clazz, name, e);
+ }
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスまたはインタフェースの指定されたメンバメソッドをリフレクトする{@link Method}オブジェクトを取得する。
+ *
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param name メソッドの名前
+ * @param argTypes パラメータのリスト
+ * @return 指定された{@code name}および{@code argTypes}と一致する{@link Method}オブジェクト
+ * @throws NoSuchMethodRuntimeException 一致するメソッドが見つからない場合
+ * @see Class#getDeclaredMethod(String, Class[])
+ */
+ public static Method getDeclaredMethod(final Class<?> clazz, final String name, final Class<?>... argTypes)
+ throws NoSuchMethodRuntimeException {
+ try {
+ return clazz.getDeclaredMethod(name, argTypes);
+ } catch (final NoSuchMethodException e) {
+ throw new NoSuchMethodRuntimeException(clazz, name, argTypes, e);
+ }
+ }
+
+ /**
+ * パラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param parameterizedCollection パラメタ化されたコレクションの型
+ * @return パラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollection(final Type parameterizedCollection) {
+ return GenericUtil.getRawClass(GenericUtil.getElementTypeOfCollection(parameterizedCollection));
+ }
+
+ /**
+ * 指定されたフィールドのパラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return 指定されたフィールドのパラメタ化されたコレクションの要素型 since 2.4.18
+ * since 2.4.18
+ */
+ public static Class<?> getElementTypeOfCollectionFromFieldType(final Field field) {
+ final Type type = field.getGenericType();
+ return getElementTypeOfCollection(type);
+ }
+
+ /**
+ * 指定されたメソッドの引数型として宣言されているパラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param method メソッド
+ * @param parameterPosition パラメタ化されたコレクションが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollectionFromParameterType(final Method method, final int parameterPosition) {
+ final Type[] parameterTypes = method.getGenericParameterTypes();
+ return getElementTypeOfCollection(parameterTypes[parameterPosition]);
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたコレクションの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたコレクションの要素型
+ */
+ public static Class<?> getElementTypeOfCollectionFromReturnType(final Method method) {
+ return getElementTypeOfCollection(method.getGenericReturnType());
+ }
+
+ /**
+ * パラメタ化されたリストの要素型を取得する。
+ *
+ * @param parameterizedList パラメタ化されたリストの型
+ * @return パラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfList(final Type parameterizedList) {
+ return GenericUtil.getRawClass(GenericUtil.getElementTypeOfList(parameterizedList));
+ }
+
+ /**
+ * 指定されたフィールドのパラメタ化されたリストの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return 指定されたフィールドのパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromFieldType(final Field field) {
+ final Type type = field.getGenericType();
+ return getElementTypeOfList(type);
+ }
+
+ /**
+ * 指定されたメソッドの引数型として宣言されているパラメタ化されたリストの要素型を取得する。
+ *
+ * @param method メソッド
+ * @param parameterPosition パラメタ化されたリストが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromParameterType(final Method method, final int parameterPosition) {
+ final Type[] parameterTypes = method.getGenericParameterTypes();
+ return getElementTypeOfList(parameterTypes[parameterPosition]);
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたリストの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたリストの要素型
+ */
+ public static Class<?> getElementTypeOfListFromReturnType(final Method method) {
+ return getElementTypeOfList(method.getGenericReturnType());
+ }
+
+ /**
+ * パラメタ化されたセットの要素型を取得する。
+ *
+ * @param parameterizedSet パラメタ化されたセットの型
+ * @return パラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSet(final Type parameterizedSet) {
+ return GenericUtil.getRawClass(GenericUtil.getElementTypeOfSet(parameterizedSet));
+ }
+
+ /**
+ * 指定されたフィールドのパラメタ化されたセットの要素型を取得する。
+ *
+ * @param field フィールド
+ * @return 指定されたフィールドのパラメタ化されたセットの要素型 since 2.4.18
+ */
+ public static Class<?> getElementTypeOfSetFromFieldType(final Field field) {
+ final Type type = field.getGenericType();
+ return getElementTypeOfSet(type);
+ }
+
+ /**
+ * 指定されたメソッドの引数型として宣言されているパラメタ化されたセットの要素型を取得する。
+ *
+ * @param method メソッド
+ * @param parameterPosition パラメタ化されたセットが宣言されているメソッド引数の位置
+ * @return 指定されたメソッドの引数型として宣言されているパラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSetFromParameterType(final Method method, final int parameterPosition) {
+ final Type[] parameterTypes = method.getGenericParameterTypes();
+ return getElementTypeOfSet(parameterTypes[parameterPosition]);
+ }
+
+ /**
+ * 指定されたメソッドの戻り値型として宣言されているパラメタ化されたセットの要素型を取得する。
+ *
+ * @param method メソッド
+ * @return 指定されたメソッドの戻り値型として宣言されているパラメタ化されたセットの要素型
+ */
+ public static Class<?> getElementTypeOfSetFromReturnType(final Method method) {
+ return getElementTypeOfSet(method.getGenericReturnType());
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスまたはインタフェースの指定された{@code public}メンバフィールドをリフレクトする{@link Field}オブジェクトを取得する。
+ *
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param name フィールド名
+ * @return {@code name}で指定されたこのクラスの{@link Field}オブジェクト
+ * @throws NoSuchFieldRuntimeException 指定された名前のフィールドが見つからない場合
+ * @see Class#getField(String)
+ */
+ public static Field getField(final Class<?> clazz, final String name) throws NoSuchFieldRuntimeException {
+ try {
+ return clazz.getField(name);
+ } catch (final NoSuchFieldException e) {
+ throw new NoSuchFieldRuntimeException(clazz, name, e);
+ }
+ }
+
+ /**
+ * {@link Class}オブジェクトが表すクラスまたはインタフェースの指定された{@code public}メンバメソッドをリフレクトする{@link Method}オブジェクトを取得する。
+ *
+ * @param clazz クラスの{@link Class}オブジェクト
+ * @param name メソッドの名前
+ * @param argTypes パラメータのリスト
+ * @return 指定された{@code name}および{@code argTypes}と一致する{@link Method}オブジェクト
+ * @throws NoSuchMethodRuntimeException 一致するメソッドが見つからない場合
+ * @see Class#getMethod(String, Class[])
+ */
+ public static Method getMethod(final Class<?> clazz, final String name, final Class<?>... argTypes)
+ throws NoSuchMethodRuntimeException {
+ try {
+ return clazz.getMethod(name, argTypes);
+ } catch (final NoSuchMethodException e) {
+ throw new NoSuchMethodRuntimeException(clazz, name, argTypes, e);
+ }
+ }
+
+ /**
+ * 指定されたオブジェクトについて、{@link Field}によって表される{@code static}フィールドの値を取得する。
+ *
+ * @param <T> フィールドの型
+ * @param field フィールド
+ * @return {@code static}フィールドで表現される値
+ * @throws IllegalAccessRuntimeException 基本となるフィールドにアクセスできない場合
+ * @see Field#get(Object)
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>T getStaticValue(final Field field) throws IllegalAccessRuntimeException {
+ return (T) getValue(field, null);
+ }
+
+ /**
+ * 指定されたオブジェクトについて、{@link Field}によって表されるフィールドの値を取得する。
+ *
+ * @param <T> フィールドの型
+ * @param field フィールド
+ * @param target 表現されるフィールド値の抽出元オブジェクト
+ * @return オブジェクト{@code obj}内で表現される値
+ * @throws IllegalAccessRuntimeException 基本となるフィールドにアクセスできない場合
+ * @see Field#get(Object)
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>T getValue(final Field field, final Object target) throws IllegalAccessRuntimeException {
+ try {
+ return (T) field.get(target);
+ } catch (final IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), e);
+ }
+ }
+
+ /**
+ * {@link Method}オブジェクトによって表される基本となるメソッドを、指定したオブジェクトに対して指定したパラメータで呼び出す。
+ *
+ * @param <T> メソッドの戻り値の型
+ * @param method メソッド
+ * @param target 基本となるメソッドの呼び出し元のオブジェクト
+ * @param args メソッド呼び出しに使用される引数
+ * @return このオブジェクトが表すメソッドを、パラメータ{@code args}を使用して{@code obj}にディスパッチした結果
+ * @throws IllegalAccessRuntimeException この{@link Method}オブジェクトがJava言語アクセス制御を実施し、 基本となるメソッドにアクセスできない場合
+ * @throws InvocationTargetRuntimeException 基本となるメソッドが例外をスローする場合
+ * @see Method#invoke(Object, Object[])
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>T invoke(final Method method, final Object target, final Object... args)
+ throws IllegalAccessRuntimeException, InvocationTargetRuntimeException {
+ try {
+ return (T) method.invoke(target, args);
+ } catch (final IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(method.getDeclaringClass(), e);
+ } catch (final InvocationTargetException e) {
+ throw new InvocationTargetRuntimeException(method.getDeclaringClass(), e);
+ }
+ }
+
+ /**
+ * {@link Method}オブジェクトによって表される基本となる{@code static}メソッドを、指定したパラメータで呼び出す。
+ *
+ * @param <T> メソッドの戻り値の型
+ * @param method メソッド
+ * @param args メソッド呼び出しに使用される引数
+ * @return このオブジェクトが表す{@code static}メソッドを、パラメータ{@code args}を使用してディスパッチした結果
+ * @throws IllegalAccessRuntimeException この{@link Method}オブジェクトがJava言語アクセス制御を実施し、基本となるメソッドにアクセスできない場合
+ * @throws InvocationTargetRuntimeException 基本となるメソッドが例外をスローする場合
+ * @see Method#invoke(Object, Object[])
+ */
+ @SuppressWarnings("unchecked")
+ public static <T>T invokeStatic(final Method method, final Object... args) throws IllegalAccessRuntimeException,
+ InvocationTargetRuntimeException {
+ return (T) invoke(method, null, args);
+ }
+
+ /**
+ * 指定されたクラスのデフォルトコンストラクタで、クラスの新しいインスタンスを作成および初期化する。
+ *
+ * @param <T> {@link Class}オブジェクトが表すクラス
+ * @param clazz クラスを表す{@link Class}オブジェクト
+ * @return このオブジェクトが表すコンストラクタを呼び出すことで作成される新規オブジェクト
+ * @throws InstantiationRuntimeException 基本となるコンストラクタを宣言するクラスが{@code abstract}クラスを表す場合
+ * @throws IllegalAccessRuntimeException 実パラメータ数と仮パラメータ数が異なる場合、
+ * プリミティブ引数のラップ解除変換が失敗した場合、 またはラップ解除後、
+ * メソッド呼び出し変換によってパラメータ値を対応する仮パラメータ型に変換できない場合、
+ * このコンストラクタが列挙型に関連している場合
+ * @see Constructor#newInstance(Object[])
+ */
+ public static <T>T newInstance(final Class<T> clazz) throws InstantiationRuntimeException,
+ IllegalAccessRuntimeException {
+ try {
+ return clazz.newInstance();
+ } catch (final InstantiationException e) {
+ throw new InstantiationRuntimeException(clazz, e);
+ } catch (final IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(clazz, e);
+ }
+ }
+
+ /**
+ * 指定された初期化パラメータで、コンストラクタの宣言クラスの新しいインスタンスを作成および初期化する。
+ *
+ * @param <T> コンストラクタの宣言クラス
+ * @param constructor コンストラクタ
+ * @param args コンストラクタ呼び出しに引数として渡すオブジェクトの配列
+ * @return コンストラクタを呼び出すことで作成される新規オブジェクト
+ * @throws InstantiationRuntimeException 基本となるコンストラクタを宣言するクラスが{@code abstract}クラスを表す場合
+ * @throws IllegalAccessRuntimeException 実パラメータ数と仮パラメータ数が異なる場合、
+ * プリミティブ引数のラップ解除変換が失敗した場合、 またはラップ解除後、
+ * メソッド呼び出し変換によってパラメータ値を対応する仮パラメータ型に変換できない場合、
+ * このコンストラクタが列挙型に関連している場合
+ * @see Constructor#newInstance(Object[])
+ */
+ public static <T>T newInstance(final Constructor<T> constructor, final Object... args)
+ throws InstantiationRuntimeException, IllegalAccessRuntimeException {
+ try {
+ return constructor.newInstance(args);
+ } catch (final InstantiationException e) {
+ throw new InstantiationRuntimeException(constructor.getDeclaringClass(), e);
+ } catch (final IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(constructor.getDeclaringClass(), e);
+ } catch (final InvocationTargetException e) {
+ throw new InvocationTargetRuntimeException(constructor.getDeclaringClass(), e);
+ }
+ }
+
+ /**
+ * {@link Field}オブジェクトによって表される{@code static}フィールドを、指定された新しい値に設定する。
+ *
+ * @param field フィールド
+ * @param value {@code static}フィールドの新しい値
+ * @throws IllegalAccessRuntimeException 基本となるフィールドにアクセスできない場合
+ * @see Field#set(Object, Object)
+ */
+ public static void setStaticValue(final Field field, final Object value) throws IllegalAccessRuntimeException {
+ setValue(field, null, value);
+ }
+
+ /**
+ * {@link Field}オブジェクトによって表される指定されたオブジェクト引数のフィールドを、指定された新しい値に設定する。
+ *
+ * @param field フィールド
+ * @param target フィールドを変更するオブジェクト
+ * @param value 変更中の{@code target}の新しいフィールド値
+ * @throws IllegalAccessRuntimeException 基本となるフィールドにアクセスできない場合
+ * @see Field#set(Object, Object)
+ */
+ public static void setValue(final Field field, final Object target, final Object value)
+ throws IllegalAccessRuntimeException {
+ try {
+ field.set(target, value);
+ } catch (final IllegalAccessException e) {
+ throw new IllegalAccessRuntimeException(field.getDeclaringClass(), e);
+ }
+ }
+
+ private ReflectionUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ReflectionUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceBundleUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceBundleUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceBundleUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * {@link ResourceBundle}用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ *
+ */
+public class ResourceBundleUtil {
+
+ /**
+ * {@link Map}に変換します。
+ *
+ * @param bundle バンドル
+ * @return {@link Map}
+ */
+ public static final Map<String, String> convertMap(ResourceBundle bundle) {
+ Map<String, String> ret = new HashMap<String, String>();
+ for (Enumeration<String> e = bundle.getKeys(); e.hasMoreElements();) {
+ String key = e.nextElement();
+ String value = bundle.getString(key);
+ ret.put(key, value);
+ }
+ return ret;
+ }
+
+ /**
+ * {@link Map}に変換します。
+ *
+ * @param name 名前
+ * @param locale ロケール
+ * @return {@link Map}
+ */
+ public static final Map<String, String> convertMap(String name, Locale locale) {
+ ResourceBundle bundle = getBundle(name, locale);
+ return convertMap(bundle);
+ }
+
+ /**
+ * バンドルを返します。 見つからない場合は、<code>null</code>を返します。
+ *
+ * @param name 名前
+ * @param locale ロケール
+ * @return {@link ResourceBundle}
+ * @see ResourceBundle#getBundle(String, Locale)
+ */
+ public static final ResourceBundle getBundle(String name, Locale locale) {
+ if (locale == null) {
+ locale = Locale.getDefault();
+ }
+ try {
+ return ResourceBundle.getBundle(name, locale);
+ } catch (MissingResourceException ignore) {
+ return null;
+ }
+ }
+
+ /**
+ * バンドルを返します。 見つからない場合は、<code>null</code>を返します。
+ *
+ * @param name 名前
+ * @param locale ロケール
+ * @param classLoader クラスローダ
+ * @return {@link ResourceBundle}
+ * @see ResourceBundle#getBundle(String, Locale, ClassLoader)
+ */
+ public static final ResourceBundle getBundle(String name, Locale locale, ClassLoader classLoader) {
+ if (locale == null) {
+ locale = Locale.getDefault();
+ }
+ try {
+ return ResourceBundle.getBundle(name, locale, classLoader);
+ } catch (MissingResourceException ignore) {
+ return null;
+ }
+ }
+
+ /**
+ * インスタンスを構築します。
+ */
+ protected ResourceBundleUtil() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceBundleUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceTraversal.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceTraversal.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceTraversal.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+/**
+ * リソースを横断的に処理するためのクラス。
+ *
+ * @author j5ik2o
+ */
+public class ResourceTraversal {
+
+ /**
+ * リソースを処理するインターフェースです。
+ *
+ */
+ public interface ResourceHandler {
+
+ /**
+ * リソースを処理します。
+ *
+ * @param path パス
+ * @param is {@link InputStream}
+ */
+ void processResource(String path, InputStream is);
+ }
+
+
+ /**
+ * リソースを横断的に処理する。
+ *
+ * @param rootDir ルートディレクトリ
+ * @param handler ハンドラ
+ */
+ public static void forEach(final File rootDir, final ResourceHandler handler) {
+ forEach(rootDir, null, handler);
+ }
+
+ /**
+ * リソースを横断的に処理する。
+ *
+ * @param rootDir ルートディレクトリ
+ * @param baseDirectory ベースディレクトリ
+ * @param handler ハンドラ
+ */
+ public static void forEach(final File rootDir, final String baseDirectory, final ResourceHandler handler) {
+ final File baseDir = getBaseDir(rootDir, baseDirectory);
+ if (baseDir.exists()) {
+ traverseFileSystem(rootDir, baseDir, handler);
+ }
+ }
+
+ /**
+ * リソースを横断的に処理する。
+ *
+ * @param jarFile JarFile
+ * @param handler ハンドラ
+ */
+ public static void forEach(final JarFile jarFile, final ResourceHandler handler) {
+ final Enumeration<JarEntry> enumeration = jarFile.entries();
+ while (enumeration.hasMoreElements()) {
+ final JarEntry entry = enumeration.nextElement();
+ if (!entry.isDirectory()) {
+ final String entryName = entry.getName().replace('\\', '/');
+ final InputStream is = JarFileUtil.getInputStream(jarFile, entry);
+ try {
+ handler.processResource(entryName, is);
+ } finally {
+ InputStreamUtil.close(is);
+ }
+ }
+ }
+ }
+
+ private static File getBaseDir(final File rootDir, final String baseDirectory) {
+ File baseDir = rootDir;
+ if (baseDirectory != null) {
+ final String[] names = baseDirectory.split("/");
+ for (String name : names) {
+ baseDir = new File(baseDir, name);
+ }
+ }
+ return baseDir;
+ }
+
+ private static void traverseFileSystem(final File rootDir, final File baseDir, final ResourceHandler handler) {
+ final File[] files = baseDir.listFiles();
+ for (int i = 0; i < files.length; ++i) {
+ final File file = files[i];
+ if (file.isDirectory()) {
+ traverseFileSystem(rootDir, file, handler);
+ } else {
+ final int pos = FileUtil.getCanonicalPath(rootDir).length();
+ final String filePath = FileUtil.getCanonicalPath(file);
+ final String resourcePath = filePath.substring(pos + 1).replace('\\', '/');
+ final InputStream is = FileInputStreamUtil.create(file);
+ try {
+ handler.processResource(resourcePath, is);
+ } finally {
+ InputStreamUtil.close(is);
+ }
+ }
+ }
+ }
+
+ /**
+ * インスタンスを構築します。
+ */
+ protected ResourceTraversal() {
+ }
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceTraversal.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Properties;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+import org.jiemamy.composer.importer.exception.ResourceNotFoundRuntimeException;
+
+/**
+ * リソース用のユーティリティクラス。
+ *
+ * @author j5ik2o
+ *
+ */
+public class ResourceUtil {
+
+ /**
+ * パスを変換する。
+ *
+ * @param path パス
+ * @param clazz クラス
+ * @return 変換された結果
+ */
+ public static String convertPath(String path, Class<?> clazz) {
+ if (isExist(path)) {
+ return path;
+ }
+ String prefix = clazz.getName().replace('.', '/').replaceFirst("/[^/]+$", "");
+ String extendedPath = prefix + "/" + path;
+ if (ResourceUtil.getResourceNoException(extendedPath) != null) {
+ return extendedPath;
+ }
+ return path;
+ }
+
+ /**
+ * クラスファイルが置かれているルートディレクトリを取得する。
+ *
+ * @param clazz クラス
+ * @return ルートディレクトリ
+ * @see #getBuildDir(String)
+ */
+ public static File getBuildDir(Class<?> clazz) {
+ return getBuildDir(getResourcePath(clazz));
+ }
+
+ /**
+ * クラスファイルが置かれているルートディレクトリを取得する。
+ *
+ * @param path パス
+ * @return ルートディレクトリ
+ */
+ public static File getBuildDir(String path) {
+ File dir = null;
+ URL url = getResource(path);
+ if ("file".equals(url.getProtocol())) {
+ int num = path.split("/").length;
+ dir = new File(getFileName(url));
+ for (int i = 0; i < num; ++i, dir = dir.getParentFile()) {
+ // nop
+ }
+ } else {
+ dir = new File(JarFileUtil.toJarFilePath(url));
+ }
+ return dir;
+ }
+
+ /**
+ * クラスローダを取得する。
+ *
+ * @return クラスローダ
+ */
+ public static ClassLoader getClassLoader() {
+ return Thread.currentThread().getContextClassLoader();
+ }
+
+ /**
+ * 拡張子を取得する。
+ *
+ * @param path パス
+ * @return 拡張子
+ */
+ public static String getExtension(String path) {
+ int extPos = path.lastIndexOf(".");
+ if (extPos >= 0) {
+ return path.substring(extPos + 1);
+ }
+ return null;
+ }
+
+ /**
+ * ファイルを取得する。
+ *
+ * @param url URL
+ * @return ファイル
+ */
+ public static File getFile(URL url) {
+ File file = new File(getFileName(url));
+ if (file.exists()) {
+ return file;
+ }
+ return null;
+ }
+
+ /**
+ * ファイル名を取得する。
+ *
+ * @param url URL
+ * @return ファイル名
+ */
+ public static String getFileName(URL url) {
+ String s = url.getFile();
+ return URLUtil.decode(s, "UTF8");
+ }
+
+ /**
+ * プロパティファイルを取得する。
+ *
+ * @param path パス
+ * @return プロパティファイル
+ * @throws IORuntimeException {@link IOException}が発生した場合
+ */
+ public static Properties getProperties(String path) throws IORuntimeException {
+ Properties props = new Properties();
+ InputStream is = getResourceAsStream(path);
+ try {
+ props.load(is);
+ return props;
+ } catch (IOException ex) {
+ throw new IORuntimeException(ex);
+ }
+ }
+
+ /**
+ * リソースを取得する。
+ *
+ * @param path パス
+ * @return リソース
+ * @see #getResource(String, String)
+ */
+ public static URL getResource(String path) {
+ return getResource(path, null);
+ }
+
+ /**
+ * リソースを取得する。
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return リソース
+ * @throws ResourceNotFoundRuntimeException リソースが見つからなかった場合
+ */
+ public static URL getResource(String path, String extension) throws ResourceNotFoundRuntimeException {
+
+ URL url = getResourceNoException(path, extension);
+ if (url != null) {
+ return url;
+ }
+ throw new ResourceNotFoundRuntimeException(getResourcePath(path, extension));
+ }
+
+ /**
+ * リソースをファイルで取得する。
+ *
+ * @param path パス
+ * @return ファイル
+ * @see #getResourceAsFile(String, String)
+ */
+ public static File getResourceAsFile(String path) {
+ return getResourceAsFile(path, null);
+ }
+
+ /**
+ * リソースをファイルで取得する。
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return ファイル
+ * @see #getFile(URL)
+ */
+ public static File getResourceAsFile(String path, String extension) {
+ return getFile(getResource(path, extension));
+ }
+
+ /**
+ * リソースをファイルで取得する。
+ * <p>
+ * リソースが見つからない場合は<code>null</code>。
+ * </p>
+ *
+ * @param clazz クラス
+ * @return ファイル
+ * @see #getResourceAsFileNoException(String)
+ */
+ public static File getResourceAsFileNoException(Class<?> clazz) {
+ return getResourceAsFileNoException(getResourcePath(clazz));
+ }
+
+ /**
+ * リソースをファイルで取得する。
+ * <p>
+ * リソースが見つからない場合は<code>null</code>。
+ * </p>
+ *
+ * @param path パス
+ * @return ファイル
+ * @see #getResourceNoException(String)
+ */
+ public static File getResourceAsFileNoException(String path) {
+ URL url = getResourceNoException(path);
+ if (url == null) {
+ return null;
+ }
+ return getFile(url);
+ }
+
+ /**
+ * リソースをストリームで取得する。
+ *
+ * @param path パス
+ * @return ストリーム
+ * @see #getResourceAsStream(String, String)
+ */
+ public static InputStream getResourceAsStream(String path) {
+ return getResourceAsStream(path, null);
+ }
+
+ /**
+ * リソースをストリームで取得する。
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return ストリーム
+ * @see #getResource(String, String)
+ */
+ public static InputStream getResourceAsStream(String path, String extension) {
+ URL url = getResource(path, extension);
+ return URLUtil.openStream(url);
+ }
+
+ /**
+ * リソースをストリームで取得する。
+ * <p>
+ * リソースが見つからなかった場合は<code>null</code>。
+ * </p>
+ *
+ * @param path パス
+ * @return ストリーム
+ * @see #getResourceAsStreamNoException(String, String)
+ */
+ public static InputStream getResourceAsStreamNoException(String path) {
+ return getResourceAsStreamNoException(path, null);
+ }
+
+ /**
+ * リソースをストリームとして取得する。
+ * <p>
+ * リソースが見つからなかった場合は<code>null</code>。
+ * </p>
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return ストリーム
+ * @see #getResourceNoException(String, String)
+ */
+ public static InputStream getResourceAsStreamNoException(String path, String extension) {
+ URL url = getResourceNoException(path, extension);
+ if (url == null) {
+ return null;
+ }
+ try {
+ return url.openStream();
+ } catch (final IOException e) {
+ return null;
+ }
+ }
+
+ /**
+ * リソースを取得する。
+ * <p>
+ * 見つからなかった場合は<code>null</code>を返します。
+ * </p>
+ *
+ * @param path パス
+ * @return リソース
+ * @see #getResourceNoException(String, String)
+ */
+ public static URL getResourceNoException(String path) {
+ return getResourceNoException(path, null);
+ }
+
+ /**
+ * リソースを取得する。
+ * <p>
+ * 見つからなかった場合は<code>null</code>。
+ * </p>
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return リソース
+ * @see #getResourceNoException(String, String, ClassLoader)
+ */
+ public static URL getResourceNoException(String path, String extension) {
+ return getResourceNoException(path, extension, Thread.currentThread().getContextClassLoader());
+ }
+
+ /**
+ * リソースを取得する。
+ * <p>
+ * 見つからなかった場合は<code>null</code>。
+ * </p>
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @param loader クラスローダ
+ * @return リソース
+ * @see #getResourcePath(String, String)
+ */
+ public static URL getResourceNoException(String path, String extension, ClassLoader loader) {
+ if (path == null || loader == null) {
+ return null;
+ }
+ path = getResourcePath(path, extension);
+ return loader.getResource(path);
+ }
+
+ /**
+ * リソースパスを取得する。
+ *
+ * @param clazz クラス
+ * @return リソースパス
+ */
+ public static String getResourcePath(Class<?> clazz) {
+ return clazz.getName().replace('.', '/') + ".class";
+ }
+
+ /**
+ * リソースパスを取得する。
+ *
+ * @param path パス
+ * @param extension 拡張子
+ * @return リソースパス
+ */
+ public static String getResourcePath(String path, String extension) {
+ if (extension == null) {
+ return path;
+ }
+ extension = "." + extension;
+ if (path.endsWith(extension)) {
+ return path;
+ }
+ return path.replace('.', '/') + extension;
+ }
+
+ /**
+ * リソースの存在有無を取得する。
+ *
+ * @param path パス
+ * @return リソースが存在するかどうか
+ * @see #getResourceNoException(String)
+ */
+ public static boolean isExist(String path) {
+ return getResourceNoException(path) != null;
+ }
+
+ /**
+ * 拡張子を除去する。
+ *
+ * @param path パス
+ * @return 取り除いた後の結果
+ */
+ public static String removeExtension(String path) {
+ int extPos = path.lastIndexOf(".");
+ if (extPos >= 0) {
+ return path.substring(0, extPos);
+ }
+ return path;
+ }
+
+ /**
+ * 外部形式に変換する。
+ *
+ * @param url URL
+ * @return 外部形式
+ */
+ public static String toExternalForm(URL url) {
+ String s = url.toExternalForm();
+ return URLUtil.decode(s, "UTF8");
+ }
+
+ private ResourceUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourceUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourcesUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourcesUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourcesUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,410 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.jar.JarFile;
+
+import org.apache.commons.lang.StringUtils;
+
+import org.jiemamy.composer.importer.utils.ClassTraversal.ClassHandler;
+import org.jiemamy.composer.importer.utils.ResourceTraversal.ResourceHandler;
+
+/**
+ * ファイルシステム上やJarファイル中に展開されているリソースの集まりを扱うユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public final class ResourcesUtil {
+
+ /**
+ * ファイルシステム上のリソースの集まりを扱うオブジェクト。
+ *
+ * @author j5ik2o
+ */
+ public static class FileSystemResources implements Resources {
+
+ /** ベースディレクトリです。 */
+ protected final File baseDir;
+
+ /** ルートパッケージです。 */
+ protected final String rootPackage;
+
+ /** ルートディレクトリです。 */
+ protected final String rootDir;
+
+
+ /**
+ * インスタンスを構築します。
+ *
+ * @param baseDir ベースディレクトリ
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ */
+ public FileSystemResources(final File baseDir, final String rootPackage, final String rootDir) {
+ this.baseDir = baseDir;
+ this.rootPackage = rootPackage;
+ this.rootDir = rootDir;
+ }
+
+ /**
+ * インスタンスを生成する。
+ *
+ * @param url ディレクトリを表すURL
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ */
+ public FileSystemResources(final URL url, final String rootPackage, final String rootDir) {
+ this(URLUtil.toFile(url), rootPackage, rootDir);
+ }
+
+ public void close() {
+ }
+
+ public void forEach(final ClassHandler handler) {
+ ClassTraversal.forEach(baseDir, rootPackage, handler);
+ }
+
+ public void forEach(final ResourceHandler handler) {
+ ResourceTraversal.forEach(baseDir, rootDir, handler);
+ }
+
+ public boolean isExistClass(final String className) {
+ final File file = new File(baseDir, toClassFile(ClassUtil.concatName(rootPackage, className)));
+ return file.exists();
+ }
+
+ }
+
+ /**
+ * Jarファイル中のリソースの集まりを扱うオブジェクト。
+ *
+ * @author j5ik2o
+ */
+ public static class JarFileResources implements Resources {
+
+ /** Jarファイルです。 */
+ protected final JarFile jarFile;
+
+ /** ルートパッケージです。 */
+ protected final String rootPackage;
+
+ /** ルートディレクトリです。 */
+ protected final String rootDir;
+
+
+ /**
+ * インスタンスを生成する。
+ *
+ * @param jarFile Jarファイル
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ */
+ public JarFileResources(final JarFile jarFile, final String rootPackage, final String rootDir) {
+ this.jarFile = jarFile;
+ this.rootPackage = rootPackage;
+ this.rootDir = rootDir;
+ }
+
+ /**
+ * インスタンスを生成する。
+ *
+ * @param url Jarファイルを表すURL
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ */
+ public JarFileResources(final URL url, final String rootPackage, final String rootDir) {
+ this(JarFileUtil.toJarFile(url), rootPackage, rootDir);
+ }
+
+ public void close() {
+ JarFileUtil.close(jarFile);
+ }
+
+ public void forEach(final ClassHandler handler) {
+ ClassTraversal.forEach(jarFile, new ClassHandler() {
+
+ public void processClass(String packageName, String shortClassName) {
+ if (rootPackage == null || (packageName != null && packageName.startsWith(rootPackage))) {
+ handler.processClass(packageName, shortClassName);
+ }
+ }
+ });
+ }
+
+ public void forEach(final ResourceHandler handler) {
+ ResourceTraversal.forEach(jarFile, new ResourceHandler() {
+
+ public void processResource(String path, InputStream is) {
+ if (rootDir == null || path.startsWith(rootDir)) {
+ handler.processResource(path, is);
+ }
+ }
+ });
+ }
+
+ public boolean isExistClass(final String className) {
+ return jarFile.getEntry(toClassFile(ClassUtil.concatName(rootPackage, className))) != null;
+ }
+
+ }
+
+ /**
+ * リソースの集まりを表すオブジェクト。
+ *
+ * @author j5ik2o
+ */
+ public interface Resources {
+
+ /**
+ * リソースの後処理を行う。
+ */
+ void close();
+
+ /**
+ * このインスタンスが扱うリソースの中に存在するクラスを探して
+ * {@link ClassHandler#processClass(String, String) ハンドラ}をコールバックする。
+ * <p>
+ * インスタンス構築時にルートパッケージが指定されている場合は、 ルートパッケージ以下のクラスのみが対象となる。
+ * </p>
+ *
+ * @param handler ハンドラ
+ */
+ void forEach(ClassHandler handler);
+
+ /**
+ * このインスタンスが扱うリソースを探して
+ * {@link ResourceHandler#processResource(String, java.io.InputStream)
+ * ハンドラ}をコールバックする。
+ * <p>
+ * インスタンス構築時にルートディレクトリが指定されている場合は、 ルートディレクトリ以下のリソースのみが対象となる。
+ * </p>
+ *
+ * @param handler ハンドラ
+ */
+ void forEach(ResourceHandler handler);
+
+ /**
+ * 指定されたクラス名に対応するクラスファイルがこのインスタンスが扱うリソースの中に存在すれば<code>true</code>を取得する。
+ * <p>
+ * インスタンス構築時にルートパッケージが指定されている場合、 指定されたクラス名はルートパッケージからの相対名として解釈する。
+ * </p>
+ *
+ * @param className クラス名
+ * @return 指定されたクラス名に対応するクラスファイルがこのインスタンスが扱うリソースの中に存在すれば
+ * <code>true</code>
+ */
+ boolean isExistClass(final String className);
+
+ }
+
+ /**
+ * {@link Resources}のインスタンスを作成するファクトリ。
+ *
+ * @author j5ik2o
+ */
+ public interface ResourcesFactory {
+
+ /**
+ * {@link Resources}のインスタンスを作成して返します。
+ *
+ * @param url リソースを表すURL
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ * @return URLで表されたリソースを扱う{@link Resources}
+ */
+ Resources create(URL url, String rootPackage, String rootDir);
+ }
+
+
+ /** 空の{@link Resources}の配列。 */
+ private static final Resources[] EMPTY_ARRAY = new Resources[0];
+
+ /** URLのプロトコルをキー、{@link ResourcesFactory}を値とするマッピング。 */
+ private static final Map<String, ResourcesFactory> RESOUCES_TYPE_FACTORIES =
+ new HashMap<String, ResourcesFactory>();
+
+ //private static final Logger logger = Logger.getLogger(ResourcesUtil.class);
+
+ static {
+ addResourcesFactory("file", new ResourcesFactory() {
+
+ public Resources create(final URL url, final String rootPackage, final String rootDir) {
+ return new FileSystemResources(getBaseDir(url, rootDir), rootPackage, rootDir);
+ }
+ });
+ addResourcesFactory("jar", new ResourcesFactory() {
+
+ public Resources create(final URL url, final String rootPackage, final String rootDir) {
+ return new JarFileResources(url, rootPackage, rootDir);
+ }
+ });
+ addResourcesFactory("zip", new ResourcesFactory() {
+
+ public Resources create(final URL url, final String rootPackage, final String rootDir) {
+ return new JarFileResources(JarFileUtil.create(new File(ZipFileUtil.toZipFilePath(url))), rootPackage,
+ rootDir);
+ }
+ });
+ addResourcesFactory("code-source", new ResourcesFactory() {
+
+ public Resources create(final URL url, final String rootPackage, final String rootDir) {
+ return new JarFileResources(URLUtil.create("jar:file:" + url.getPath()), rootPackage, rootDir);
+ }
+ });
+ }
+
+
+ /**
+ * {@link ResourcesFactory}を追加する。
+ *
+ * @param protocol URLのプロトコル
+ * @param factory プロトコルに対応する{@link Resources}のファクトリ
+ */
+ public static void addResourcesFactory(final String protocol, ResourcesFactory factory) {
+ RESOUCES_TYPE_FACTORIES.put(protocol, factory);
+ }
+
+ /**
+ * ファイルを表すURLからルートパッケージの上位となるベースディレクトリを取得する。
+ *
+ * @param url ファイルを表すURL
+ * @param baseName ベース名
+ * @return ルートパッケージの上位となるベースディレクトリ
+ */
+ protected static File getBaseDir(final URL url, final String baseName) {
+ File file = URLUtil.toFile(url);
+ final String[] paths = StringUtils.split(baseName, "/");
+ for (int i = 0; i < paths.length; ++i) {
+ file = file.getParentFile();
+ }
+ return file;
+ }
+
+ /**
+ * 指定のクラスを基点とするリソースの集まりを扱う{@link Resources}を取得する。
+ * <p>
+ * このメソッドが返す{@link Resources}は、指定されたクラスをFQNで参照可能なパスをルートとします。 例えば指定されたクラスが
+ * <code>foo.Bar</code>で、そのクラスファイルが<code>classes/foo/Bar.class</code>の場合、
+ * このメソッドが返す{@link Resources}は<code>classes</code>ディレクトリ以下のリソースの集合を扱う。
+ * </p>
+ *
+ * @param referenceClass 基点となるクラス
+ * @return 指定のクラスを基点とするリソースの集まりを扱う{@link Resources}
+ */
+ public static Resources getResourcesType(final Class<?> referenceClass) {
+ final URL url = ResourceUtil.getResource(toClassFile(referenceClass.getName()));
+ final String path[] = referenceClass.getName().split("\\.");
+ String baseUrl = url.toExternalForm();
+ for (int i = 0; i < path.length; ++i) {
+ int pos = baseUrl.lastIndexOf('/');
+ baseUrl = baseUrl.substring(0, pos);
+ }
+ return getResourcesType(URLUtil.create(baseUrl + '/'), null, null);
+ }
+
+ /**
+ * 指定のディレクトリを基点とするリソースの集まりを扱う{@link Resources}を取得する。
+ *
+ * @param rootDir ルートディレクトリ
+ * @return 指定のディレクトリを基点とするリソースの集まりを扱う{@link Resources}
+ */
+ public static Resources getResourcesType(final String rootDir) {
+ final URL url = ResourceUtil.getResource(rootDir.endsWith("/") ? rootDir : rootDir + '/');
+ return getResourcesType(url, null, rootDir);
+ }
+
+ /**
+ * URLを扱う{@link Resources}を取得する。
+ * <p>
+ * URLのプロトコルが未知の場合は<code>null</code>。
+ * </p>
+ *
+ * @param url リソースのURL
+ * @param rootPackage ルートパッケージ
+ * @param rootDir ルートディレクトリ
+ * @return URLを扱う{@link Resources}
+ */
+ protected static Resources getResourcesType(final URL url, final String rootPackage, final String rootDir) {
+ final ResourcesFactory factory = RESOUCES_TYPE_FACTORIES.get(URLUtil.toCanonicalProtocol(url.getProtocol()));
+ if (factory != null) {
+ return factory.create(url, rootPackage, rootDir);
+ }
+ return null;
+ }
+
+ /**
+ * 指定のルートパッケージを基点とするリソースの集まりを扱う{@link Resources}の配列を取得する。
+ *
+ * @param rootPackage ルートパッケージ
+ * @return 指定のルートパッケージを基点とするリソースの集まりを扱う{@link Resources}の配列
+ */
+ public static Resources[] getResourcesTypes(final String rootPackage) {
+ if (StringUtils.isEmpty(rootPackage)) {
+ return EMPTY_ARRAY;
+ }
+
+ final String baseName = toDirectoryName(rootPackage);
+ final List<Resources> list = new ArrayList<Resources>();
+ for (final Iterator<URL> it = ClassLoaderUtil.getResources(baseName); it.hasNext();) {
+ final URL url = it.next();
+ final Resources resourcesType = getResourcesType(url, rootPackage, baseName);
+ if (resourcesType != null) {
+ list.add(resourcesType);
+ }
+ }
+ if (list.isEmpty()) {
+ return EMPTY_ARRAY;
+ }
+ return list.toArray(new Resources[list.size()]);
+ }
+
+ /**
+ * クラス名をクラスファイルのパス名に変換する。
+ *
+ * @param className クラス名
+ * @return クラスファイルのパス名
+ */
+ protected static String toClassFile(final String className) {
+ return className.replace('.', '/') + ".class";
+ }
+
+ /**
+ * パッケージ名をディレクトリ名に変換する。
+ *
+ * @param packageName パッケージ名
+ * @return ディレクトリ名
+ */
+ protected static String toDirectoryName(final String packageName) {
+ if (StringUtils.isEmpty(packageName)) {
+ return null;
+ }
+ return packageName.replace('.', '/') + '/';
+ }
+
+ private ResourcesUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ResourcesUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/URLUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/URLUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/URLUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,178 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link URL}を扱うユーティリティ・クラス。
+ *
+ * @author j5ik2o
+ */
+public class URLUtil {
+
+ /** プロトコルを正規化するためのマップ */
+ protected static final Map<String, String> CANONICAL_PROTOCOLS = new HashMap<String, String>();
+ static {
+ CANONICAL_PROTOCOLS.put("wsjar", "jar"); // WebSphereがJarファイルのために使用する固有のプロトコル
+ }
+
+
+ /**
+ * <code>String</code>表現から<code>URL</code>オブジェクトを作成します。
+ *
+ * @param spec <code>URL</code>として構文解析される<code>String</code>
+ * @return <code>URL</code>
+ */
+ public static URL create(String spec) {
+ try {
+ return new URL(spec);
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたコンテキスト内の指定された仕様で構文解析することによって、<code>URL</code>を生成する。
+ *
+ * @param context 仕様を構文解析するコンテキスト
+ * @param spec <code>URL</code>として構文解析される<code>String</code>
+ * @return <code>URL</code>
+ */
+ public static URL create(URL context, String spec) {
+ try {
+ return new URL(context, spec);
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 特別な符号化方式を使用して<code>application/x-www-form-urlencoded</code>文字列をデコードする。
+ *
+ * @param s デコード対象の<code>String</code>
+ * @param enc サポートされる文字エンコーディングの名前
+ * @return 新しくデコードされた String
+ */
+ public static String decode(final String s, final String enc) {
+ try {
+ return URLDecoder.decode(s, enc);
+ } catch (final UnsupportedEncodingException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4167874">このバグ</a>に対する対応です。
+ *
+ */
+// public static void disableURLCaches() {
+// BeanDesc bd = BeanDescFactory.getBeanDesc(URLConnection.class);
+// FieldUtil.set(bd.getField("defaultUseCaches"), null, Boolean.FALSE);
+// }
+ /**
+ * 特定の符号化方式を使用して文字列を<code>application/x-www-form-urlencoded</code>形式に変換する。
+ *
+ * @param s 変換対象の String
+ * @param enc サポートされる文字エンコーディングの名前
+ * @return 変換後の<code>String</code>
+ */
+ public static String encode(final String s, final String enc) {
+ try {
+ return URLEncoder.encode(s, enc);
+ } catch (final UnsupportedEncodingException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * URLが参照するリモートオブジェクトへの接続を表す{@link URLConnection}オブジェクトを取得する。
+ *
+ * @param url URL
+ * @return URLへの{@link URLConnection}オブジェクト
+ */
+ public static URLConnection openConnection(URL url) {
+ try {
+ URLConnection connection = url.openConnection();
+ connection.setUseCaches(false);
+ return connection;
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * URLをオープンして{@link InputStream}を取得する。
+ *
+ * @param url URL
+ * @return URLが表すリソースを読み込むための{@link InputStream}
+ */
+ public static InputStream openStream(URL url) {
+ try {
+ URLConnection connection = url.openConnection();
+ connection.setUseCaches(false);
+ return connection.getInputStream();
+ } catch (IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 正規化されたプロトコルを取得する。
+ *
+ * @param protocol プロトコル
+ * @return 正規化されたプロトコル
+ */
+ public static String toCanonicalProtocol(final String protocol) {
+ final String canonicalProtocol = CANONICAL_PROTOCOLS.get(protocol);
+ if (canonicalProtocol != null) {
+ return canonicalProtocol;
+ }
+ return protocol;
+ }
+
+ /**
+ * URLが示すJarファイルの{@link File}オブジェクトを取得する。
+ *
+ * @param fileUrl JarファイルのURL
+ * @return Jarファイルの{@link File}
+ */
+ public static File toFile(final URL fileUrl) {
+ try {
+ final String path = URLDecoder.decode(fileUrl.getPath(), "UTF-8");
+ return new File(path).getAbsoluteFile();
+ } catch (final Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private URLUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/URLUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain
Added: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ZipFileUtil.java
===================================================================
--- charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ZipFileUtil.java (rev 0)
+++ charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ZipFileUtil.java 2009-04-03 07:01:54 UTC (rev 3079)
@@ -0,0 +1,128 @@
+/*
+ * Copyright 2007-2009 Jiemamy Project and the Others.
+ *
+ * This file is part of Jiemamy.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+ * either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+package org.jiemamy.composer.importer.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.jiemamy.composer.importer.exception.IORuntimeException;
+
+/**
+ * {@link java.util.zip.ZipFile}を扱うユーティリティクラス。
+ *
+ * @author j5ik2o
+ */
+public class ZipFileUtil {
+
+ /**
+ * Zipファイルをクローズする。
+ *
+ * @param zipFile Zipファイル
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローする
+ */
+ public static void close(final ZipFile zipFile) {
+ try {
+ zipFile.close();
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたZipファイルを読み取るための<code>ZipFile</code>を取得する。
+ *
+ * @param file ファイル
+ * @return 指定されたZipファイルを読み取るための<code>ZipFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローする
+ */
+ public static ZipFile create(final File file) {
+ try {
+ return new ZipFile(file);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたZipファイルを読み取るための<code>ZipFile</code>を取得する。
+ *
+ * @param file ファイルパス
+ * @return 指定されたZipファイルを読み取るための<code>ZipFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローする
+ */
+ public static ZipFile create(final String file) {
+ try {
+ return new ZipFile(file);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * 指定されたZipファイルエントリの内容を読み込むための入力ストリームを取得する。
+ *
+ * @param file Zipファイル
+ * @param entry Zipファイルエントリ
+ * @return 指定されたZipファイルエントリの内容を読み込むための入力ストリーム
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローする
+ */
+ public static InputStream getInputStream(final ZipFile file, final ZipEntry entry) {
+ try {
+ return file.getInputStream(entry);
+ } catch (final IOException e) {
+ throw new IORuntimeException(e);
+ }
+ }
+
+ /**
+ * URLで指定されたZipファイルを読み取るための<code>ZipFile</code>を取得する。
+ *
+ * @param zipUrl Zipファイルを示すURL
+ * @return 指定されたZipファイルを読み取るための<code>ZipFile</code>
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローする
+ */
+ public static ZipFile toZipFile(final URL zipUrl) {
+ return create(new File(toZipFilePath(zipUrl)));
+ }
+
+ /**
+ * URLで指定されたZipファイルのパスを取得する。
+ *
+ * @param zipUrl Zipファイルを示すURL
+ * @return URLで指定されたZipファイルのパス
+ * @throws IORuntimeException 入出力エラーが発生した場合にスローされます
+ */
+ public static String toZipFilePath(final URL zipUrl) {
+ final String urlString = zipUrl.getPath();
+ final int pos = urlString.lastIndexOf('!');
+ final String zipFilePath = urlString.substring(0, pos);
+ final File zipFile = new File(URLUtil.decode(zipFilePath, "UTF8"));
+ return FileUtil.getCanonicalPath(zipFile);
+ }
+
+ /**
+ * インスタンスを構築します。
+ */
+ protected ZipFileUtil() {
+ }
+
+}
Property changes on: charon/jiemamy-jpa-importer/trunk/src/main/java/org/jiemamy/composer/importer/utils/ZipFileUtil.java
___________________________________________________________________
Added: svn:mime-type
+ text/plain