From 132aa8a77685ec92bc90c03f987650d275a7b639 Mon Sep 17 00:00:00 2001 From: lresende Date: Mon, 30 Sep 2013 06:59:11 +0000 Subject: 2.0.1 RC1 release tag git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@1527464 13f79535-47bb-0310-9956-ffa450edef68 --- .../modules/common-java/META-INF/MANIFEST.MF | 22 + .../tags/2.0.1-RC1/modules/common-java/pom.xml | 46 ++ .../java/classloader/ClassLoaderDelegate.java | 102 ++++ .../sca/common/java/collection/CollectionMap.java | 77 +++ .../java/collection/CompoundEnumeration.java | 93 ++++ .../common/java/collection/CompoundIterator.java | 113 ++++ .../sca/common/java/collection/LRUCache.java | 89 ++++ .../tuscany/sca/common/java/io/IOHelper.java | 167 ++++++ .../java/reflection/JavaIntrospectionHelper.java | 588 +++++++++++++++++++++ .../JavaIntrospectionHelperTestCase.java | 72 +++ .../sca/common/java/reflection/SubTestImpl.java | 45 ++ .../tuscany/sca/common/java/reflection/Test1.java | 28 + .../tuscany/sca/common/java/reflection/Test2.java | 28 + .../sca/common/java/reflection/TestImpl.java | 44 ++ 14 files changed, 1514 insertions(+) create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/META-INF/MANIFEST.MF create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/pom.xml create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/classloader/ClassLoaderDelegate.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CollectionMap.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundEnumeration.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundIterator.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/LRUCache.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/io/IOHelper.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelper.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelperTestCase.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/SubTestImpl.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test1.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test2.java create mode 100644 sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/TestImpl.java (limited to 'sca-java-2.x/tags/2.0.1-RC1/modules/common-java') diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/META-INF/MANIFEST.MF b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/META-INF/MANIFEST.MF new file mode 100644 index 0000000000..5fd3a2a7f4 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/META-INF/MANIFEST.MF @@ -0,0 +1,22 @@ +Manifest-Version: 1.0 +SCA-Version: 1.1 +Bundle-Name: Apache Tuscany SCA Common Java +Bundle-Vendor: The Apache Software Foundation +Bundle-Version: 2.0.0 +Bundle-ManifestVersion: 2 +Bundle-License: http://www.apache.org/licenses/LICENSE-2.0.txt +Bundle-Description: Apache Tuscany SCA Common Java +Import-Package: org.apache.tuscany.sca.common.java.classloader;version="2.0.0", + org.apache.tuscany.sca.common.java.collection;version="2.0.0", + org.apache.tuscany.sca.common.java.io;version="2.0.0", + org.apache.tuscany.sca.common.java.reflection;version="2.0.0", + org.apache.tuscany.sca.core;version="2.0.0", + org.oasisopen.sca;version="2.0.0" +Bundle-SymbolicName: org.apache.tuscany.sca.common.java +Bundle-DocURL: http://www.apache.org/ +Export-Package: org.apache.tuscany.sca.common.java.classloader;version="2.0.0", + org.apache.tuscany.sca.common.java.collection;version="2.0.0", + org.apache.tuscany.sca.common.java.io;version="2.0.0", + org.apache.tuscany.sca.common.java.reflection;version="2.0.0";uses:="org.apache.tuscany.sca.core" + + diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/pom.xml b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/pom.xml new file mode 100644 index 0000000000..8ff51cf04a --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/pom.xml @@ -0,0 +1,46 @@ + + + + 4.0.0 + + org.apache.tuscany.sca + tuscany-modules + 2.0.1 + ../pom.xml + + tuscany-common-java + Apache Tuscany SCA Common Java + + + + org.apache.tuscany.sca + tuscany-extensibility + 2.0.1 + + + + org.apache.tuscany.sca + tuscany-sca-api + 2.0.1 + + + + + diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/classloader/ClassLoaderDelegate.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/classloader/ClassLoaderDelegate.java new file mode 100644 index 0000000000..522880711c --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/classloader/ClassLoaderDelegate.java @@ -0,0 +1,102 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.classloader; + +import java.io.IOException; +import java.net.URL; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Enumeration; +import java.util.List; + +import org.apache.tuscany.sca.common.java.collection.CompoundEnumeration; + +/** + * + * @tuscany.spi.extension.asclient + * + */ +public class ClassLoaderDelegate extends ClassLoader { + private final List classLoaders = new ArrayList(); + + /** + * @param parent The parent classloaders + * @param loaders A list of classloaders to be used to load classes or resources + */ + public ClassLoaderDelegate(ClassLoader parent, ClassLoader... loaders) { + super(parent); + if (loaders != null) { + for (ClassLoader cl : loaders) { + if (cl != null && cl != parent && !classLoaders.contains(cl)) { + this.classLoaders.add(cl); + } + } + } + } + + /** + * @param parent The parent classloaders + * @param loaders A list of classloaders to be used to load classes or resources + */ + public ClassLoaderDelegate(ClassLoader parent, Collection loaders) { + super(parent); + if (loaders != null) { + for (ClassLoader cl : loaders) { + if (cl != null && cl != parent && !classLoaders.contains(cl)) { + this.classLoaders.add(cl); + } + } + } + } + + @Override + protected Class findClass(String className) throws ClassNotFoundException { + for (ClassLoader parent : classLoaders) { + try { + return parent.loadClass(className); + } catch (ClassNotFoundException e) { + continue; + } + } + throw new ClassNotFoundException(className); + } + + @Override + protected URL findResource(String resName) { + for (ClassLoader parent : classLoaders) { + URL url = parent.getResource(resName); + if (url != null) { + return url; + } + } + return null; + } + + @SuppressWarnings("unchecked") + @Override + protected Enumeration findResources(String resName) throws IOException { + Enumeration[] enums = new Enumeration[classLoaders.size()]; + int index = 0; + for (ClassLoader parent : classLoaders) { + enums[index++] = parent.getResources(resName); + } + return new CompoundEnumeration(enums); + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CollectionMap.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CollectionMap.java new file mode 100644 index 0000000000..0db80c891d --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CollectionMap.java @@ -0,0 +1,77 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.collection; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.concurrent.ConcurrentHashMap; + +/** + * A Map with Collection values + */ +public class CollectionMap extends ConcurrentHashMap> { + private static final long serialVersionUID = -8926174610229029369L; + + public boolean putValue(K key, V value) { + Collection collection = get(key); + if (collection == null) { + collection = createCollection(); + put(key, collection); + } + return collection.add(value); + } + + public boolean putValues(K key, Collection value) { + Collection collection = get(key); + if (collection == null) { + collection = createCollection(); + put(key, collection); + } + return collection.addAll(value); + } + + public boolean removeValue(K key, V value) { + return removeValue(key, value, false); + } + + /** + * Remove an entry from the collection for a key + * @param key The key + * @param value The value in the collection + * @param removeEmptyEntry Indicate if the entry should be removed if the collection is empty + * @return + */ + public boolean removeValue(K key, V value, boolean removeEmptyEntry) { + Collection collection = get(key); + if (collection == null) { + return false; + } + boolean result = collection.remove(value); + if(removeEmptyEntry && collection.isEmpty()) { + remove(key); + } + return result; + } + + protected Collection createCollection() { + return new ArrayList(); + } + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundEnumeration.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundEnumeration.java new file mode 100644 index 0000000000..dc6a7e0f90 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundEnumeration.java @@ -0,0 +1,93 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.collection; + +import java.util.Enumeration; +import java.util.NoSuchElementException; + +public class CompoundEnumeration implements Enumeration { + private Enumeration[] enumerations = null; + private int index = 0; + + public CompoundEnumeration(Enumeration... enums) { + enumerations = enums; + } + + public boolean hasMoreElements() { + // if the current enum is null that means this enum is finished + if (currentEnumeration() == null) { + // No next enum + return false; + } + // If the current enum has more elements, lets go + return currentEnumeration().hasMoreElements(); + } + + private Enumeration findNextEnumeration(boolean moveCursor) { + return findNextEnumeration(index, moveCursor); + } + + private Enumeration findNextEnumeration(int cursor, boolean moveCursor) { + // next place in the array + int next = cursor + 1; + // If the cursor is still in the array + if (next < enumerations.length) { + + // If there is something in that place + // AND the enum is not empty + if (enumerations[next] != null && enumerations[next].hasMoreElements()) { + // OK + if (moveCursor) { + index = next; + } + return enumerations[next]; + } + // Try next element + return findNextEnumeration(next, moveCursor); + } + // No more elements available + return null; + } + + public T nextElement() { + // ask for the next element of the current enum. + if (currentEnumeration() != null) { + return currentEnumeration().nextElement(); + } + + // no more elements in this Enum + // We must throw a NoSuchElementException + throw new NoSuchElementException("No more elements"); + } + + private Enumeration currentEnumeration() { + if (enumerations != null) { + if (index < enumerations.length) { + Enumeration e = enumerations[index]; + if (e == null || !e.hasMoreElements()) { + // the current enum is null or empty + // we probably want to switch to the next one + e = findNextEnumeration(true); + } + return e; + } + } + return null; + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundIterator.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundIterator.java new file mode 100644 index 0000000000..997ba89881 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/CompoundIterator.java @@ -0,0 +1,113 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.collection; + +import java.util.Collection; +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class CompoundIterator implements Iterator { + private Iterator[] iterators = null; + private int index = 0; + + public CompoundIterator(Iterator... iterators) { + this.iterators = iterators; + } + + @SuppressWarnings("unchecked") + public CompoundIterator(Collection... collections) { + this.iterators = new Iterator[collections.length]; + for (int i = 0; i < collections.length; i++) { + this.iterators[i] = collections[i].iterator(); + } + } + + public boolean hasNext() { + // if the current enum is null that means this enum is finished + if (currentIterator() == null) { + // No next enum + return false; + } + // If the current enum has more elements, lets go + return currentIterator().hasNext(); + } + + private Iterator findNextIterator(boolean moveCursor) { + return findNextIterator(index, moveCursor); + } + + private Iterator findNextIterator(int cursor, boolean moveCursor) { + // next place in the array + int next = cursor + 1; + // If the cursor is still in the array + if (next < iterators.length) { + + // If there is something in that place + // AND the enum is not empty + if (iterators[next] != null && iterators[next].hasNext()) { + // OK + if (moveCursor) { + index = next; + } + return iterators[next]; + } + // Try next element + return findNextIterator(next, moveCursor); + } + // No more elements available + return null; + } + + public T next() { + // ask for the next element of the current enum. + if (currentIterator() != null) { + return currentIterator().next(); + } + + // no more elements in this Enum + // We must throw a NoSuchElementException + throw new NoSuchElementException("No more elements"); + } + + public void remove() { + // ask for the next element of the current enum. + if (currentIterator() != null) { + currentIterator().remove(); + } + + // no more elements in this Enum + // We must throw a NoSuchElementException + throw new NoSuchElementException("No more elements"); + } + + private Iterator currentIterator() { + if (iterators != null) { + if (index < iterators.length) { + Iterator e = iterators[index]; + if (e == null || !e.hasNext()) { + // the current enum is null or empty + // we probably want to switch to the next one + e = findNextIterator(true); + } + return e; + } + } + return null; + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/LRUCache.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/LRUCache.java new file mode 100644 index 0000000000..41286aa0f9 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/collection/LRUCache.java @@ -0,0 +1,89 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.collection; + +import java.util.LinkedHashMap; +import java.util.Map; + +/** + * A Simple LRU Cache + * + * @version $Revision$ + * @param + * @param + * @tuscany.spi.extension.asclient + */ + +public class LRUCache extends LinkedHashMap { + private static final long serialVersionUID = -342098639681884413L; + protected int maxCacheSize = 4096; + + /** + * Default constructor for an LRU Cache The default capacity is 4096 + */ + public LRUCache() { + this(0, 4096, 0.75f, true); + } + + /** + * Constructs a LRUCache with a maximum capacity + * + * @param maximumCacheSize + */ + public LRUCache(int maximumCacheSize) { + this(0, maximumCacheSize, 0.75f, true); + } + + /** + * Constructs an empty LRUCache instance with the specified + * initial capacity, maximumCacheSize,load factor and ordering mode. + * + * @param initialCapacity the initial capacity. + * @param maximumCacheSize + * @param loadFactor the load factor. + * @param accessOrder the ordering mode - true for access-order, + * false for insertion-order. + * @throws IllegalArgumentException if the initial capacity is negative or + * the load factor is non-positive. + */ + + public LRUCache(int initialCapacity, int maximumCacheSize, float loadFactor, boolean accessOrder) { + super(initialCapacity, loadFactor, accessOrder); + this.maxCacheSize = maximumCacheSize; + } + + /** + * @return Returns the maxCacheSize. + */ + public int getMaxCacheSize() { + return maxCacheSize; + } + + /** + * @param maxCacheSize The maxCacheSize to set. + */ + public void setMaxCacheSize(int maxCacheSize) { + this.maxCacheSize = maxCacheSize; + } + + @Override + protected boolean removeEldestEntry(Map.Entry eldest) { + return size() > maxCacheSize; + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/io/IOHelper.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/io/IOHelper.java new file mode 100644 index 0000000000..91aef7a65f --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/io/IOHelper.java @@ -0,0 +1,167 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.io; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.JarURLConnection; +import java.net.MalformedURLException; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URL; +import java.net.URLConnection; + +/** + * Helper class for I/O operations + * @tuscany.spi.extension.asclient + */ +public class IOHelper { + + public static InputStream openStream(URL url) throws IOException { + // Handle file: which strictly speaking is not a valid file URL + File file = toFile(url); + if (file != null) { + return new FileInputStream(file); + } + URLConnection connection = url.openConnection(); + if (connection instanceof JarURLConnection) { + // See http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5041014 + connection.setUseCaches(false); + } + InputStream is = connection.getInputStream(); + return is; + } + + public static void close(InputStream is) { + if (is != null) { + try { + is.close(); + } catch (IOException e) { + throw new IllegalStateException(e); + } + } + } + + /** + * Escape the space in URL string + * @param uri + * @return + */ + public static URI createURI(String uri) { + if (uri == null) { + return null; + } + if (uri.indexOf('%') != -1) { + // Avoid double-escaping + return URI.create(uri); + } + int index = uri.indexOf(':'); + String scheme = null; + String ssp = uri; + if (index != -1) { + scheme = uri.substring(0, index); + ssp = uri.substring(index + 1); + } + try { + return new URI(scheme, ssp, null); + } catch (URISyntaxException e) { + throw new IllegalArgumentException(e); + } + } + + public static URI toURI(URL url) { + if (url == null) { + return null; + } + return createURI(url.toString()); + } + + public static URL normalize(URL url) { + // Make sure the trailing / is added to the file directory URL so that + // URLClassLoader can load classes from that + try { + File file = toFile(url); + if (file != null) { + return file.toURI().toURL(); + } else { + return toURI(url).toURL(); + } + } catch (MalformedURLException e) { + throw new IllegalArgumentException(e); + } + } + + /** + * Returns the File object representing the given URL. + * + * @param url + * @return + */ + public static File toFile(URL url) { + if (url == null || !url.getProtocol().equals("file")) { + return null; + } else { + String filename = url.getFile().replace('/', File.separatorChar); + int pos = 0; + while ((pos = filename.indexOf('%', pos)) >= 0) { + if (pos + 2 < filename.length()) { + String hexStr = filename.substring(pos + 1, pos + 3); + char ch = (char)Integer.parseInt(hexStr, 16); + filename = filename.substring(0, pos) + ch + filename.substring(pos + 3); + } + } + return new File(filename); + } + } + + /** + * Returns the location of the classpath entry, JAR, WAR etc. containing the given class. + * + * @param clazz + * @return + */ + public static URL codeLocation(Class clazz) { + URL url = clazz.getProtectionDomain().getCodeSource().getLocation(); + if (url == null) { + url = clazz.getResource("/" + clazz.getName().replace('.', '/') + ".class"); + } + return url; + } + + /** + * Returns a location string as a URL + * @param location + * @return + */ + public static URL getLocationAsURL(String location) { + URI uri = IOHelper.createURI(location); + if (uri.getScheme() == null) { + uri = new File(location).toURI(); + } + try { + return uri.toURL(); + } catch (MalformedURLException e) { + throw new IllegalArgumentException(location, e); + } + } + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelper.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelper.java new file mode 100644 index 0000000000..73ff2e2fb0 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/main/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelper.java @@ -0,0 +1,588 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +import java.beans.Introspector; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.GenericArrayType; +import java.lang.reflect.Method; +import java.lang.reflect.Modifier; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.lang.reflect.WildcardType; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.logging.Logger; + +import org.apache.tuscany.sca.core.ExtensionPointRegistry; +import org.apache.tuscany.sca.core.UtilityExtensionPoint; +import org.oasisopen.sca.ServiceReference; + +/** + * Implements various reflection-related operations + * + * @version $Rev$ $Date$ + */ +public final class JavaIntrospectionHelper { + private static final Logger logger = Logger.getLogger(JavaIntrospectionHelper.class.getName()); + private static final Class[] EMPTY_CLASS_ARRY = new Class[0]; + + private ExtensionPointRegistry registry; + + public JavaIntrospectionHelper(ExtensionPointRegistry registry) { + this.registry = registry; + } + + public static JavaIntrospectionHelper getInstance(ExtensionPointRegistry registry) { + UtilityExtensionPoint utilities = registry.getExtensionPoint(UtilityExtensionPoint.class); + return utilities.getUtility(JavaIntrospectionHelper.class); + } + + private static boolean matches(int modifiers, int include, int exclude) { + if (include != -1) { + if ((modifiers & include) == 0) { + return false; + } + } + if (exclude != -1) { + if ((modifiers & exclude) != 0) { + return false; + } + } + return true; + } + + /** + * Recursively evaluates the type hierarchy to return all fields that are + * public or protected + * @param clazz The java class + * @param fields The set that collects all fields + * @param include The modifiers to be included + * @param exclude The modifiers to be excluded + * @return The set that collects all matched fields + */ + private static Set getAllFields(Class clazz, Set fields, int include, int exclude) { + if (clazz == null || clazz.isArray() || Object.class.equals(clazz)) { + return fields; + } + fields = getAllFields(clazz.getSuperclass(), fields, include, exclude); + Field[] declaredFields = clazz.getDeclaredFields(); + for (final Field field : declaredFields) { + int modifiers = field.getModifiers(); + if (matches(modifiers, include, exclude)) { + // Allow privileged access to set accessibility. Requires ReflectPermission + // in security policy. + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + field.setAccessible(true); // ignore Java accessibility + return null; + } + }); + fields.add(field); + } + } + return fields; + } + + /** + * @param cls + * @return + */ + public Set getAllNonStaticOrFinalFields(Class cls) { + Set fields = new HashSet(); + return getAllFields(cls, fields, -1, Modifier.STATIC | Modifier.FINAL); + } + + /** + * @param cls + * @return + */ + public Set getAllNonStaticMethods(Class cls) { + Set methods = new HashSet(); + return getAllUniqueMethods(cls, methods, -1, Modifier.STATIC); + } + + /** + * Recursively evaluates the type hierarchy to return all unique methods + */ + private static Set getAllUniqueMethods(Class pClass, Set methods, int include, int exclude) { + if (pClass == null || pClass.isArray() || Object.class.equals(pClass)) { + return methods; + } + // we first evaluate methods of the subclass and then move to the parent + Method[] declaredMethods = pClass.getDeclaredMethods(); + for (final Method declaredMethod : declaredMethods) { + int modifiers = declaredMethod.getModifiers(); + if (!matches(modifiers, include, exclude)) { + continue; + } + if (methods.size() == 0) { + methods.add(declaredMethod); + } else { + List temp = new ArrayList(); + boolean matched = false; + for (Method method : methods) { + // only add if not already in the set from a superclass (i.e. + // the method is not overridden) + if (exactMethodMatch(declaredMethod, method)) { + matched = true; + break; + } + } + if (!matched) { + // Allow privileged access to set accessibility. Requires ReflectPermission + // in security policy. + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + declaredMethod.setAccessible(true); + return null; + } + }); + temp.add(declaredMethod); + } + methods.addAll(temp); + temp.clear(); + } + } + // evaluate class hierarchy - this is done last to track inherited + // methods + methods = getAllUniqueMethods(pClass.getSuperclass(), methods, include, exclude); + return methods; + } + + /** + * Finds the closest matching field with the given name, that is, a field of + * the exact specified type or, alternately, of a supertype. + * + * @param name the name of the field + * @param type the field type + * @param fields the collection of fields to search + * @return the matching field or null if not found + */ + public static Field findClosestMatchingField(String name, Class type, Set fields) { + Field candidate = null; + for (Field field : fields) { + if (field.getName().equals(name)) { + if (field.getType().equals(type)) { + return field; // exact match + } else if (field.getType().isAssignableFrom(type) || (field.getType().isPrimitive() && primitiveAssignable(field + .getType(), + type))) { + // We could have the situation where a field parameter is a + // primitive and the demarshalled value is + // an object counterpart (e.g. Integer and int) + // @spec issue + // either an interface or super class, so keep a reference + // until + // we know there are no closer types + candidate = field; + } + } + } + if (candidate != null) { + return candidate; + } else { + return null; + } + } + + /** + * Finds the closest matching method with the given name, that is, a method + * taking the exact parameter types or, alternately, parameter supertypes. + * + * @param name the name of the method + * @param types the method parameter types + * @param methods the collection of methods to search + * @return the matching method or null if not found + */ + public static Method findClosestMatchingMethod(String name, Class[] types, Set methods) { + if (types == null) { + types = EMPTY_CLASS_ARRY; + } + Method candidate = null; + for (Method method : methods) { + if (method.getName().equals(name) && method.getParameterTypes().length == types.length) { + Class[] params = method.getParameterTypes(); + boolean disqualify = false; + boolean exactMatch = true; + for (int i = 0; i < params.length; i++) { + if (!params[i].equals(types[i]) && !params[i].isAssignableFrom(types[i])) { + // no match + disqualify = true; + exactMatch = false; + break; + } else if (!params[i].equals(types[i]) && params[i].isAssignableFrom(types[i])) { + // not exact match + exactMatch = false; + } + } + if (disqualify) { + continue; + } else if (exactMatch) { + return method; + } else { + candidate = method; + } + } + } + if (candidate != null) { + return candidate; + } else { + return null; + } + } + + /** + * Determines if two methods "match" - that is, they have the same method + * names and exact parameter types (one is not a supertype of the other) + */ + public static boolean exactMethodMatch(Method method1, Method method2) { + if (!method1.getName().equals(method2.getName())) { + return false; + } + Class[] types1 = method1.getParameterTypes(); + Class[] types2 = method2.getParameterTypes(); + if (types1.length != types2.length) { + return false; + } + boolean matched = true; + for (int i = 0; i < types1.length; i++) { + if (types1[i] != types2[i]) { + matched = false; + break; + } + } + return matched; + } + + public static Constructor getDefaultConstructor(Class clazz) throws NoSuchMethodException { + return clazz.getConstructor(); + } + + /** + * Returns the simple name of a class - i.e. the class name devoid of its + * package qualifier + * + * @param implClass the implementation class + */ + public static String getBaseName(Class implClass) { + return implClass.getSimpleName(); + } + + public static boolean isImmutable(Class clazz) { + return String.class == clazz || clazz.isPrimitive() + || Number.class.isAssignableFrom(clazz) + || Boolean.class.isAssignableFrom(clazz) + || Character.class.isAssignableFrom(clazz) + || Byte.class.isAssignableFrom(clazz); + } + + /** + * Takes a property name and converts it to a getter method name according + * to JavaBean conventions. For example, property + * foo is returned as getFoo + */ + public static String toGetter(String name) { + return "get" + name.toUpperCase().substring(0, 1) + name.substring(1); + } + + /** + * Takes a setter or getter method name and converts it to a property name + * according to JavaBean conventions. For example, setFoo(var) + * is returned as property foo + */ + public static String toPropertyName(Method method) { + if (isGetter(method) || isSetter(method)) { + String name = method.getName(); + if (name.startsWith("get") || name.startsWith("set")) { + return Introspector.decapitalize(name.substring(3)); + } else { + // Starts with is + return Introspector.decapitalize(name.substring(2)); + } + } else { + throw new IllegalArgumentException("Method is not a setter or getter: " + method); + } + } + + public static Class getErasure(Type type) { + if (type instanceof Class) { + return (Class)type; + } else if (type instanceof GenericArrayType) { + // FIXME: How to deal with the []? + GenericArrayType arrayType = (GenericArrayType)type; + return getErasure(arrayType.getGenericComponentType()); + } else if (type instanceof ParameterizedType) { + ParameterizedType pType = (ParameterizedType)type; + return getErasure(pType.getRawType()); + } else if (type instanceof WildcardType) { + WildcardType wType = (WildcardType)type; + Type[] types = wType.getUpperBounds(); + return getErasure(types[0]); + } else if (type instanceof TypeVariable) { + TypeVariable var = (TypeVariable)type; + Type[] types = var.getBounds(); + return getErasure(types[0]); + } + return null; + } + + public static Class getBaseType(Class cls, Type genericType) { + if (cls.isArray()) { + return cls.getComponentType(); + } else if (Collection.class.isAssignableFrom(cls)) { + if (genericType instanceof ParameterizedType) { + // Collection + ParameterizedType parameterizedType = (ParameterizedType)genericType; + Type baseType = parameterizedType.getActualTypeArguments()[0]; + if (baseType instanceof GenericArrayType) { + // Base is array + return cls; + } else { + return getErasure(baseType); + } + } else { + return cls; + } + } else { + return cls; + } + } + + public static Type getParameterType(Type type) { + if (type instanceof ParameterizedType) { + // Collection + ParameterizedType parameterizedType = (ParameterizedType)type; + Type baseType = parameterizedType.getActualTypeArguments()[0]; + return baseType; + } else { + return Object.class; + } + } + + public static Class getBusinessInterface(Class cls, Type callableReferenceType) { + if (ServiceReference.class.isAssignableFrom(cls) && callableReferenceType instanceof ParameterizedType) { + // Collection + ParameterizedType parameterizedType = (ParameterizedType)callableReferenceType; + Type baseType = parameterizedType.getActualTypeArguments()[0]; + if (baseType instanceof GenericArrayType) { + // Base is array + return cls; + } else { + return getErasure(baseType); + } + } + return Object.class; + } + + /** + * Takes a property name and converts it to a setter method name according + * to JavaBean conventions. For example, the property + * foo is returned as setFoo(var) + */ + public static String toSetter(String name) { + return "set" + name.toUpperCase().substring(0, 1) + name.substring(1); + } + + /** + * Compares a two types, assuming one is a primitive, to determine if the + * other is its object counterpart + */ + private static boolean primitiveAssignable(Class memberType, Class param) { + if (memberType == Integer.class) { + return param == Integer.TYPE; + } else if (memberType == Double.class) { + return param == Double.TYPE; + } else if (memberType == Float.class) { + return param == Float.TYPE; + } else if (memberType == Short.class) { + return param == Short.TYPE; + } else if (memberType == Character.class) { + return param == Character.TYPE; + } else if (memberType == Boolean.class) { + return param == Boolean.TYPE; + } else if (memberType == Byte.class) { + return param == Byte.TYPE; + } else if (param == Integer.class) { + return memberType == Integer.TYPE; + } else if (param == Double.class) { + return memberType == Double.TYPE; + } else if (param == Float.class) { + return memberType == Float.TYPE; + } else if (param == Short.class) { + return memberType == Short.TYPE; + } else if (param == Character.class) { + return memberType == Character.TYPE; + } else if (param == Boolean.class) { + return memberType == Boolean.TYPE; + } else if (param == Byte.class) { + return memberType == Byte.TYPE; + } else { + return false; + } + } + + /** + * Returns the generic types represented in the given type. Usage as + * follows: + * JavaIntrospectionHelper.getGenerics(field.getGenericType()); + *

