You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tomee.apache.org by rm...@apache.org on 2012/04/18 10:00:52 UTC
svn commit: r1327413 [1/2] - in
/openejb/trunk/patched-libraries/cxf-bundle-patched: ./
src/main/java/org/apache/cxf/binding/
src/main/java/org/apache/cxf/binding/corba/
src/main/java/org/apache/cxf/binding/corba/utils/
src/main/java/org/apache/cxf/com...
Author: rmannibucau
Date: Wed Apr 18 08:00:51 2012
New Revision: 1327413
URL: http://svn.apache.org/viewvc?rev=1327413&view=rev
Log:
updating cxf version and getting rid of asm dependency
Added:
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/CorbaAnyHelper.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/JAXBUtils.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/ASMHelper.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/endpoint/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/endpoint/dynamic/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/endpoint/dynamic/TypeClassInitializer.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/jaxb/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/jaxb/JAXBDataBinding.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/jaxb/WrapperHelperCompiler.java
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/jaxws/
openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/jaxws/WrapperClassGenerator.java
Modified:
openejb/trunk/patched-libraries/cxf-bundle-patched/pom.xml
Modified: openejb/trunk/patched-libraries/cxf-bundle-patched/pom.xml
URL: http://svn.apache.org/viewvc/openejb/trunk/patched-libraries/cxf-bundle-patched/pom.xml?rev=1327413&r1=1327412&r2=1327413&view=diff
==============================================================================
--- openejb/trunk/patched-libraries/cxf-bundle-patched/pom.xml (original)
+++ openejb/trunk/patched-libraries/cxf-bundle-patched/pom.xml Wed Apr 18 08:00:51 2012
@@ -26,14 +26,19 @@
<groupId>org.apache.openejb.patch</groupId>
<artifactId>openejb-cxf-bundle</artifactId>
- <version>2.5.2-SNAPSHOT</version>
+ <version>2.6.0-SNAPSHOT</version>
<name>Apache OpenEJB Patch :: CXF Bundle</name>
<dependencies>
<dependency>
+ <groupId>org.apache.xbean</groupId>
+ <artifactId>xbean-asm-shaded</artifactId>
+ <version>3.11-SNAPSHOT</version>
+ </dependency>
+ <dependency>
<groupId>org.apache.cxf</groupId>
<artifactId>cxf-bundle</artifactId>
- <version>2.5.2</version>
+ <version>2.6.0</version>
<scope>provided</scope>
</dependency>
<dependency>
@@ -45,7 +50,7 @@
<dependency>
<groupId>org.codehaus.woodstox</groupId>
<artifactId>woodstox-core-asl</artifactId>
- <version>4.1.1</version>
+ <version>4.1.2</version>
<scope>compile</scope>
<exclusions>
<exclusion>
@@ -87,7 +92,7 @@
<dependency>
<groupId>org.apache.neethi</groupId>
<artifactId>neethi</artifactId>
- <version>3.0.1</version>
+ <version>3.0.2</version>
<scope>compile</scope>
</dependency>
<dependency>
@@ -97,21 +102,15 @@
<scope>compile</scope>
</dependency>
<dependency>
- <groupId>asm</groupId>
- <artifactId>asm</artifactId>
- <version>3.3</version>
- <scope>compile</scope>
- </dependency>
- <dependency>
<groupId>com.sun.xml.messaging.saaj</groupId>
<artifactId>saaj-impl</artifactId>
- <version>1.3.12</version>
+ <version>1.3.18</version>
<scope>compile</scope>
</dependency>
<dependency>
- <groupId>org.jvnet</groupId>
+ <groupId>org.jvnet.mimepull</groupId>
<artifactId>mimepull</artifactId>
- <version>1.4</version>
+ <version>1.7</version>
<scope>compile</scope>
</dependency>
<dependency>
@@ -159,7 +158,7 @@
<dependency>
<groupId>org.apache.ws.security</groupId>
<artifactId>wss4j</artifactId>
- <version>1.6.3</version>
+ <version>1.6.5</version>
<scope>compile</scope>
</dependency>
<dependency>
@@ -280,6 +279,16 @@
</exclusion>
</exclusions>
</dependency>
+ <dependency>
+ <groupId>net.oauth.core</groupId>
+ <artifactId>oauth-provider</artifactId>
+ <version>20100527</version>
+ </dependency>
+ <dependency>
+ <groupId>net.oauth.core</groupId>
+ <artifactId>oauth</artifactId>
+ <version>20100527</version>
+ </dependency>
</dependencies>
<build>
@@ -291,12 +300,22 @@
<executions>
<execution>
<id>patch</id>
- <phase>process-classes</phase>
+ <phase>process-sources</phase>
<goals>
<goal>unpack</goal>
</goals>
<configuration>
- <excludes>META-INF/services/javax.ws.rs.ext.RuntimeDelegate,org/apache/cxf/jaxrs/impl/HttpHeadersImpl.class</excludes>
+ <excludes>
+ META-INF/services/javax.ws.rs.ext.RuntimeDelegate,
+ org/apache/cxf/binding/corba/utils/CorbaAnyHelper.class,
+ org/apache/cxf/common/jaxb/JAXBUtils.class,
+ org/apache/cxf/common/util/ASMHelper.class,
+ org/apache/cxf/endpoint/dynamic/TypeClassInitializer.class,
+ org/apache/cxf/jaxb/JAXBDataBinding.class,
+ org/apache/cxf/jaxb/WrapperHelperCompiler.class,
+ org/apache/cxf/jaxrs/impl/HttpHeadersImpl.class,
+ org/apache/cxf/jaxws/WrapperClassGenerator.class
+ </excludes>
<artifactItems>
<artifactItem>
<groupId>org.apache.cxf</groupId>
Added: openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/CorbaAnyHelper.java
URL: http://svn.apache.org/viewvc/openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/CorbaAnyHelper.java?rev=1327413&view=auto
==============================================================================
--- openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/CorbaAnyHelper.java (added)
+++ openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/binding/corba/utils/CorbaAnyHelper.java Wed Apr 18 08:00:51 2012
@@ -0,0 +1,531 @@
+/**
+ * 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.cxf.binding.corba.utils;
+
+import java.lang.reflect.Constructor;
+import java.math.BigInteger;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.xml.namespace.QName;
+
+import org.apache.cxf.binding.corba.CorbaBindingException;
+import org.apache.cxf.binding.corba.types.CorbaPrimitiveHandler;
+import org.apache.cxf.binding.corba.wsdl.CorbaConstants;
+import org.apache.cxf.binding.corba.wsdl.W3CConstants;
+import org.apache.cxf.common.util.ASMHelper;
+import org.apache.xbean.asm.ClassWriter;
+import org.apache.xbean.asm.FieldVisitor;
+import org.apache.xbean.asm.Label;
+import org.apache.xbean.asm.MethodVisitor;
+import org.apache.xbean.asm.Opcodes;
+import org.omg.CORBA.Any;
+import org.omg.CORBA.ORB;
+import org.omg.CORBA.TCKind;
+import org.omg.CORBA.TypeCode;
+
+public final class CorbaAnyHelper {
+
+ private static final Map<QName, QName> SCHEMA_TO_IDL_TYPES = new HashMap<QName, QName>();
+ private static final Map<QName, QName> IDL_TO_SCHEMA_TYPES = new HashMap<QName, QName>();
+
+ private static Constructor<?> fixedAnyConstructor;
+
+ private CorbaAnyHelper() {
+ //utility class
+ }
+
+ public static Any createAny(ORB orb) {
+ Any value = orb.create_any();
+ if ("com.sun.corba.se.impl.corba.AnyImpl".equals(value.getClass().getName())) {
+ value = createFixedAny(orb, value);
+ }
+
+ return value;
+ }
+
+ public static boolean isPrimitiveSchemaType(QName schemaType) {
+ return SCHEMA_TO_IDL_TYPES.get(schemaType) != null;
+ }
+
+ public static boolean isPrimitiveIdlType(QName idlType) {
+ return IDL_TO_SCHEMA_TYPES.get(idlType) != null;
+ }
+
+ public static QName convertPrimitiveSchemaToIdlType(QName schemaType) {
+ return SCHEMA_TO_IDL_TYPES.get(schemaType);
+ }
+
+ public static QName convertPrimitiveIdlToSchemaType(QName idlType) {
+ return IDL_TO_SCHEMA_TYPES.get(idlType);
+ }
+
+ public static QName getPrimitiveIdlTypeFromTypeCode(TypeCode tc) {
+ TCKind type = tc.kind();
+ QName result = null;
+
+ switch(type.value()) {
+ case TCKind._tk_boolean:
+ result = CorbaConstants.NT_CORBA_BOOLEAN;
+ break;
+ case TCKind._tk_char:
+ result = CorbaConstants.NT_CORBA_CHAR;
+ break;
+ case TCKind._tk_wchar:
+ result = CorbaConstants.NT_CORBA_WCHAR;
+ break;
+ case TCKind._tk_octet:
+ result = CorbaConstants.NT_CORBA_OCTET;
+ break;
+ case TCKind._tk_short:
+ result = CorbaConstants.NT_CORBA_SHORT;
+ break;
+ case TCKind._tk_ushort:
+ result = CorbaConstants.NT_CORBA_USHORT;
+ break;
+ case TCKind._tk_long:
+ result = CorbaConstants.NT_CORBA_LONG;
+ break;
+ case TCKind._tk_ulong:
+ result = CorbaConstants.NT_CORBA_ULONG;
+ break;
+ case TCKind._tk_longlong:
+ result = CorbaConstants.NT_CORBA_LONGLONG;
+ break;
+ case TCKind._tk_ulonglong:
+ result = CorbaConstants.NT_CORBA_ULONGLONG;
+ break;
+ case TCKind._tk_float:
+ result = CorbaConstants.NT_CORBA_FLOAT;
+ break;
+ case TCKind._tk_double:
+ result = CorbaConstants.NT_CORBA_DOUBLE;
+ break;
+ case TCKind._tk_string:
+ result = CorbaConstants.NT_CORBA_STRING;
+ break;
+ case TCKind._tk_wstring:
+ result = CorbaConstants.NT_CORBA_WSTRING;
+ break;
+ default:
+ result = null;
+ }
+
+ return result;
+ }
+
+ public static void insertPrimitiveIntoAny(Any a, CorbaPrimitiveHandler primitive)
+ throws CorbaBindingException {
+ assert primitive != null;
+ switch (primitive.getTypeCode().kind().value()) {
+ case TCKind._tk_boolean:
+ a.insert_boolean((Boolean)primitive.getValue());
+ break;
+ case TCKind._tk_char:
+ a.insert_char((Character)primitive.getValue());
+ break;
+ case TCKind._tk_wchar:
+ a.insert_wchar((Character)primitive.getValue());
+ break;
+ case TCKind._tk_octet:
+ a.insert_octet((Byte)primitive.getValue());
+ break;
+ case TCKind._tk_short:
+ a.insert_short((Short)primitive.getValue());
+ break;
+ case TCKind._tk_ushort:
+ a.insert_ushort(((Integer)primitive.getValue()).shortValue());
+ break;
+ case TCKind._tk_long:
+ a.insert_long((Integer)primitive.getValue());
+ break;
+ case TCKind._tk_ulong:
+ a.insert_ulong(((BigInteger)primitive.getValue()).intValue());
+ break;
+ case TCKind._tk_longlong:
+ a.insert_longlong((Long)primitive.getValue());
+ break;
+ case TCKind._tk_ulonglong:
+ a.insert_ulonglong(((BigInteger)primitive.getValue()).intValue());
+ break;
+ case TCKind._tk_float:
+ a.insert_float((Float)primitive.getValue());
+ break;
+ case TCKind._tk_double:
+ a.insert_double((Double)primitive.getValue());
+ break;
+ case TCKind._tk_string:
+ a.insert_string((String)primitive.getValue());
+ break;
+ case TCKind._tk_wstring:
+ a.insert_wstring((String)primitive.getValue());
+ break;
+ default:
+ throw new CorbaBindingException("Unable to insert type into any. Kind = "
+ + primitive.getTypeCode().kind().value());
+ }
+ }
+
+ public static void extractPrimitiveFromAny(Any a, CorbaPrimitiveHandler primitive) {
+ assert primitive != null;
+ switch (primitive.getTypeCode().kind().value()) {
+ case TCKind._tk_boolean:
+ primitive.setValue(Boolean.valueOf(a.extract_boolean()));
+ break;
+ case TCKind._tk_char:
+ primitive.setValue(Character.valueOf(a.extract_char()));
+ break;
+ case TCKind._tk_wchar:
+ primitive.setValue(Character.valueOf(a.extract_wchar()));
+ break;
+ case TCKind._tk_octet:
+ primitive.setValue(Byte.valueOf(a.extract_octet()));
+ break;
+ case TCKind._tk_short:
+ primitive.setValue(Short.valueOf(a.extract_short()));
+ break;
+ case TCKind._tk_ushort:
+ primitive.setValue(Integer.valueOf(a.extract_ushort()));
+ break;
+ case TCKind._tk_long:
+ primitive.setValue(Integer.valueOf(a.extract_long()));
+ break;
+ case TCKind._tk_ulong:
+ primitive.setValue(BigInteger.valueOf(a.extract_ulong()));
+ break;
+ case TCKind._tk_longlong:
+ primitive.setValue(Long.valueOf(a.extract_longlong()));
+ break;
+ case TCKind._tk_ulonglong:
+ primitive.setValue(BigInteger.valueOf(a.extract_ulonglong()));
+ break;
+ case TCKind._tk_float:
+ primitive.setValue(Float.valueOf(a.extract_float()));
+ break;
+ case TCKind._tk_double:
+ primitive.setValue(Double.valueOf(a.extract_double()));
+ break;
+ case TCKind._tk_string:
+ primitive.setValue(a.extract_string());
+ break;
+ case TCKind._tk_wstring:
+ primitive.setValue(a.extract_wstring());
+ break;
+ default:
+ throw new CorbaBindingException("Unable to extract type from any. Kind = "
+ + primitive.getTypeCode().kind().value());
+ }
+ }
+
+ // NOTE: We have an issue when we get a schema type of String. We don't know whether this means
+ // that we have an IDL type of wchar, string, or wstring. To be safe, we'll simply use a CORBA
+ // string for the mapping.
+ static {
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_BOOLEAN, CorbaConstants.NT_CORBA_BOOLEAN);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_BYTE, CorbaConstants.NT_CORBA_CHAR);
+ //SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_STRING, CorbaConstants.NT_CORBA_WCHAR);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_UBYTE, CorbaConstants.NT_CORBA_OCTET);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_SHORT, CorbaConstants.NT_CORBA_SHORT);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_USHORT, CorbaConstants.NT_CORBA_USHORT);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_INT, CorbaConstants.NT_CORBA_LONG);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_UINT, CorbaConstants.NT_CORBA_ULONG);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_LONG, CorbaConstants.NT_CORBA_LONGLONG);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_ULONG, CorbaConstants.NT_CORBA_ULONGLONG);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_FLOAT, CorbaConstants.NT_CORBA_FLOAT);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_DOUBLE, CorbaConstants.NT_CORBA_DOUBLE);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_STRING, CorbaConstants.NT_CORBA_STRING);
+ //SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_STRING, CorbaConstants.NT_CORBA_WSTRING);
+ SCHEMA_TO_IDL_TYPES.put(W3CConstants.NT_SCHEMA_ANYTYPE, CorbaConstants.NT_CORBA_ANY);
+ }
+
+ static {
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_BOOLEAN, W3CConstants.NT_SCHEMA_BOOLEAN);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_CHAR, W3CConstants.NT_SCHEMA_BYTE);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_WCHAR, W3CConstants.NT_SCHEMA_STRING);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_OCTET, W3CConstants.NT_SCHEMA_UBYTE);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_SHORT, W3CConstants.NT_SCHEMA_SHORT);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_USHORT, W3CConstants.NT_SCHEMA_USHORT);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_LONG, W3CConstants.NT_SCHEMA_INT);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_ULONG, W3CConstants.NT_SCHEMA_UINT);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_LONGLONG, W3CConstants.NT_SCHEMA_LONG);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_ULONGLONG, W3CConstants.NT_SCHEMA_ULONG);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_FLOAT, W3CConstants.NT_SCHEMA_FLOAT);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_DOUBLE, W3CConstants.NT_SCHEMA_DOUBLE);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_STRING, W3CConstants.NT_SCHEMA_STRING);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_WSTRING, W3CConstants.NT_SCHEMA_STRING);
+ IDL_TO_SCHEMA_TYPES.put(CorbaConstants.NT_CORBA_ANY, W3CConstants.NT_SCHEMA_ANYTYPE);
+ }
+
+ private static Any createFixedAny(ORB orb, Any any) {
+ createFixedAnyConstructor();
+ try {
+ return (Any)fixedAnyConstructor.newInstance(orb, any);
+ } catch (Exception e) {
+ return any;
+ }
+ }
+ private static synchronized void createFixedAnyConstructor() {
+ if (fixedAnyConstructor != null) {
+ return;
+ }
+
+ ASMHelper helper = new ASMHelper();
+ ClassWriter cw = helper.createClassWriter();
+ FieldVisitor fv;
+
+ cw.visit(Opcodes.V1_5, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER,
+ "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ null, "com/sun/corba/se/impl/corba/AnyImpl", null);
+
+ cw.visitSource("FixedAnyImpl.java", null);
+
+ fv = cw.visitField(0, "obj", "Lorg/omg/CORBA/portable/Streamable;", null, null);
+ fv.visitEnd();
+ addFixedAnyConstructor(cw);
+ addInsertOverride(cw);
+ addExtractOverride(cw);
+ addReadOverride(cw);
+ addWriteOverride(cw);
+
+ cw.visitEnd();
+
+ byte[] b = cw.toByteArray();
+ Class<?> c = helper.loadClass("org.apache.cxf.binding.corba.utils.FixedAnyImpl",
+ CorbaAnyHelper.class, b);
+ try {
+ fixedAnyConstructor = c.getConstructor(ORB.class, Any.class);
+ } catch (Exception e) {
+ //shouldn't happen since we generated that constructor
+ }
+ }
+
+ private static void addReadOverride(ClassWriter cw) {
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "read_value",
+ "(Lorg/omg/CORBA/portable/InputStream;Lorg/omg/CORBA/TypeCode;)V",
+ null, null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(54, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ Label l1 = new Label();
+ mv.visitJumpInsn(Opcodes.IFNULL, l1);
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(55, l2);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "org/omg/CORBA/portable/Streamable",
+ "_read", "(Lorg/omg/CORBA/portable/InputStream;)V");
+ Label l3 = new Label();
+ mv.visitJumpInsn(Opcodes.GOTO, l3);
+ mv.visitLabel(l1);
+ mv.visitLineNumber(57, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "com/sun/corba/se/impl/corba/AnyImpl",
+ "read_value",
+ "(Lorg/omg/CORBA/portable/InputStream;Lorg/omg/CORBA/TypeCode;)V");
+ mv.visitLabel(l3);
+ mv.visitLineNumber(59, l3);
+ mv.visitInsn(Opcodes.RETURN);
+ Label l4 = new Label();
+ mv.visitLabel(l4);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;",
+ null, l0, l4, 0);
+ mv.visitLocalVariable("is", "Lorg/omg/CORBA/portable/InputStream;", null, l0, l4, 1);
+ mv.visitLocalVariable("t", "Lorg/omg/CORBA/TypeCode;", null, l0, l4, 2);
+ mv.visitMaxs(3, 3);
+ mv.visitEnd();
+ }
+
+ private static void addWriteOverride(ClassWriter cw) {
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "write_value",
+ "(Lorg/omg/CORBA/portable/OutputStream;)V", null, null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(61, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ Label l1 = new Label();
+ mv.visitJumpInsn(Opcodes.IFNULL, l1);
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(62, l2);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "org/omg/CORBA/portable/Streamable",
+ "_write", "(Lorg/omg/CORBA/portable/OutputStream;)V");
+ Label l3 = new Label();
+ mv.visitJumpInsn(Opcodes.GOTO, l3);
+ mv.visitLabel(l1);
+ mv.visitLineNumber(64, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "com/sun/corba/se/impl/corba/AnyImpl",
+ "write_value", "(Lorg/omg/CORBA/portable/OutputStream;)V");
+ mv.visitLabel(l3);
+ mv.visitLineNumber(66, l3);
+ mv.visitInsn(Opcodes.RETURN);
+ Label l4 = new Label();
+ mv.visitLabel(l4);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;",
+ null, l0, l4, 0);
+ mv.visitLocalVariable("os", "Lorg/omg/CORBA/portable/OutputStream;", null, l0, l4, 1);
+ mv.visitMaxs(2, 2);
+ mv.visitEnd();
+
+ }
+
+ private static void addExtractOverride(ClassWriter cw) {
+ // TODO Auto-generated method stub
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "extract_Streamable",
+ "()Lorg/omg/CORBA/portable/Streamable;", null, null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(47, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ Label l1 = new Label();
+ mv.visitJumpInsn(Opcodes.IFNULL, l1);
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(48, l2);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD, "org/apache/cxf/binding/corba/utils/FixedAnyImpl",
+ "obj", "Lorg/omg/CORBA/portable/Streamable;");
+ mv.visitInsn(Opcodes.ARETURN);
+ mv.visitLabel(l1);
+ mv.visitLineNumber(50, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "com/sun/corba/se/impl/corba/AnyImpl",
+ "extract_Streamable", "()Lorg/omg/CORBA/portable/Streamable;");
+ mv.visitInsn(Opcodes.ARETURN);
+ Label l3 = new Label();
+ mv.visitLabel(l3);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;", null, l0, l3, 0);
+ mv.visitMaxs(1, 1);
+ mv.visitEnd();
+
+ }
+
+ private static void addInsertOverride(ClassWriter cw) {
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC,
+ "insert_Streamable",
+ "(Lorg/omg/CORBA/portable/Streamable;)V", null, null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(43, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ "com/sun/corba/se/impl/corba/AnyImpl",
+ "insert_Streamable",
+ "(Lorg/omg/CORBA/portable/Streamable;)V");
+ Label l1 = new Label();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(44, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitFieldInsn(Opcodes.PUTFIELD,
+ "org/apache/cxf/binding/corba/utils/FixedAnyImpl", "obj",
+ "Lorg/omg/CORBA/portable/Streamable;");
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(45, l2);
+ mv.visitInsn(Opcodes.RETURN);
+ Label l3 = new Label();
+ mv.visitLabel(l3);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;",
+ null, l0, l3, 0);
+ mv.visitLocalVariable("s", "Lorg/omg/CORBA/portable/Streamable;", null, l0, l3, 1);
+ mv.visitMaxs(2, 2);
+ mv.visitEnd();
+ }
+
+ private static void addFixedAnyConstructor(ClassWriter cw) {
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "(Lorg/omg/CORBA/ORB;)V", null, null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(36, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitTypeInsn(Opcodes.CHECKCAST, "com/sun/corba/se/spi/orb/ORB");
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ "com/sun/corba/se/impl/corba/AnyImpl",
+ "<init>", "(Lcom/sun/corba/se/spi/orb/ORB;)V");
+ Label l1 = new Label();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(37, l1);
+ mv.visitInsn(Opcodes.RETURN);
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLocalVariable("this",
+ "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;",
+ null, l0, l2, 0);
+ mv.visitLocalVariable("orb", "Lorg/omg/CORBA/ORB;", null, l0, l2, 1);
+ mv.visitMaxs(2, 2);
+ mv.visitEnd();
+
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
+ "(Lorg/omg/CORBA/ORB;Lorg/omg/CORBA/Any;)V",
+ null, null);
+ mv.visitCode();
+ l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(39, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitTypeInsn(Opcodes.CHECKCAST, "com/sun/corba/se/spi/orb/ORB");
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ "com/sun/corba/se/impl/corba/AnyImpl",
+ "<init>",
+ "(Lcom/sun/corba/se/spi/orb/ORB;Lorg/omg/CORBA/Any;)V");
+ l1 = new Label();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(40, l1);
+ mv.visitInsn(Opcodes.RETURN);
+ l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/binding/corba/utils/FixedAnyImpl;",
+ null, l0, l2, 0);
+ mv.visitLocalVariable("orb", "Lorg/omg/CORBA/ORB;", null, l0, l2, 1);
+ mv.visitLocalVariable("any", "Lorg/omg/CORBA/Any;", null, l0, l2, 2);
+ mv.visitMaxs(3, 3);
+ mv.visitEnd();
+
+ }
+}
+
Added: openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/JAXBUtils.java
URL: http://svn.apache.org/viewvc/openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/JAXBUtils.java?rev=1327413&view=auto
==============================================================================
--- openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/JAXBUtils.java (added)
+++ openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/jaxb/JAXBUtils.java Wed Apr 18 08:00:51 2012
@@ -0,0 +1,1160 @@
+/**
+ * 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.cxf.common.jaxb;
+
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Target;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.StringTokenizer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.PropertyException;
+import javax.xml.bind.SchemaOutputResolver;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.attachment.AttachmentMarshaller;
+import javax.xml.bind.attachment.AttachmentUnmarshaller;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import javax.xml.transform.Result;
+import javax.xml.transform.dom.DOMResult;
+import javax.xml.transform.stream.StreamResult;
+
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+import org.xml.sax.InputSource;
+
+import org.apache.cxf.common.logging.LogUtils;
+import org.apache.cxf.common.util.ASMHelper;
+import org.apache.cxf.common.util.CachedClass;
+import org.apache.cxf.common.util.PackageUtils;
+import org.apache.cxf.common.util.ReflectionInvokationHandler;
+import org.apache.cxf.common.util.ReflectionInvokationHandler.WrapReturn;
+import org.apache.cxf.common.util.ReflectionUtil;
+import org.apache.cxf.common.util.StringUtils;
+import org.apache.cxf.common.util.SystemPropertyAction;
+import org.apache.cxf.helpers.JavaUtils;
+import org.apache.xbean.asm.ClassWriter;
+import org.apache.xbean.asm.FieldVisitor;
+import org.apache.xbean.asm.Label;
+import org.apache.xbean.asm.MethodVisitor;
+import org.apache.xbean.asm.Opcodes;
+
+
+public final class JAXBUtils {
+
+ public enum IdentifierType {
+ CLASS,
+ INTERFACE,
+ GETTER,
+ SETTER,
+ VARIABLE,
+ CONSTANT
+ };
+
+ public static final String JAXB_URI = "http://java.sun.com/xml/ns/jaxb";
+
+
+ private static final char[] XML_NAME_PUNCTUATION_CHARS = new char[] {
+ /* hyphen */ '\u002D',
+ /* period */ '\u002E',
+ /* colon */'\u003A',
+ /* dot */ '\u00B7',
+ /* greek ano teleia */ '\u0387',
+ /* arabic end of ayah */ '\u06DD',
+ /* arabic start of rub el hizb */'\u06DE',
+ /* underscore */ '\u005F',
+ };
+
+ private static final String XML_NAME_PUNCTUATION_STRING = new String(XML_NAME_PUNCTUATION_CHARS);
+
+ private static final Map<String, String> BUILTIN_DATATYPES_MAP;
+ private static final Map<String, Class<?>> HOLDER_TYPES_MAP;
+ private static final Logger LOG = LogUtils.getL7dLogger(JAXBUtils.class);
+ private static ClassLoader jaxbXjcLoader;
+
+ static {
+ BUILTIN_DATATYPES_MAP = new HashMap<String, String>();
+ BUILTIN_DATATYPES_MAP.put("string", "java.lang.String");
+ BUILTIN_DATATYPES_MAP.put("integer", "java.math.BigInteger");
+ BUILTIN_DATATYPES_MAP.put("int", "int");
+ BUILTIN_DATATYPES_MAP.put("long", "long");
+ BUILTIN_DATATYPES_MAP.put("short", "short");
+ BUILTIN_DATATYPES_MAP.put("decimal", "java.math.BigDecimal");
+ BUILTIN_DATATYPES_MAP.put("float", "float");
+ BUILTIN_DATATYPES_MAP.put("double", "double");
+ BUILTIN_DATATYPES_MAP.put("boolean", "boolean");
+ BUILTIN_DATATYPES_MAP.put("byte", "byte");
+ BUILTIN_DATATYPES_MAP.put("QName", "javax.xml.namespace.QName");
+ BUILTIN_DATATYPES_MAP.put("dateTime", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("base64Binary", "byte[]");
+ BUILTIN_DATATYPES_MAP.put("hexBinary", "byte[]");
+ BUILTIN_DATATYPES_MAP.put("unsignedInt", "long");
+ BUILTIN_DATATYPES_MAP.put("unsignedShort", "short");
+ BUILTIN_DATATYPES_MAP.put("unsignedByte", "byte");
+ BUILTIN_DATATYPES_MAP.put("time", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("date", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gYear", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gYearMonth", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gMonth", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gMonthDay", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("gDay", "javax.xml.datatype.XMLGregorianCalendar");
+ BUILTIN_DATATYPES_MAP.put("duration", "javax.xml.datatype.Duration");
+ BUILTIN_DATATYPES_MAP.put("NOTATION", "javax.xml.namespace.QName");
+ BUILTIN_DATATYPES_MAP.put("string", "java.lang.String");
+
+ HOLDER_TYPES_MAP = new HashMap<String, Class<?>>();
+ HOLDER_TYPES_MAP.put("int", java.lang.Integer.class);
+ HOLDER_TYPES_MAP.put("long", java.lang.Long.class);
+ HOLDER_TYPES_MAP.put("short", java.lang.Short.class);
+ HOLDER_TYPES_MAP.put("float", java.lang.Float.class);
+ HOLDER_TYPES_MAP.put("double", java.lang.Double.class);
+ HOLDER_TYPES_MAP.put("boolean", java.lang.Boolean.class);
+ HOLDER_TYPES_MAP.put("byte", java.lang.Byte.class);
+ }
+
+
+ /**
+ * prevents instantiation
+ *
+ */
+ private JAXBUtils() {
+ }
+
+ public static String builtInTypeToJavaType(String type) {
+ return BUILTIN_DATATYPES_MAP.get(type);
+ }
+
+ public static Class<?> holderClass(String type) {
+ return HOLDER_TYPES_MAP.get(type);
+ }
+
+ /**
+ * Checks if the specified word is a Java keyword (as defined in JavaUtils).
+ *
+ * @param word the word to check.
+ * @return true if the word is a keyword.
+ * @see org.apache.cxf.helpers.JavaUtils
+ */
+ protected static boolean isJavaKeyword(String word) {
+ return JavaUtils.isJavaKeyword(word);
+ }
+
+ /**
+ * Generates a Java package name from a URI according to the
+ * algorithm outlined in JAXB 2.0.
+ *
+ * @param namespaceURI the namespace URI.
+ * @return the package name.
+ */
+ public static String namespaceURIToPackage(String namespaceURI) {
+ try {
+ return nameSpaceURIToPackage(new URI(namespaceURI));
+ } catch (URISyntaxException ex) {
+ return null;
+ }
+ }
+
+ /**
+ * Generates a Java package name from a URI according to the
+ * algorithm outlined in Appendix D of JAXB (2.0+).
+ *
+ * @param namespaceURI the namespace URI.
+ * @return the package name.
+ */
+ public static String nameSpaceURIToPackage(URI uri) {
+
+ StringBuilder packageName = new StringBuilder();
+ String authority = uri.getAuthority();
+ String scheme = uri.getScheme();
+ if (authority == null && "urn".equals(scheme)) {
+ authority = uri.getSchemeSpecificPart();
+ }
+
+ if (null != authority && !"".equals(authority)) {
+ if ("urn".equals(scheme)) {
+ packageName.append(authority);
+ /* JAXB 2.2 D.5.1, Rule #5 */
+ for (int i = 0; i < packageName.length(); i++) {
+ if (packageName.charAt(i) == '-') {
+ packageName.setCharAt(i, '.');
+ }
+ }
+ authority = packageName.toString();
+ packageName.setLength(0);
+
+ StringTokenizer st = new StringTokenizer(authority, ":");
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+ if (packageName.length() > 0) {
+ packageName.insert(0, ".");
+ packageName.insert(0, normalizePackageNamePart(token));
+ } else {
+ packageName.insert(0, token);
+ }
+ }
+ authority = packageName.toString();
+ packageName.setLength(0);
+
+ }
+
+ StringTokenizer st = new StringTokenizer(authority, ".");
+ if (st.hasMoreTokens()) {
+ String token = null;
+ while (st.hasMoreTokens()) {
+ token = st.nextToken();
+ if (packageName.length() == 0) {
+ if ("www".equals(token)) {
+ continue;
+ }
+ } else {
+ packageName.insert(0, ".");
+ }
+ packageName.insert(0, normalizePackageNamePart(token));
+ }
+ }
+
+ if (!("http".equalsIgnoreCase(scheme) || "urn".equalsIgnoreCase(scheme))) {
+ packageName.insert(0, ".");
+ packageName.insert(0, normalizePackageNamePart(scheme));
+ }
+
+ }
+
+ String path = uri.getPath();
+ if (path == null) {
+ path = "";
+ }
+ /* JAXB 2.2 D.5.1 Rule 2 - remove trailing .??, .???, or .html only. */
+ int index = path.lastIndexOf('.');
+ if (index < 0) {
+ index = path.length();
+ } else {
+ String ending = path.substring(index + 1);
+ if (ending.length() < 2 || (ending.length() > 3
+ && !"html".equalsIgnoreCase(ending))) {
+ index = path.length();
+ }
+ }
+ StringTokenizer st = new StringTokenizer(path.substring(0, index), "/");
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken();
+ if (packageName.length() > 0) {
+ packageName.append('.');
+ }
+ packageName.append(normalizePackageNamePart(token));
+ }
+ return packageName.toString();
+ }
+
+ private static String normalizePackageNamePart(String name) {
+ StringBuilder sname = new StringBuilder(name.toLowerCase());
+
+ for (int i = 0; i < sname.length(); i++) {
+ sname.setCharAt(i, Character.toLowerCase(sname.charAt(i)));
+ }
+
+ for (int i = 0; i < sname.length(); i++) {
+ if (!Character.isJavaIdentifierPart(sname.charAt(i))) {
+ sname.setCharAt(i, '_');
+ }
+ }
+
+ if (isJavaKeyword(sname.toString())) {
+ sname.insert(0, '_');
+ }
+
+ if (!Character.isJavaIdentifierStart(sname.charAt(0))) {
+ sname.insert(0, '_');
+ }
+
+ return sname.toString();
+ }
+
+
+ /**
+ * Converts an XML name to a Java identifier according to the mapping
+ * algorithm outlined in the JAXB specification
+ *
+ * @param name the XML name
+ * @return the Java identifier
+ */
+ public static String nameToIdentifier(String name, IdentifierType type) {
+
+ if (null == name || name.length() == 0) {
+ return name;
+ }
+
+ // algorithm will not change an XML name that is already a legal and
+ // conventional (!) Java class, method, or constant identifier
+
+ boolean legalIdentifier = false;
+ StringBuilder buf = new StringBuilder(name);
+ legalIdentifier = Character.isJavaIdentifierStart(buf.charAt(0));
+
+ for (int i = 1; i < name.length() && legalIdentifier; i++) {
+ legalIdentifier = legalIdentifier && Character.isJavaIdentifierPart(buf.charAt(i));
+ }
+
+ boolean conventionalIdentifier = isConventionalIdentifier(buf, type);
+ if (legalIdentifier && conventionalIdentifier) {
+ if (JAXBUtils.isJavaKeyword(name) && type == IdentifierType.VARIABLE) {
+ name = normalizePackageNamePart(name.toString());
+ }
+ return name;
+ }
+
+ // split into words
+
+ List<String> words = new ArrayList<String>();
+
+ StringTokenizer st = new StringTokenizer(name, XML_NAME_PUNCTUATION_STRING);
+ while (st.hasMoreTokens()) {
+ words.add(st.nextToken());
+ }
+
+ for (int i = 0; i < words.size(); i++) {
+ splitWord(words, i);
+ }
+
+ return makeConventionalIdentifier(words, type);
+ }
+
+ private static void splitWord(List<String> words, int listIndex) {
+ String word = words.get(listIndex);
+ if (word.length() <= 1) {
+ return;
+ }
+ int index = listIndex + 1;
+ StringBuilder sword = new StringBuilder(word);
+ int first = 0;
+ char firstChar = sword.charAt(first);
+ if (Character.isLowerCase(firstChar)) {
+ sword.setCharAt(first, Character.toUpperCase(firstChar));
+ }
+ int i = 1;
+
+ while (i < sword.length()) {
+ if (Character.isDigit(firstChar)) {
+ while (i < sword.length() && Character.isDigit(sword.charAt(i))) {
+ i++;
+ }
+ } else if (isCasedLetter(firstChar)) {
+ boolean previousIsLower = Character.isLowerCase(firstChar);
+ while (i < sword.length() && isCasedLetter(sword.charAt(i))) {
+ if (Character.isUpperCase(sword.charAt(i)) && previousIsLower) {
+ break;
+ }
+ previousIsLower = Character.isLowerCase(sword.charAt(i));
+ i++;
+ }
+ } else {
+ // first must be a mark or an uncased letter
+ while (i < sword.length() && (isMark(sword.charAt(i)) || !isCasedLetter(sword.charAt(i)))) {
+ i++;
+ }
+ }
+
+ // characters from first to i are all either
+ // * digits
+ // * upper or lower case letters, with only the first one an upper
+ // * uncased letters or marks
+
+
+ String newWord = sword.substring(first, i);
+ words.add(index, newWord);
+ index++;
+ if (i >= sword.length()) {
+ break;
+ } else {
+ first = i;
+ firstChar = sword.charAt(first);
+ }
+ }
+
+ if (index > (listIndex + 1)) {
+ words.remove(listIndex);
+ }
+ }
+
+ private static boolean isMark(char c) {
+ return Character.isJavaIdentifierPart(c) && !Character.isLetter(c) && !Character.isDigit(c);
+ }
+
+ private static boolean isCasedLetter(char c) {
+ return Character.isUpperCase(c) || Character.isLowerCase(c);
+ }
+
+ private static boolean isConventionalIdentifier(StringBuilder buf, IdentifierType type) {
+ if (null == buf || buf.length() == 0) {
+ return false;
+ }
+ boolean result = false;
+ if (IdentifierType.CONSTANT == type) {
+ for (int i = 0; i < buf.length(); i++) {
+ if (Character.isLowerCase(buf.charAt(i))) {
+ return false;
+ }
+ }
+ result = true;
+ } else if (IdentifierType.VARIABLE == type) {
+ result = Character.isLowerCase(buf.charAt(0));
+ } else {
+ int pos = 3;
+ if (IdentifierType.GETTER == type
+ && !(buf.length() >= pos
+ && "get".equals(buf.subSequence(0, 3)))) {
+ return false;
+ } else if (IdentifierType.SETTER == type
+ && !(buf.length() >= pos && "set".equals(buf.subSequence(0, 3)))) {
+ return false;
+ } else {
+ pos = 0;
+ }
+ result = Character.isUpperCase(buf.charAt(pos));
+ }
+ return result;
+ }
+
+ private static String makeConventionalIdentifier(List<String> words, IdentifierType type) {
+ StringBuilder buf = new StringBuilder();
+ boolean firstWord = true;
+ if (IdentifierType.GETTER == type) {
+ buf.append("get");
+ } else if (IdentifierType.SETTER == type) {
+ buf.append("set");
+ }
+ for (String w : words) {
+ int l = buf.length();
+ if (l > 0 && IdentifierType.CONSTANT == type) {
+ buf.append('_');
+ l++;
+ }
+ buf.append(w);
+ if (IdentifierType.CONSTANT == type) {
+ for (int i = l; i < buf.length(); i++) {
+ if (Character.isLowerCase(buf.charAt(i))) {
+ buf.setCharAt(i, Character.toUpperCase(buf.charAt(i)));
+ }
+ }
+ } else if (IdentifierType.VARIABLE == type) {
+ if (firstWord && Character.isUpperCase(buf.charAt(l))) {
+ buf.setCharAt(l, Character.toLowerCase(buf.charAt(l)));
+ }
+ } else {
+ if (firstWord && Character.isLowerCase(buf.charAt(l))) {
+ buf.setCharAt(l, Character.toUpperCase(buf.charAt(l)));
+ }
+ }
+ firstWord = false;
+ }
+ return buf.toString();
+ }
+
+ public static Class<?> getValidClass(Class<?> cls) {
+ if (cls.isEnum()) {
+ return cls;
+ }
+ if (cls.isArray()) {
+ return cls;
+ }
+
+ if (cls == Object.class || cls == String.class
+ || "javax.xml.ws.Holder".equals(cls.getName())) {
+ cls = null;
+ } else if (cls.isPrimitive() || cls.isAnnotation()) {
+ cls = null;
+ } else if (cls.isInterface()) {
+ return cls;
+ }
+ if (cls != null) {
+ if (cls.getName().equals("javax.xml.ws.wsaddressing.W3CEndpointReference")) {
+ return cls;
+ }
+ Constructor<?> cons = ReflectionUtil.getDeclaredConstructor(cls);
+ if (cons == null) {
+ cons = ReflectionUtil.getConstructor(cls);
+ }
+ if (cons == null) {
+ cls = null;
+ }
+ }
+ return cls;
+ }
+
+ private static synchronized ClassLoader getXJCClassLoader() {
+ if (jaxbXjcLoader == null) {
+ try {
+ Class.forName("com.sun.tools.internal.xjc.api.XJC");
+ jaxbXjcLoader = ClassLoader.getSystemClassLoader();
+ } catch (Exception t2) {
+ //couldn't find either, probably cause tools.jar isn't on
+ //the classpath. Let's see if we can find the tools jar
+ String s = SystemPropertyAction.getProperty("java.home");
+ if (!StringUtils.isEmpty(s)) {
+ File home = new File(s);
+ File jar = new File(home, "lib/tools.jar");
+ if (!jar.exists()) {
+ jar = new File(home, "../lib/tools.jar");
+ }
+ if (jar.exists()) {
+ try {
+ jaxbXjcLoader = new URLClassLoader(new URL[] {jar.toURI().toURL()});
+ Class.forName("com.sun.tools.internal.xjc.api.XJC", false, jaxbXjcLoader);
+ } catch (Exception e) {
+ jaxbXjcLoader = null;
+ }
+ }
+ }
+ }
+ }
+ return jaxbXjcLoader;
+ }
+
+ public static JAXBContext createRIContext(Class<?> clss[], String defaultNS) throws JAXBException {
+ try {
+ Class<?> cls;
+ Map<String, Object> map = new HashMap<String, Object>();
+ try {
+ cls = Class.forName("com.sun.xml.bind.v2.ContextFactory");
+ if (defaultNS != null) {
+ map.put("com.sun.xml.bind.defaultNamespaceRemap", defaultNS);
+ }
+ } catch (ClassNotFoundException e) {
+ // TODO Auto-generated catch block
+ cls = Class.forName("com.sun.xml.internal.bind.v2.ContextFactory", true, getXJCClassLoader());
+ if (defaultNS != null) {
+ map.put("com.sun.xml.internal.bind.defaultNamespaceRemap", defaultNS);
+ }
+ }
+ Method meth = cls.getMethod("createContext", clss.getClass(), Map.class);
+ return (JAXBContext)meth.invoke(null, clss, map);
+ } catch (Exception e) {
+ throw new JAXBException(e);
+ }
+ }
+ public static void setNamespaceWrapper(final Map<String, String> nspref,
+ Marshaller marshaller) throws PropertyException {
+ Object mapper = null;
+ if (marshaller.getClass().getName().contains(".internal.")) {
+ mapper = createNamespaceWrapper(nspref);
+ if (mapper == null) {
+ LOG.log(Level.INFO, "Could not create namespace mapper for JDK internal"
+ + " JAXB implementation.");
+ } else {
+ marshaller.setProperty("com.sun.xml.internal.bind.namespacePrefixMapper",
+ mapper);
+ }
+ } else {
+ try {
+ Class<?> cls = Class.forName("org.apache.cxf.common.jaxb.NamespaceMapper");
+ mapper = cls.getConstructor(Map.class).newInstance(nspref);
+ } catch (Exception ex) {
+ LOG.log(Level.INFO, "Could not create NamespaceMapper", ex);
+ }
+ marshaller.setProperty("com.sun.xml.bind.namespacePrefixMapper",
+ mapper);
+ }
+ }
+ public static BridgeWrapper createBridge(Set<Class<?>> ctxClasses,
+ QName qname,
+ Class<?> refcls,
+ Annotation anns[]) throws JAXBException {
+ try {
+ Class<?> cls;
+ Class<?> refClass;
+ String pkg = "com.sun.xml.bind.";
+ try {
+ cls = Class.forName("com.sun.xml.bind.api.JAXBRIContext");
+ refClass = Class.forName(pkg + "api.TypeReference");
+ } catch (ClassNotFoundException e) {
+ // TODO Auto-generated catch block
+ cls = Class.forName("com.sun.xml.internal.bind.api.JAXBRIContext", true, getXJCClassLoader());
+ pkg = "com.sun.xml.internal.bind.";
+ refClass = Class.forName(pkg + "api.TypeReference", true, getXJCClassLoader());
+ }
+ Object ref = refClass.getConstructor(QName.class,
+ Type.class,
+ anns.getClass()).newInstance(qname, refcls, anns);
+ List<Object> typeRefs = new ArrayList<Object>();
+ typeRefs.add(ref);
+ List<Class<?>> clses = new ArrayList<Class<?>>(ctxClasses);
+ clses.add(refClass.getField("type").get(ref).getClass());
+ if (!refcls.isInterface()) {
+ clses.add(refcls);
+ }
+
+ Object ctx = null;
+ for (Method m : cls.getDeclaredMethods()) {
+ if (m.getName().equals("newInstance")
+ && m.getParameterTypes().length == 6) {
+ ctx = m.invoke(null, clses.toArray(new Class[clses.size()]),
+ typeRefs, null, null, true, null);
+
+ }
+ }
+
+ Object bridge = ctx.getClass().getMethod("createBridge", refClass).invoke(ctx, ref);
+ return ReflectionInvokationHandler.createProxyWrapper(bridge,
+ BridgeWrapper.class);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+ public interface BridgeWrapper {
+
+ Object unmarshal(XMLStreamReader source, AttachmentUnmarshaller am) throws JAXBException;
+
+ Object unmarshal(InputStream source) throws JAXBException;
+
+ Object unmarshal(Node source, AttachmentUnmarshaller am) throws JAXBException;
+
+ void marshal(Object elValue, XMLStreamWriter source, AttachmentMarshaller m) throws JAXBException;
+
+ void marshal(Object elValue, StreamResult s1) throws JAXBException;
+
+ void marshal(Object elValue, Node source, AttachmentMarshaller am) throws JAXBException;
+ }
+
+
+ public static SchemaCompiler createSchemaCompiler() throws JAXBException {
+ try {
+ Class<?> cls;
+ Object sc = null;
+ try {
+ cls = Class.forName("com.sun.tools.xjc.api.XJC");
+ sc = cls.getMethod("createSchemaCompiler").invoke(null);
+ } catch (Throwable e) {
+ cls = Class.forName("com.sun.tools.internal.xjc.api.XJC", true, getXJCClassLoader());
+ sc = cls.getMethod("createSchemaCompiler").invoke(null);
+ }
+
+ return ReflectionInvokationHandler.createProxyWrapper(sc,
+ SchemaCompiler.class);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+
+ public static SchemaCompiler createSchemaCompilerWithDefaultAllocator(Set<String> allocatorSet) {
+
+ try {
+ SchemaCompiler compiler = JAXBUtils.createSchemaCompiler();
+ Object allocator = ReflectionInvokationHandler
+ .createProxyWrapper(new DefaultClassNameAllocator(allocatorSet),
+ JAXBUtils.getParamClass(compiler, "setClassNameAllocator"));
+
+ compiler.setClassNameAllocator(allocator);
+ return compiler;
+ } catch (JAXBException e1) {
+ throw new IllegalStateException("Unable to create schema compiler", e1);
+ }
+
+ }
+
+ public static void logGeneratedClassNames(Logger logger, JCodeModel codeModel) {
+ if (!logger.isLoggable(Level.INFO)) {
+ return;
+ }
+
+ StringBuilder sb = new StringBuilder();
+ boolean first = true;
+ for (Iterator<JPackage> itr = codeModel.packages(); itr.hasNext();) {
+ JPackage package1 = itr.next();
+
+ for (Iterator<JDefinedClass> citr = package1.classes(); citr.hasNext();) {
+ if (!first) {
+ sb.append(", ");
+ } else {
+ first = false;
+ }
+ sb.append(citr.next().fullName());
+ }
+ }
+
+ logger.log(Level.INFO, "Created classes: " + sb.toString());
+ }
+
+ public static List<String> getGeneratedClassNames(JCodeModel codeModel) {
+ List<String> classes = new ArrayList<String>();
+ for (Iterator<JPackage> itr = codeModel.packages(); itr.hasNext();) {
+ JPackage package1 = itr.next();
+
+ for (Iterator<JDefinedClass> citr = package1.classes(); citr.hasNext();) {
+ classes.add(citr.next().fullName());
+ }
+ }
+ return classes;
+ }
+
+ public static Object createFileCodeWriter(File f) throws JAXBException {
+ try {
+ Class<?> cls;
+ try {
+ cls = Class.forName("com.sun.codemodel.writer.FileCodeWriter");
+ } catch (ClassNotFoundException e) {
+ // TODO Auto-generated catch block
+ cls = Class.forName("com.sun.codemodel.internal.writer.FileCodeWriter",
+ true, getXJCClassLoader());
+ }
+ return cls.getConstructor(File.class).newInstance(f);
+ } catch (Exception ex) {
+ throw new JAXBException(ex);
+ }
+ }
+
+ public static Class<?> getParamClass(SchemaCompiler sc, String method) {
+ Object o = ((ReflectionInvokationHandler)Proxy.getInvocationHandler(sc)).getTarget();
+ for (Method m : o.getClass().getMethods()) {
+ if (m.getName().equals(method) && m.getParameterTypes().length == 1) {
+ return m.getParameterTypes()[0];
+ }
+ }
+ return null;
+ }
+
+
+ public static List<DOMResult> generateJaxbSchemas(
+ JAXBContext context, final Map<String, DOMResult> builtIns) throws IOException {
+ final List<DOMResult> results = new ArrayList<DOMResult>();
+
+ context.generateSchema(new SchemaOutputResolver() {
+ @Override
+ public Result createOutput(String ns, String file) throws IOException {
+ DOMResult result = new DOMResult();
+
+ if (builtIns.containsKey(ns)) {
+ DOMResult dr = builtIns.get(ns);
+ result.setSystemId(dr.getSystemId());
+ results.add(dr);
+ return result;
+ }
+ result.setSystemId(file);
+ results.add(result);
+ return result;
+ }
+ });
+
+ return results;
+ }
+
+ public static String getPackageNamespace(Class<?> cls) {
+ Package p = cls.getPackage();
+ if (p != null) {
+ javax.xml.bind.annotation.XmlSchema schemaAnn =
+ p.getAnnotation(javax.xml.bind.annotation.XmlSchema.class);
+ if (schemaAnn != null) {
+ return schemaAnn.namespace();
+ }
+ }
+ return null;
+ }
+
+ public static void scanPackages(Set<Class<?>> classes,
+ Map<Package, CachedClass> objectFactoryCache) {
+ scanPackages(classes, null, objectFactoryCache);
+ }
+ public static void scanPackages(Set<Class<?>> classes,
+ Class<?>[] extraClass,
+ Map<Package, CachedClass> objectFactoryCache) {
+
+ // add user extra class into jaxb context
+ if (extraClass != null && extraClass.length > 0) {
+ for (Class<?> clz : extraClass) {
+ classes.add(clz);
+ }
+ }
+
+ // try and read any jaxb.index files that are with the other classes.
+ // This should
+ // allow loading of extra classes (such as subclasses for inheritance
+ // reasons)
+ // that are in the same package. Also check for ObjectFactory classes
+ Map<String, InputStream> packages = new HashMap<String, InputStream>();
+ Map<String, ClassLoader> packageLoaders = new HashMap<String, ClassLoader>();
+ Set<Class<?>> objectFactories = new HashSet<Class<?>>();
+ for (Class<?> jcls : classes) {
+ String pkgName = PackageUtils.getPackageName(jcls);
+ if (!packages.containsKey(pkgName)) {
+ Package pkg = jcls.getPackage();
+
+ packages.put(pkgName, jcls.getResourceAsStream("jaxb.index"));
+ packageLoaders.put(pkgName, jcls.getClassLoader());
+ String objectFactoryClassName = pkgName + "." + "ObjectFactory";
+ Class<?> ofactory = null;
+ CachedClass cachedFactory = null;
+ if (pkg != null && objectFactoryCache != null) {
+ synchronized (objectFactoryCache) {
+ cachedFactory = objectFactoryCache.get(pkg);
+ }
+ }
+ if (cachedFactory != null) {
+ ofactory = cachedFactory.getCachedClass();
+ }
+ if (ofactory == null) {
+ try {
+ ofactory = Class.forName(objectFactoryClassName, false, jcls
+ .getClassLoader());
+ objectFactories.add(ofactory);
+ addToObjectFactoryCache(pkg, ofactory, objectFactoryCache);
+ } catch (ClassNotFoundException e) {
+ addToObjectFactoryCache(pkg, null, objectFactoryCache);
+ }
+ } else {
+ objectFactories.add(ofactory);
+ }
+ }
+ }
+ for (Map.Entry<String, InputStream> entry : packages.entrySet()) {
+ if (entry.getValue() != null) {
+ BufferedReader reader = null;
+ try {
+ reader = new BufferedReader(new InputStreamReader(entry.getValue(), "UTF-8"));
+ String pkg = entry.getKey();
+ ClassLoader loader = packageLoaders.get(pkg);
+ if (!StringUtils.isEmpty(pkg)) {
+ pkg += ".";
+ }
+
+ String line = reader.readLine();
+ while (line != null) {
+ line = line.trim();
+ if (line.indexOf("#") != -1) {
+ line = line.substring(0, line.indexOf("#"));
+ }
+ if (!StringUtils.isEmpty(line)) {
+ try {
+ Class<?> ncls = Class.forName(pkg + line, false, loader);
+ classes.add(ncls);
+ } catch (Exception e) {
+ // ignore
+ }
+ }
+ line = reader.readLine();
+ }
+ } catch (Exception e) {
+ // ignore
+ } finally {
+ try {
+ if (reader != null) {
+ reader.close();
+ entry.getValue().close();
+ }
+ } catch (Exception e) {
+ // ignore
+ }
+ }
+ }
+ }
+ classes.addAll(objectFactories);
+ }
+
+
+ private static void addToObjectFactoryCache(Package objectFactoryPkg,
+ Class<?> ofactory,
+ Map<Package, CachedClass> objectFactoryCache) {
+ if (objectFactoryPkg == null || objectFactoryCache == null) {
+ return;
+ }
+ synchronized (objectFactoryCache) {
+ objectFactoryCache.put(objectFactoryPkg,
+ new CachedClass(ofactory));
+ }
+ }
+
+ public static class DefaultClassNameAllocator {
+ private final Set<String> typesClassNames;
+
+ public DefaultClassNameAllocator() {
+ this(new HashSet<String>());
+ }
+
+ public DefaultClassNameAllocator(Set<String> set) {
+ typesClassNames = set;
+ }
+
+ public String assignClassName(String packageName, String className) {
+ String fullClassName = className;
+ String fullPckClass = packageName + "." + fullClassName;
+ int cnt = 0;
+ while (typesClassNames.contains(fullPckClass)) {
+ cnt++;
+ fullClassName = className + cnt;
+ fullPckClass = packageName + "." + fullClassName;
+ }
+ typesClassNames.add(fullPckClass);
+ return fullClassName;
+ }
+
+ }
+
+ public interface SchemaCompiler {
+
+ void setErrorListener(Object elForRun);
+
+ void setClassNameAllocator(Object allocator);
+
+ @WrapReturn(S2JJAXBModel.class)
+ S2JJAXBModel bind();
+
+ void parseSchema(InputSource source);
+
+ void parseSchema(String key, Element el);
+ void parseSchema(String key, XMLStreamReader el);
+
+ @WrapReturn(Options.class)
+ Options getOptions();
+ }
+ public interface S2JJAXBModel {
+
+ @WrapReturn(JCodeModel.class)
+ JCodeModel generateCode(Object object, Object elForRun);
+
+ @WrapReturn(Mapping.class)
+ Mapping get(QName qn);
+
+ @WrapReturn(TypeAndAnnotation.class)
+ TypeAndAnnotation getJavaType(QName typeQName);
+ }
+ public interface Mapping {
+ @WrapReturn(TypeAndAnnotation.class)
+ TypeAndAnnotation getType();
+ }
+ public interface TypeAndAnnotation {
+ @WrapReturn(JType.class)
+ JType getTypeClass();
+ }
+ public interface JType {
+ boolean isArray();
+
+ @WrapReturn(JType.class)
+ JType elementType();
+
+ boolean isPrimitive();
+
+ String binaryName();
+
+ String fullName();
+
+ String name();
+
+ @WrapReturn(value = JType.class, iterator = true)
+ Iterator<JType> classes();
+ }
+ public interface Options {
+
+ void addGrammar(InputSource is);
+
+ void addBindFile(InputSource is);
+
+ void parseArguments(String[] args);
+
+ String getBuildID();
+ }
+ public interface JCodeModel {
+
+ void build(Object writer) throws IOException;
+
+ @WrapReturn(value = JPackage.class, iterator = true)
+ Iterator<JPackage> packages();
+ }
+ public interface JPackage {
+
+ String name();
+
+ @WrapReturn(value = JDefinedClass.class, iterator = true)
+ Iterator<JDefinedClass> classes();
+ }
+ public interface JDefinedClass {
+ String name();
+
+ String fullName();
+ }
+
+ public static boolean isJAXB22() {
+ Target t = XmlElement.class.getAnnotation(Target.class);
+ //JAXB 2.2 allows XmlElement on params.
+ for (ElementType et : t.value()) {
+ if (et == ElementType.PARAMETER) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static synchronized Object createNamespaceWrapper(Map<String, String> map) {
+ ASMHelper helper = new ASMHelper();
+ String className = "org.apache.cxf.jaxb.NamespaceMapperInternal";
+ Class<?> cls = helper.findClass(className, JAXBUtils.class);
+ if (cls == null) {
+ ClassWriter cw = helper.createClassWriter();
+ if (cw == null) {
+ return null;
+ }
+ cls = createNamespaceWrapperInternal(helper, cw);
+ }
+ try {
+ return cls.getConstructor(Map.class).newInstance(map);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+ private static Class<?> createNamespaceWrapperInternal(ASMHelper helper, ClassWriter cw) {
+ String className = "org.apache.cxf.jaxb.NamespaceMapperInternal";
+ FieldVisitor fv;
+ MethodVisitor mv;
+ cw.visit(Opcodes.V1_5,
+ Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER,
+ "org/apache/cxf/jaxb/NamespaceMapperInternal", null,
+ "com/sun/xml/internal/bind/marshaller/NamespacePrefixMapper", null);
+
+ cw.visitSource("NamespaceMapper.java", null);
+
+ fv = cw.visitField(Opcodes.ACC_PRIVATE + Opcodes.ACC_FINAL,
+ "nspref", "Ljava/util/Map;",
+ "Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;", null);
+ fv.visitEnd();
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>",
+ "(Ljava/util/Map;)V",
+ "(Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;)V", null);
+ mv.visitCode();
+ Label l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(30, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitMethodInsn(Opcodes.INVOKESPECIAL,
+ "com/sun/xml/internal/bind/marshaller/NamespacePrefixMapper", "<init>", "()V");
+ Label l1 = new Label();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(31, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitFieldInsn(Opcodes.PUTFIELD, "org/apache/cxf/jaxb/NamespaceMapperInternal",
+ "nspref", "Ljava/util/Map;");
+ Label l2 = new Label();
+ mv.visitLabel(l2);
+ mv.visitLineNumber(32, l2);
+ mv.visitInsn(Opcodes.RETURN);
+ Label l3 = new Label();
+ mv.visitLabel(l3);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/jaxb/NamespaceMapperInternal;", null, l0, l3, 0);
+ mv.visitLocalVariable("nspref", "Ljava/util/Map;",
+ "Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;",
+ l0, l3, 1);
+ mv.visitMaxs(2, 2);
+ mv.visitEnd();
+
+ mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "getPreferredPrefix",
+ "(Ljava/lang/String;Ljava/lang/String;Z)Ljava/lang/String;",
+ null, null);
+ mv.visitCode();
+ l0 = new Label();
+ mv.visitLabel(l0);
+ mv.visitLineNumber(38, l0);
+ mv.visitVarInsn(Opcodes.ALOAD, 0);
+ mv.visitFieldInsn(Opcodes.GETFIELD,
+ "org/apache/cxf/jaxb/NamespaceMapperInternal",
+ "nspref", "Ljava/util/Map;");
+ mv.visitVarInsn(Opcodes.ALOAD, 1);
+ mv.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/Map",
+ "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
+ mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/String");
+ mv.visitVarInsn(Opcodes.ASTORE, 4);
+ l1 = new Label();
+ mv.visitLabel(l1);
+ mv.visitLineNumber(39, l1);
+ mv.visitVarInsn(Opcodes.ALOAD, 4);
+ l2 = new Label();
+ mv.visitJumpInsn(Opcodes.IFNULL, l2);
+ l3 = new Label();
+ mv.visitLabel(l3);
+ mv.visitLineNumber(40, l3);
+ mv.visitVarInsn(Opcodes.ALOAD, 4);
+ mv.visitInsn(Opcodes.ARETURN);
+ mv.visitLabel(l2);
+ mv.visitLineNumber(42, l2);
+ mv.visitVarInsn(Opcodes.ALOAD, 2);
+ mv.visitInsn(Opcodes.ARETURN);
+ Label l4 = new Label();
+ mv.visitLabel(l4);
+ mv.visitLocalVariable("this", "Lorg/apache/cxf/jaxb/NamespaceMapperInternal;", null, l0, l4, 0);
+ mv.visitLocalVariable("namespaceUri", "Ljava/lang/String;", null, l0, l4, 1);
+ mv.visitLocalVariable("suggestion", "Ljava/lang/String;", null, l0, l4, 2);
+ mv.visitLocalVariable("requirePrefix", "Z", null, l0, l4, 3);
+ mv.visitLocalVariable("prefix", "Ljava/lang/String;", null, l1, l4, 4);
+ mv.visitMaxs(2, 5);
+ mv.visitEnd();
+ cw.visitEnd();
+
+ byte bts[] = cw.toByteArray();
+
+
+ Class<?> cls;
+ try {
+ cls = Class.forName("com.sun.xml.bind.api.JAXBRIContext");
+ } catch (ClassNotFoundException e) {
+ // TODO Auto-generated catch block
+ try {
+ cls = Class.forName("com.sun.xml.internal.bind.api.JAXBRIContext", true, getXJCClassLoader());
+ } catch (ClassNotFoundException e1) {
+ cls = JAXBUtils.class;
+ }
+ }
+
+ return helper.loadClass(className,
+ cls, bts);
+ }
+
+ public static JAXBBeanInfo getBeanInfo(JAXBContextProxy context, Class<?> cls) {
+ Object o = context.getBeanInfo(cls);
+ if (o == null) {
+ return null;
+ }
+ return ReflectionInvokationHandler.createProxyWrapper(o, JAXBBeanInfo.class);
+ }
+
+}
Added: openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/ASMHelper.java
URL: http://svn.apache.org/viewvc/openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/ASMHelper.java?rev=1327413&view=auto
==============================================================================
--- openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/ASMHelper.java (added)
+++ openejb/trunk/patched-libraries/cxf-bundle-patched/src/main/java/org/apache/cxf/common/util/ASMHelper.java Wed Apr 18 08:00:51 2012
@@ -0,0 +1,246 @@
+/**
+ * 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.cxf.common.util;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.GenericArrayType;
+import java.lang.reflect.Method;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.apache.xbean.asm.ClassWriter;
+
+public class ASMHelper {
+ protected static final Map<Class<?>, String> PRIMITIVE_MAP = new HashMap<Class<?>, String>();
+ protected static final Map<Class<?>, String> NONPRIMITIVE_MAP = new HashMap<Class<?>, String>();
+
+ protected static final Map<Class<?>, WeakReference<TypeHelperClassLoader>> LOADER_MAP
+ = new WeakIdentityHashMap<Class<?>, WeakReference<TypeHelperClassLoader>>();
+
+ protected static boolean oldASM;
+
+ static {
+ PRIMITIVE_MAP.put(Byte.TYPE, "B");
+ PRIMITIVE_MAP.put(Boolean.TYPE, "Z");
+ PRIMITIVE_MAP.put(Long.TYPE, "J");
+ PRIMITIVE_MAP.put(Integer.TYPE, "I");
+ PRIMITIVE_MAP.put(Short.TYPE, "S");
+ PRIMITIVE_MAP.put(Character.TYPE, "C");
+ PRIMITIVE_MAP.put(Float.TYPE, "F");
+ PRIMITIVE_MAP.put(Double.TYPE, "D");
+
+ NONPRIMITIVE_MAP.put(Byte.TYPE, Byte.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Boolean.TYPE, Boolean.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Long.TYPE, Long.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Integer.TYPE, Integer.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Short.TYPE, Short.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Character.TYPE, Character.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Float.TYPE, Float.class.getName().replaceAll("\\.", "/"));
+ NONPRIMITIVE_MAP.put(Double.TYPE, Double.class.getName().replaceAll("\\.", "/"));
+ }
+
+ protected static String getMethodSignature(Method m) {
+ StringBuilder buf = new StringBuilder("(");
+ for (Class<?> cl : m.getParameterTypes()) {
+ buf.append(getClassCode(cl));
+ }
+ buf.append(")");
+ buf.append(getClassCode(m.getReturnType()));
+
+ return buf.toString();
+ }
+
+ protected static String periodToSlashes(String s) {
+ char ch[] = s.toCharArray();
+ for (int x = 0; x < ch.length; x++) {
+ if (ch[x] == '.') {
+ ch[x] = '/';
+ }
+ }
+ return new String(ch);
+ }
+
+
+ public static String getClassCode(Class<?> cl) {
+ if (cl == Void.TYPE) {
+ return "V";
+ }
+ if (cl.isPrimitive()) {
+ return PRIMITIVE_MAP.get(cl);
+ }
+ if (cl.isArray()) {
+ return "[" + getClassCode(cl.getComponentType());
+ }
+ return "L" + periodToSlashes(cl.getName()) + ";";
+ }
+ public static String getClassCode(Type type) {
+ if (type instanceof Class) {
+ return getClassCode((Class<?>)type);
+ } else if (type instanceof GenericArrayType) {
+ GenericArrayType at = (GenericArrayType)type;
+ return "[" + getClassCode(at.getGenericComponentType());
+ } else if (type instanceof TypeVariable) {
+ TypeVariable<?> tv = (TypeVariable<?>)type;
+ Type[] bounds = tv.getBounds();
+ if (bounds != null && bounds.length == 1) {
+ return getClassCode(bounds[0]);
+ } else {
+ throw new IllegalArgumentException("Unable to determine type for: " + tv);
+ }
+ } else if (type instanceof ParameterizedType) {
+ ParameterizedType pt = (ParameterizedType)type;
+ StringBuilder a = new StringBuilder(getClassCode(pt.getRawType()));
+ a.setLength(a.length() - 1);
+ a.append('<');
+ for (Type t : pt.getActualTypeArguments()) {
+ a.append(getClassCode(t));
+ }
+ a.append(">;");
+ return a.toString();
+ } else if (type instanceof WildcardType) {
+ WildcardType wt = (WildcardType)type;
+ StringBuilder a = new StringBuilder();
+ Type[] lowBounds = wt.getLowerBounds();
+ Type[] upBounds = wt.getUpperBounds();
+ for (Type t : upBounds) {
+ a.append("+");
+ a.append(getClassCode(t));
+ }
+ for (Type t : lowBounds) {
+ a.append("-");
+ a.append(getClassCode(t));
+ }
+ return a.toString();
+ }
+ return null;
+ }
+
+
+ public ClassWriter createClassWriter() {
+ ClassWriter newCw = null;
+ if (!oldASM) {
+ Class<ClassWriter> cls;
+ try {
+ cls = ClassWriter.class;
+ } catch (NoClassDefFoundError error) {
+ throw new RuntimeException("No ASM ClassWriterFound", error);
+ }
+ try {
+ // ASM 1.5.x/2.x
+ Constructor<ClassWriter> cons = cls.getConstructor(new Class<?>[] {Boolean.TYPE});
+
+ try {
+ // got constructor, now check if it's 1.x which is very
+ // different from 2.x and 3.x
+ cls.getMethod("newConstInt", new Class<?>[] {Integer.TYPE});
+ // newConstInt was removed in 2.x, if we get this far, we're
+ // using 1.5.x,
+ // set to null so we don't attempt to use it.
+ oldASM = true;
+ } catch (Throwable t) {
+ newCw = cons.newInstance(new Object[] {Boolean.TRUE});
+ }
+
+ } catch (Throwable e) {
+ // ASM 3.x
+ try {
+ Constructor<ClassWriter> cons = cls.getConstructor(new Class<?>[] {Integer.TYPE});
+ int i = cls.getField("COMPUTE_MAXS").getInt(null);
+ i |= cls.getField("COMPUTE_FRAMES").getInt(null);
+ newCw = cons.newInstance(new Object[] {Integer.valueOf(i)});
+ } catch (Throwable e1) {
+ // ignore
+ }
+
+ }
+ }
+ return newCw;
+ }
+
+
+ public Class<?> loadClass(String className, Class<?> clz , byte[] bytes) {
+ TypeHelperClassLoader loader = getTypeHelperClassLoader(clz);
+ synchronized (loader) {
+ Class<?> cls = loader.lookupDefinedClass(className);
+ if (cls == null) {
+ return loader.defineClass(className, bytes);
+ }
+ return cls;
+ }
+ }
+ public Class<?> findClass(String className, Class<?> clz) {
+ TypeHelperClassLoader loader = getTypeHelperClassLoader(clz);
+ return loader.lookupDefinedClass(className);
+ }
+
+ private static synchronized TypeHelperClassLoader getTypeHelperClassLoader(Class<?> l) {
+ WeakReference<TypeHelperClassLoader> ref = LOADER_MAP.get(l);
+ TypeHelperClassLoader ret;
+ if (ref == null || ref.get() == null) {
+ ret = new TypeHelperClassLoader(l.getClassLoader());
+ LOADER_MAP.put(l, new WeakReference<TypeHelperClassLoader>(ret));
+ } else {
+ ret = ref.get();
+ }
+ return ret;
+ }
+
+ public static class TypeHelperClassLoader extends ClassLoader {
+ Map<String, Class<?>> defined = new ConcurrentHashMap<String, Class<?>>();
+
+ TypeHelperClassLoader(ClassLoader parent) {
+ super(parent);
+ }
+ public Class<?> lookupDefinedClass(String name) {
+ return defined.get(name.replace('/', '.'));
+ }
+
+ public synchronized Class<?> defineClass(String name, byte bytes[]) {
+ Class<?> ret = defined.get(name.replace('/', '.'));
+ if (ret != null) {
+ return ret;
+ }
+ if (name.endsWith("package-info")) {
+ Package p = super.getPackage(name.substring(0, name.length() - 13));
+ if (p == null) {
+ definePackage(name.substring(0, name.length() - 13).replace('/', '.'),
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null);
+ }
+ }
+
+ ret = super.defineClass(name.replace('/', '.'), bytes, 0, bytes.length);
+ defined.put(name.replace('/', '.'), ret);
+ return ret;
+ }
+ }
+
+}