+ * JavaIntrospectionHelper.getGenerics(m.getGenericParameterTypes()[0];); + * + * @return the generic types in order of declaration or an empty array if + * the type is not genericized + */ + public static List getGenerics(Type genericType) { + List classes = new ArrayList(); + if (genericType instanceof ParameterizedType) { + ParameterizedType ptype = (ParameterizedType)genericType; + // get the type arguments + Type[] targs = ptype.getActualTypeArguments(); + for (Type targ : targs) { + classes.add(targ); + } + } + return classes; + } + + /** + * Returns the generic type specified by the class at the given position as + * in:

public class Foo{ //.. } + *

+ * JavaIntrospectionHelper.introspectGeneric(Foo.class,1); + *

+ * will return Baz. + */ + public static Class introspectGeneric(Class clazz, int pos) { + assert clazz != null : "No class specified"; + Type type = clazz.getGenericSuperclass(); + if (type instanceof ParameterizedType) { + Type[] args = ((ParameterizedType)type).getActualTypeArguments(); + if (args.length <= pos) { + throw new IllegalArgumentException("Invalid index value for generic class " + clazz.getName()); + } + return (Class)((ParameterizedType)type).getActualTypeArguments()[pos]; + } else { + Type[] interfaces = clazz.getGenericInterfaces(); + for (Type itype : interfaces) { + if (!(itype instanceof ParameterizedType)) { + continue; + } + ParameterizedType interfaceType = (ParameterizedType)itype; + return (Class)interfaceType.getActualTypeArguments()[0]; + } + } + return null; + } + + /** + * Returns the set of interfaces implemented by the given class and its + * ancestors or a blank set if none + */ + public List> getAllInterfaces(Class clazz) { + List> implemented = new ArrayList>(); + getAllInterfaces(clazz, implemented); + return implemented; + } + + private static void getAllInterfaces(Class clazz, List> implemented) { + Class[] interfaces = clazz.getInterfaces(); + for (Class interfaze : interfaces) { + if (!implemented.contains(interfaze)) { + implemented.add(interfaze); + } + } + Class superClass = clazz.getSuperclass(); + // Object has no superclass so check for null + if (superClass != null && !superClass.equals(Object.class)) { + getAllInterfaces(superClass, implemented); + } + } + + /** + * Test if a method follows the JavaBeans setter pattern + * @param method + * @return + */ + public static boolean isSetter(Method method) { + return (void.class == method.getReturnType() && method.getParameterTypes().length == 1 + && method.getName().startsWith("set") && method.getName().length() > 3); + } + + /** + * Test if a method follows the JavaBeans getter pattern + * @param method + * @return + */ + public static boolean isGetter(Method method) { + if (method.getParameterTypes().length == 0) { + return false; + } + Class returnType = method.getReturnType(); + if (returnType == void.class || returnType == Void.class) { + return false; + } + String name = method.getName(); + if (returnType == boolean.class) + if (name.length() > 2 && name.startsWith("is")) { + return true; + } + return name.length() > 3 && name.startsWith("get"); + } + + private final static Map, String> signatures = new HashMap, String>(); + static { + signatures.put(boolean.class, "Z"); + signatures.put(byte.class, "B"); + signatures.put(char.class, "C"); + signatures.put(short.class, "S"); + signatures.put(int.class, "I"); + signatures.put(long.class, "J"); + signatures.put(float.class, "F"); + signatures.put(double.class, "D"); + }; + + public static String getSignature(Class cls) { + if (cls.isPrimitive()) { + return signatures.get(cls); + } + if (cls.isArray()) { + return "[" + getSignature(cls.getComponentType()); + } + return "L" + cls.getName().replace('.', '/') + ";"; + } + + public static Class getArrayType(Class componentType, int dims) throws ClassNotFoundException { + StringBuffer buf = new StringBuffer(); + for (int i = 0; i < dims; i++) { + buf.append('['); + } + buf.append(getSignature(componentType)); + return Class.forName(buf.toString(), false, componentType.getClassLoader()); + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelperTestCase.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelperTestCase.java new file mode 100644 index 0000000000..25d694a9d7 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/JavaIntrospectionHelperTestCase.java @@ -0,0 +1,72 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; +import java.util.Set; + +import org.apache.tuscany.sca.core.DefaultExtensionPointRegistry; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.Test; + +/** + * + */ +public class JavaIntrospectionHelperTestCase { + private static JavaIntrospectionHelper helper; + + /** + * @throws java.lang.Exception + */ + @BeforeClass + public static void setUpBeforeClass() throws Exception { + helper = JavaIntrospectionHelper.getInstance(new DefaultExtensionPointRegistry()); + } + + @Test + public void testGetMethods() { + Set methods = helper.getAllNonStaticMethods(SubTestImpl.class); + System.out.println(methods); + } + + @Test + public void testGetFields() { + Set fields = helper.getAllNonStaticOrFinalFields(SubTestImpl.class); + System.out.println(fields); + } + + @Test + public void testGetAllInterfaces() { + List> interfaces = helper.getAllInterfaces(SubTestImpl.class); + System.out.println(interfaces); + } + + /** + * @throws java.lang.Exception + */ + @AfterClass + public static void tearDownAfterClass() throws Exception { + helper = null; + } + +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/SubTestImpl.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/SubTestImpl.java new file mode 100644 index 0000000000..77595f3281 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/SubTestImpl.java @@ -0,0 +1,45 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +/** + * + */ +public class SubTestImpl extends TestImpl implements Test2 { + private final int age = 0; + public String message; + protected static Test1 test1; + + public void test2(int i) { + System.out.println(age + i); + } + + @Override + public String test(String str) { + return hello(str); + } + + private String hello(String str) { + return message + ":" + str; + } + + public static void test4() { + } +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test1.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test1.java new file mode 100644 index 0000000000..c7a25d95c2 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test1.java @@ -0,0 +1,28 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +/** + * + */ +public interface Test1 { + String test(String str); + void test1(int i); +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test2.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test2.java new file mode 100644 index 0000000000..2b751af3eb --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/Test2.java @@ -0,0 +1,28 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +/** + * + */ +public interface Test2 { + String test(String str); + void test2(int i); +} diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/TestImpl.java b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/TestImpl.java new file mode 100644 index 0000000000..1bb7432b63 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/common-java/src/test/java/org/apache/tuscany/sca/common/java/reflection/TestImpl.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you 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.apache.tuscany.sca.common.java.reflection; + +/** + * + */ +public class TestImpl implements Test1 { + private String message; + protected Test2 test2; + + public void test1(int i) { + } + + protected void setTest2(Test2 test2) { + this.test2 = test2; + } + + public String test(String str) { + return hello(str); + } + + private String hello(String str) { + return message + ":" + str; + } + +} -- cgit v1.2.3