index int64 0 0 | repo_id stringlengths 9 205 | file_path stringlengths 31 246 | content stringlengths 1 12.2M | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/PortableRemoteObjectExtImpl.java | /**
*
* 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.yoko.rmi.impl;
import java.util.Properties;
import org.apache.yoko.rmi.api.PortableRemoteObjectExtDelegate;
import org.apache.yoko.rmi.api.PortableRemoteObjectState;
import org.apache.yoko.rmi.util.ClassLoaderLocal;
public final class PortableRemoteObjectExtImpl implements
PortableRemoteObjectExtDelegate {
private static ClassLoaderLocal rmiState = new ClassLoaderLocal(RMIState.class.getName());
private static org.omg.CORBA.ORB defaultOrb;
private static org.omg.CORBA.ORB getDefaultOrb() {
if(defaultOrb == null) {
java.util.Properties props = new Properties();
props.putAll(System.getProperties());
defaultOrb = org.omg.CORBA.ORB.init(new String[0], props);
}
return defaultOrb;
}
private static int nextRMIStateId = 0;
public PortableRemoteObjectState getCurrentState() {
RMIState state = (RMIState) rmiState.get();
if(state == null) {
org.omg.CORBA.ORB orb = getDefaultOrb();
state = new RMIState(orb,"rmi"+ nextRMIStateId++);
rmiState.set(state);
}
return state;
}
}
| 3,300 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/RemoteInterfaceDescriptor.java | /**
*
* 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.yoko.rmi.impl;
final class RemoteInterfaceDescriptor extends RemoteDescriptor {
RemoteInterfaceDescriptor(Class type, TypeRepository repository) {
super(type, repository);
}
@Override
protected RemoteInterfaceDescriptor genRemoteInterface() {
return this;
}
}
| 3,301 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/TypeDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
import java.io.PrintWriter;
import java.rmi.Remote;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.logging.Logger;
abstract class TypeDescriptor extends ModelElement {
static Logger logger = Logger.getLogger(TypeDescriptor.class.getName());
final Class type;
private volatile String _repid = null;
private volatile String packageName = null; // the package name qualifier (if any)
protected String genPackageName() {
int idx = java_name.lastIndexOf('.');
return ((idx < 0) ? "" : java_name.substring(0, idx));
}
public final String getPackageName() {
if (null == packageName) packageName = genPackageName();
return packageName;
}
private volatile String typeName = null; // the simple type name (minus package, if any)
protected String genTypeName() {
int idx = java_name.lastIndexOf('.');
return ((idx < 0) ? java_name : java_name.substring(idx + 1));
}
public final String getTypeName() {
if (null == typeName) typeName = genTypeName();
return typeName;
}
private volatile FullKey key = null;
private FullKey genKey() {
return new FullKey(getRepositoryID(), type);
}
public final FullKey getKey() {
if (null == key) key = genKey();
return key;
}
public static class SimpleKey {
private final String repid;
public SimpleKey(String repid) {
this.repid = repid;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((repid == null) ? 0 : repid.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (!(obj instanceof SimpleKey)) return false;
return Objects.equals(repid, ((SimpleKey)obj).repid);
}
}
public static final class FullKey extends SimpleKey {
private final Class<?> localType;
public FullKey(String repid, Class<?> localType) {
super(repid);
this.localType = localType;
}
@Override
public int hashCode() {
// must just be the same as SimpleKey's hashCode
return super.hashCode();
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (!(obj instanceof SimpleKey)) return false;
if (obj instanceof FullKey &&
!!!Objects.equals(localType, ((FullKey)obj).localType)) return false;
return super.equals(obj);
}
}
@Override
public String toString() {
return String.format("%s{class=\"%s\",repId=\"%s\"}",
this.getClass().getName(), type,
getRepositoryID());
}
protected TypeDescriptor(Class type, TypeRepository repository) {
super(repository, type.getName());
this.type = type;
}
@Override
protected String genIDLName() {
return java_name.replace('.', '_');
}
protected String genRepId() {
return String.format("RMI:%s:%016X", type.getName(), 0);
}
public final String getRepositoryID() {
if (_repid == null) _repid = genRepId();
return _repid;
}
private volatile RemoteInterfaceDescriptor remoteInterface = null;
protected RemoteInterfaceDescriptor genRemoteInterface() {
throw new UnsupportedOperationException("class " + type + " does not implement " + Remote.class.getName());
}
final RemoteInterfaceDescriptor getRemoteInterface() {
if (null == remoteInterface) remoteInterface = genRemoteInterface();
return remoteInterface;
}
/** Read an instance of this value from a CDR stream */
public abstract Object read(InputStream in);
/** Write an instance of this value to a CDR stream */
public abstract void write(OutputStream out, Object val);
public boolean isCustomMarshalled() {
return false;
}
String makeSignature(Class type) {
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
return "Z";
} else if (type == Byte.TYPE) {
return "B";
} else if (type == Short.TYPE) {
return "S";
} else if (type == Character.TYPE) {
return "C";
} else if (type == Integer.TYPE) {
return "I";
} else if (type == Long.TYPE) {
return "J";
} else if (type == Float.TYPE) {
return "F";
} else if (type == Double.TYPE) {
return "D";
} else if (type == Void.TYPE) {
return "V";
} else
throw new RuntimeException("unknown primitive class" + type);
} else if (type.isArray()) {
int i = 0;
Class elem = type;
for (; elem.isArray(); elem = elem.getComponentType())
i += 1;
StringBuffer sb = new StringBuffer();
for (int j = 0; j < i; j++)
sb.append('[');
sb.append(makeSignature(elem));
return sb.toString();
} else {
return "L" + (type.getName()).replace('.', '/') + ";";
}
}
long getHashCode() {
return 0L;
}
@Override
protected void init() {
getTypeCode();
}
private volatile TypeCode typeCode = null;
protected abstract TypeCode genTypeCode();
final TypeCode getTypeCode() {
if (null == typeCode) {
synchronized (repo) {
if (null == typeCode) typeCode = genTypeCode();
}
}
return typeCode;
}
protected final void setTypeCode(TypeCode tc) {
typeCode = tc;
}
Object copyObject(Object value, CopyState state) {
throw new InternalError("cannot copy " + value.getClass().getName());
}
void writeMarshalValue(PrintWriter pw, String outName,
String paramName) {
pw.print(outName);
pw.print('.');
pw.print("write_");
pw.print(getIDLName());
pw.print('(');
pw.print(paramName);
pw.print(')');
}
void writeUnmarshalValue(PrintWriter pw, String inName) {
pw.print(inName);
pw.print('.');
pw.print("read_");
pw.print(getIDLName());
pw.print('(');
pw.print(')');
}
void addDependencies(Set<Class<?>> classes) {
return;
}
boolean copyInStub() {
return true;
}
void print(PrintWriter pw, Map<Object,Integer> recurse, Object val) {
if (val == null) {
pw.print("null");
}
Integer old = (Integer) recurse.get(val);
if (old != null) {
pw.print("^" + old);
} else {
Integer key = new Integer(System.identityHashCode(val));
pw.println(type.getName() + "@"
+ Integer.toHexString(key.intValue()));
}
}
/**
* Method copyBetweenStates.
*
* @return boolean
*/
public boolean copyBetweenStates() {
return true;
}
/**
* Method copyWithinState.
*
* @return boolean
*/
public boolean copyWithinState() {
return true;
}
}
| 3,302 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/PortableRemoteObjectImpl.java | /**
*
* 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.yoko.rmi.impl;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.rmi.CORBA.PortableRemoteObjectDelegate;
import javax.rmi.CORBA.Stub;
import javax.rmi.CORBA.Tie;
import javax.rmi.CORBA.Util;
import org.apache.yoko.rmi.util.ClientUtil;
import org.apache.yoko.rmi.util.GetSystemPropertyAction;
import org.apache.yoko.rmi.util.stub.MethodRef;
import org.apache.yoko.rmi.util.stub.StubClass;
import org.apache.yoko.rmi.util.stub.StubInitializer;
import org.apache.yoko.rmispec.util.UtilLoader;
import org.omg.CORBA.BAD_INV_ORDER;
import org.omg.CORBA.portable.IDLEntity;
import org.omg.CORBA.portable.ObjectImpl;
public class PortableRemoteObjectImpl implements PortableRemoteObjectDelegate {
static final Logger LOGGER = Logger
.getLogger(PortableRemoteObjectImpl.class.getName());
static {
// Initialize the stub handler factory when first loaded to ensure we have
// class loading visibility to the factory.
getRMIStubInitializer();
}
static org.omg.CORBA.ORB getORB() {
return RMIState.current().getORB();
}
static org.omg.PortableServer.POA getPOA() {
return RMIState.current().getPOA();
}
static ClassLoader getClassLoader() {
return RMIState.current().getClassLoader();
}
public void connect(Remote target, Remote source)
throws java.rmi.RemoteException {
if (!(source instanceof javax.rmi.CORBA.Stub))
source = toStub(source);
ObjectImpl obj;
if (target instanceof ObjectImpl) {
obj = (ObjectImpl) target;
} else {
try {
exportObject(target);
} catch (RemoteException ex) {
// ignore "already exported test" //
}
try {
obj = (ObjectImpl) toStub(target);
} catch (java.rmi.NoSuchObjectException ex) {
throw (RemoteException)new RemoteException("cannot convert to stub!").initCause(ex);
}
}
try {
((javax.rmi.CORBA.Stub) source).connect(((ObjectImpl) obj)._orb());
} catch (org.omg.CORBA.BAD_OPERATION bad_operation) {
throw (RemoteException)new RemoteException(bad_operation.getMessage())
.initCause(bad_operation);
}
}
private Object narrowRMI(ObjectImpl narrowFrom, Class<?> narrowTo) {
if (LOGGER.isLoggable(Level.FINE))
LOGGER.fine(String.format("RMI narrowing %s => %s", narrowFrom.getClass().getName(), narrowTo.getName()));
ObjectImpl object = narrowFrom;
final String codebase = getCodebase(narrowFrom);
RMIState state = RMIState.current();
javax.rmi.CORBA.Stub stub;
try {
stub = createStub(state, codebase, narrowTo);
} catch (ClassNotFoundException ex) {
throw (ClassCastException)new ClassCastException(narrowTo.getName()).initCause(ex);
}
org.omg.CORBA.portable.Delegate delegate;
try {
// let the stub adopt narrowFrom's identity
delegate = object._get_delegate();
} catch (org.omg.CORBA.BAD_OPERATION ex) {
// ignore
delegate = null;
}
stub._set_delegate(delegate);
return stub;
}
private String getCodebase(ObjectImpl narrowFrom) {
String codebase;
if (narrowFrom instanceof org.omg.CORBA_2_3.portable.ObjectImpl) {
org.omg.CORBA_2_3.portable.ObjectImpl object_2_3 = (org.omg.CORBA_2_3.portable.ObjectImpl) narrowFrom;
try {
codebase = object_2_3._get_codebase();
} catch (org.omg.CORBA.BAD_OPERATION ex) {
codebase = null;
}
} else {
codebase = null;
}
return codebase;
}
private Object narrowIDL(ObjectImpl narrowFrom, Class<?> narrowTo) {
if (LOGGER.isLoggable(Level.FINE))
LOGGER.fine(String.format("IDL narrowing %s => %s", narrowFrom.getClass().getName(), narrowTo.getName()));
final ClassLoader idlClassLoader = UtilImpl.getClassLoader(narrowTo);
final String codebase = getCodebase(narrowFrom);
final String helperClassName = narrowTo.getName() + "Helper";
try {
final Class<?> helperClass = Util.loadClass(helperClassName, codebase, idlClassLoader);
final Method helperNarrow = AccessController.doPrivileged(new PrivilegedExceptionAction<Method>() {
@Override
public Method run() throws Exception {
return helperClass.getMethod("narrow", org.omg.CORBA.Object.class);
}
});
return helperNarrow.invoke(null, narrowFrom);
} catch (PrivilegedActionException e) {
throw (ClassCastException)new ClassCastException(narrowTo.getName()).initCause(e.getCause());
} catch (Exception e) {
throw (ClassCastException)new ClassCastException(narrowTo.getName()).initCause(e);
}
}
public Object narrow(Object narrowFrom, @SuppressWarnings("rawtypes") Class narrowTo)
throws ClassCastException {
if (narrowFrom == null)
return null;
if (narrowTo.isInstance(narrowFrom))
return narrowFrom;
final String fromClassName = narrowFrom.getClass().getName();
final String toClassName = narrowTo.getName();
if (LOGGER.isLoggable(Level.FINE))
LOGGER.finer(String.format("narrow %s => %s", fromClassName, toClassName));
if (!(narrowFrom instanceof org.omg.CORBA.portable.ObjectImpl))
throw new ClassCastException(String.format(
"object to narrow (runtime type %s) is not an instance of %s",
fromClassName, ObjectImpl.class.getName()));
if (!narrowTo.isInterface())
throw new ClassCastException(String.format("%s is not an interface", toClassName));
final boolean isRemote = Remote.class.isAssignableFrom(narrowTo);
final boolean isIDLEntity = IDLEntity.class.isAssignableFrom(narrowTo);
if (isRemote && isIDLEntity)
throw new ClassCastException(String.format(
"%s invalidly extends both %s and %s",
toClassName, Remote.class.getName(), IDLEntity.class.getName()));
if (isRemote)
return narrowRMI((ObjectImpl) narrowFrom, narrowTo);
if (isIDLEntity)
return narrowIDL((ObjectImpl) narrowFrom, narrowTo);
throw new ClassCastException(String.format(
"%s extends neither %s nor %s",
toClassName, Remote.class.getName(), IDLEntity.class.getName()));
}
static java.rmi.Remote narrow1(RMIState state, ObjectImpl object, Class<?> narrowTo) throws ClassCastException {
Stub stub;
try {
stub = createStub(state, null, narrowTo);
} catch (ClassNotFoundException ex) {
throw (ClassCastException)new ClassCastException(narrowTo.getName()).initCause(ex);
}
org.omg.CORBA.portable.Delegate delegate;
try {
// let the stub adopt narrowFrom's identity
delegate = object._get_delegate();
} catch (org.omg.CORBA.BAD_OPERATION ex) {
// ignore
delegate = null;
}
stub._set_delegate(delegate);
return (java.rmi.Remote) stub;
}
static private Stub createStub(RMIState state, String codebase, Class<?> type) throws ClassNotFoundException {
if (Remote.class == type) {
return new RMIRemoteStub();
}
if (ClientUtil.isRunningAsClientContainer()) {
Stub stub = state.getStaticStub(codebase, type);
if (stub != null) {
return stub;
}
}
return createRMIStub(state, type);
}
static Object[] NO_ARG = new Object[0];
static Stub createRMIStub(RMIState state, Class<?> type) throws ClassNotFoundException {
if (!type.isInterface()) {
throw new RuntimeException("non-interfaces not supported");
}
LOGGER.fine("Creating RMI stub for class " + type.getName());
Constructor<? extends Stub> cons = getRMIStubClassConstructor(state, type);
try {
Stub result = cons.newInstance(NO_ARG);
return result;
} catch (InstantiationException ex) {
throw new RuntimeException(
"internal problem: cannot instantiate stub", ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException(
"internal problem: cannot instantiate stub", ex.getCause());
} catch (IllegalAccessException ex) {
throw new RuntimeException(
"internal problem: cannot instantiate stub", ex);
}
}
private static java.lang.reflect.Method stub_write_replace;
static {
try {
stub_write_replace = RMIStub.class.getDeclaredMethod(
"writeReplace", new Class[0]);
} catch (Throwable ex) {
LOGGER.log(Level.WARNING, "cannot initialize: \n" + ex.getMessage(), ex);
throw new Error("cannot initialize", ex);
}
}
static synchronized Class<?> getRMIStubClass(RMIState state, Class<?> type) throws ClassNotFoundException {
return getRMIStubClassConstructor(state, type).getDeclaringClass();
}
static Constructor<? extends Stub> getRMIStubClassConstructor(RMIState state, Class<?> type) throws ClassNotFoundException {
LOGGER.fine("Requesting stub constructor of class " + type.getName());
@SuppressWarnings("unchecked")
Constructor<? extends Stub> cons = (Constructor<? extends Stub>) state.stub_map.get(type);
if (cons != null) {
LOGGER.fine("Returning cached constructor of class " + cons.getDeclaringClass().getName());
return cons;
}
TypeRepository repository = state.repo;
RemoteDescriptor desc = (RemoteDescriptor) repository.getRemoteInterface(type);
MethodDescriptor[] mdesc = desc.getMethods();
MethodDescriptor[] descriptors = new MethodDescriptor[mdesc.length + 1];
for (int i = 0; i < mdesc.length; i++) {
descriptors[i] = mdesc[i];
}
LOGGER.finer("TYPE ----> " + type);
LOGGER.finer("LOADER --> " + UtilImpl.getClassLoader(type));
LOGGER.finer("CONTEXT -> " + getClassLoader());
MethodRef[] methods = new MethodRef[descriptors.length];
for (int i = 0; i < mdesc.length; i++) {
Method m = descriptors[i].getReflectedMethod();
LOGGER.finer("Method ----> " + m);
methods[i] = new MethodRef(m);
}
methods[mdesc.length] = new MethodRef(stub_write_replace);
Class<?> clazz = null;
try {
/* Construct class! */
clazz = StubClass.make(/* the class loader to use */
UtilImpl.getClassLoader(type),
/* the bean developer's bean class */
RMIStub.class,
/* interfaces */
new Class[] { type },
/* the methods */
methods,
/* contains only ejbCreate */
null,
/* our data objects */
descriptors,
/* the handler method */
getPOAStubInvokeMethod(),
/* package name (use superclass') */
getPackageName(type),
/* provider of handlers */
getRMIStubInitializer());
} catch (java.lang.NoClassDefFoundError ex) {
/* Construct class! */
clazz = StubClass.make(/* the class loader to use */
getClassLoader(),
/* the bean developer's bean class */
RMIStub.class,
/* interfaces */
new Class[] { type },
/* the methods */
methods,
/* contains only ejbCreate */
null,
/* our data objects */
descriptors,
/* the handler method */
getPOAStubInvokeMethod(),
/* package name (use superclass') */
getPackageName(type),
/* provider of handlers */
getRMIStubInitializer());
}
if (clazz != null) {
try {
cons = (Constructor<? extends Stub>) clazz.getConstructor();
state.stub_map.put(type, cons);
} catch (NoSuchMethodException e) {
LOGGER.log(Level.FINER, "constructed stub has no default constructor", e);
}
}
return cons;
}
static String getPackageName(Class clazz) {
String class_name = clazz.getName();
int idx = class_name.lastIndexOf('.');
if (idx == -1) {
return null;
} else {
return class_name.substring(0, idx);
}
}
private static Method poa_stub_invoke_method;
static Method getPOAStubInvokeMethod() {
if (poa_stub_invoke_method == null) {
// NYI: PrivilegedAction
try {
// get the interface method used to invoke the stub handler
poa_stub_invoke_method = (StubHandler.class)
.getDeclaredMethod("invoke", new Class[] {
RMIStub.class, MethodDescriptor.class,
Object[].class });
} catch (NoSuchMethodException ex) {
throw new Error("cannot find RMI Stub handler invoke method", ex);
}
}
return poa_stub_invoke_method;
}
public java.rmi.Remote toStub(java.rmi.Remote value)
throws java.rmi.NoSuchObjectException {
if (value instanceof javax.rmi.CORBA.Stub)
return value;
javax.rmi.CORBA.Tie tie = javax.rmi.CORBA.Util.getTie(value);
if (tie == null) {
throw new java.rmi.NoSuchObjectException("object not exported");
}
RMIServant servant = (RMIServant) tie;
try {
org.omg.PortableServer.POA poa = servant.getRMIState().getPOA();
org.omg.CORBA.Object ref = poa.servant_to_reference(servant);
return (java.rmi.Remote) narrow(ref, servant.getJavaClass());
} catch (org.omg.PortableServer.POAPackage.ServantNotActive ex) {
throw new RuntimeException("internal error: " + ex.getMessage(), ex);
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw new RuntimeException("internal error: " + ex.getMessage(), ex);
}
}
public void exportObject(Remote obj) throws java.rmi.RemoteException {
RMIState state = RMIState.current();
try {
state.checkShutDown();
} catch (BAD_INV_ORDER ex) {
throw new RemoteException("RMIState is deactivated", ex);
}
Tie tie = javax.rmi.CORBA.Util.getTie(obj);
if (tie != null)
throw new java.rmi.RemoteException("object already exported");
RMIServant servant = new RMIServant(state);
javax.rmi.CORBA.Util.registerTarget(servant, obj);
LOGGER.finer("exporting instance of " + obj.getClass().getName()
+ " in " + state.getName());
try {
servant._id = state.getPOA().activate_object(servant);
} catch (org.omg.PortableServer.POAPackage.ServantAlreadyActive ex) {
throw new java.rmi.RemoteException("internal error: " + ex.getMessage(), ex);
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw new java.rmi.RemoteException("internal error: " + ex.getMessage(), ex);
}
}
public void unexportObject(Remote obj)
throws java.rmi.NoSuchObjectException {
javax.rmi.CORBA.Util.unexportObject(obj);
}
// the factory object used for creating stub initializers
static private StubInitializer initializer = null;
// the default stub handler, which is ours without overrides.
private static final String defaultInitializer = "org.apache.yoko.rmi.impl.RMIStubInitializer";
/**
* Get the RMI stub handler initializer to use for RMI invocation
* stubs. The Class in question must implement the StubInitializer method.
*
* @return The class used to create StubHandler instances.
*/
private static StubInitializer getRMIStubInitializer() {
if (initializer == null) {
String factory = (String)AccessController.doPrivileged(new GetSystemPropertyAction("org.apache.yoko.rmi.RMIStubInitializerClass", defaultInitializer));
try {
initializer = (StubInitializer)(UtilLoader.loadServiceClass(factory, "org.apache.yoko.rmi.RMIStubInitializerClass").newInstance());
} catch (Exception e) {
throw (org.omg.CORBA.INITIALIZE)new org.omg.CORBA.INITIALIZE(
"Can not create RMIStubInitializer: " + factory).initCause(e);
}
}
return initializer;
}
}
| 3,303 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/FieldDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import java.io.IOException;
import java.io.ObjectStreamField;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.Map;
import java.util.logging.Logger;
import java.util.logging.Level;
import org.omg.CORBA.ValueMember;
abstract class FieldDescriptor extends ModelElement implements Comparable {
static Logger logger = Logger.getLogger(FieldDescriptor.class.getName());
org.apache.yoko.rmi.util.corba.Field field;
Class type;
Class declaringClass;
boolean isFinal;
ValueMember valuemember;
boolean isPublic;
protected FieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repo) {
super(repo, name);
this.type = type;
init();
declaringClass = owner;
if (f != null) {
isPublic = (Modifier.isPublic(f.getModifiers()));
this.field = new org.apache.yoko.rmi.util.corba.Field(f);
isFinal = Modifier.isFinal(f.getModifiers());
} else {
isPublic = false;
this.field = null;
isFinal = false;
}
}
@Override
protected final String genIDLName() {
return java_name;
}
ValueMember getValueMember(TypeRepository rep) {
if (valuemember == null) {
TypeDescriptor desc = rep.getDescriptor(type);
TypeDescriptor owner = rep.getDescriptor(declaringClass);
valuemember = new ValueMember(getIDLName(), desc.getRepositoryID(),
owner.getRepositoryID(), "1.0", desc.getTypeCode(), null,
(short) (isPublic ? 1 : 0));
}
return valuemember;
}
public Class getType() {
return type;
}
/**
* ordering of fields
*/
public int compareTo(Object other) {
FieldDescriptor desc = (FieldDescriptor) other;
//
// Primitive fields precede non-primitive fields
//
if (this.isPrimitive() && !desc.isPrimitive())
return -1;
else if (!this.isPrimitive() && desc.isPrimitive())
return 1;
//
// fields of the same kind are ordered lexicographically
//
return java_name.compareTo(desc.java_name);
}
public boolean isPrimitive() {
return type.isPrimitive();
}
abstract void read(ObjectReader reader, Object obj)
throws java.io.IOException;
abstract void write(ObjectWriter writer, Object obj)
throws java.io.IOException;
abstract void readFieldIntoMap(ObjectReader reader, java.util.Map map)
throws java.io.IOException;
abstract void writeFieldFromMap(ObjectWriter writer, java.util.Map map)
throws java.io.IOException;
abstract void copyState(Object orig, Object copy, CopyState state);
static FieldDescriptor get(java.lang.reflect.Field f, TypeRepository repository) {
return get(f.getDeclaringClass(), f.getType(), f.getName(), f, repository);
}
static FieldDescriptor get(Class declaringClass, ObjectStreamField field, TypeRepository repository) {
Field f = null;
try {
f = declaringClass.getDeclaredField(field.getName());
} catch (Exception ex) {
logger.log(Level.FINER, "Cannot get java field \"" + field.getName()
+ "\" for class \"" + declaringClass.getName() + "\""
+ "\n" + ex, ex);
}
return get(declaringClass, field.getType(), field.getName(), f, repository);
}
static FieldDescriptor get(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
FieldDescriptor desc = get0(owner, type, name, f, repository);
desc.init();
return desc;
}
private static FieldDescriptor get0(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
return new BooleanFieldDescriptor(owner, type, name, f, repository);
} else if (type == Byte.TYPE) {
return new ByteFieldDescriptor(owner, type, name, f, repository);
} else if (type == Short.TYPE) {
return new ShortFieldDescriptor(owner, type, name, f, repository);
} else if (type == Character.TYPE) {
return new CharFieldDescriptor(owner, type, name, f, repository);
} else if (type == Integer.TYPE) {
return new IntFieldDescriptor(owner, type, name, f, repository);
} else if (type == Long.TYPE) {
return new LongFieldDescriptor(owner, type, name, f, repository);
} else if (type == Float.TYPE) {
return new FloatFieldDescriptor(owner, type, name, f, repository);
} else if (type == Double.TYPE) {
return new DoubleFieldDescriptor(owner, type, name, f, repository);
} else {
throw new RuntimeException("unknown field type " + type);
}
} else {
if(org.omg.CORBA.Object.class.isAssignableFrom(type)) {
return new CorbaObjectFieldDescriptor(owner, type, name, f, repository);
}
if (java.lang.Object.class.equals(type)
|| java.io.Externalizable.class.equals(type)
|| java.io.Serializable.class.equals(type)) {
return new AnyFieldDescriptor(owner, type, name, f,repository);
} else if (java.rmi.Remote.class.isAssignableFrom(type)
|| java.rmi.Remote.class.equals(type))
{
return new RemoteFieldDescriptor(owner, type, name, f, repository);
} else if (String.class.equals(type)) {
return new StringFieldDescriptor(owner, type, name, f, repository);
} else if (java.io.Serializable.class.isAssignableFrom(type)) {
return new ValueFieldDescriptor(owner, type, name, f, repository);
} else if (type.isInterface() && type.getMethods().length > 0) {
// interface classes that define methods
return new ValueFieldDescriptor(owner, type, name, f, repository);
} else {
return new ObjectFieldDescriptor(owner, type, name, f, repository);
}
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
pw.print(java_name);
pw.print("=");
try {
Object obj = field.get(val);
if (obj == null) {
pw.print("null");
} else {
TypeDescriptor desc = repo.getDescriptor(obj.getClass());
desc.print(pw, recurse, obj);
}
} catch (IllegalAccessException ex) {
/*
* } catch (RuntimeException ex) { System.err.println
* ("SystemException in FieldDescriptor "+field); System.err.println
* ("value = "+val); ex.printStackTrace ();
*/
}
}
}
class RemoteFieldDescriptor extends FieldDescriptor {
Class interfaceType;
RemoteFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
if (type.isInterface()) {
interfaceType = type;
} else {
Class t = type;
loop: while (!Object.class.equals(t)) {
Class[] ifs = t.getInterfaces();
for (int i = 0; i < ifs.length; i++) {
if (java.rmi.Remote.class.isAssignableFrom(ifs[i])) {
interfaceType = ifs[i];
break loop;
}
}
t = t.getSuperclass();
}
if (interfaceType == null) {
throw new RuntimeException("cannot find " + "remote interface "
+ "for " + type);
}
}
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
Object value = reader.readRemoteObject(interfaceType);
field.set(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeRemoteObject((java.rmi.Remote) field.get(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(final Object orig, final Object copy, CopyState state) {
try {
field.set(copy, state.copy(field.get(orig)));
} catch (CopyRecursionException e) {
state.registerRecursion(new CopyRecursionResolver(orig) {
public void resolve(Object value) {
try {
field.set(copy, value);
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
});
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
java.rmi.Remote value = (java.rmi.Remote) reader
.readRemoteObject(interfaceType);
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
java.rmi.Remote value = (java.rmi.Remote) map.get(java_name);
writer.writeRemoteObject(value);
}
}
class AnyFieldDescriptor extends FieldDescriptor {
static final Logger logger = Logger.getLogger(AnyFieldDescriptor.class
.getName());
boolean narrowValue;
AnyFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
narrowValue = java.rmi.Remote.class.isAssignableFrom(type);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
Object val = reader.readAny();
if (narrowValue && val != null && !type.isInstance(val)) {
try {
val = javax.rmi.PortableRemoteObject.narrow(val, this.type);
} catch (SecurityException ex) {
logger.finer("Narrow failed" + "\n" + ex);
throw ex;
}
} else if (val != null && !type.isInstance(val)) {
throw new org.omg.CORBA.MARSHAL("value is instance of "
+ val.getClass().getName() + " -- should be: "
+ type.getName());
}
field.set(obj, val);
} catch (IllegalAccessException ex) {
throw (org.omg.CORBA.MARSHAL)new org.omg.CORBA.MARSHAL(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeAny(field.get(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(final Object orig, final Object copy, CopyState state) {
try {
field.set(copy, state.copy(field.get(orig)));
} catch (CopyRecursionException e) {
state.registerRecursion(new CopyRecursionResolver(orig) {
public void resolve(Object value) {
try {
field.set(copy, value);
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
});
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
org.omg.CORBA.Any value = (org.omg.CORBA.Any) reader.readAny();
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
org.omg.CORBA.Any value = (org.omg.CORBA.Any) map.get(java_name);
writer.writeAny(value);
}
}
class ValueFieldDescriptor extends FieldDescriptor {
ValueFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
field.set(obj, reader.readValueObject(getType()));
} catch (IllegalAccessException ex) {
throw (org.omg.CORBA.MARSHAL)new org.omg.CORBA.MARSHAL(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeValueObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(final Object orig, final Object copy, CopyState state) {
try {
field.set(copy, state.copy(field.get(orig)));
} catch (CopyRecursionException e) {
state.registerRecursion(new CopyRecursionResolver(orig) {
public void resolve(Object value) {
try {
field.set(copy, value);
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
});
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
java.io.Serializable value = (java.io.Serializable) reader
.readValueObject();
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
java.io.Serializable value = (java.io.Serializable) map
.get(java_name);
writer.writeValueObject(value);
}
}
class StringFieldDescriptor extends FieldDescriptor {
StringFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
String value = (String) reader.readValueObject();
field.set(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeValueObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.set(copy, field.get(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
String value = (String) reader.readValueObject();
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
String value = (String) map.get(java_name);
writer.writeValueObject(value);
}
}
class ObjectFieldDescriptor extends FieldDescriptor {
ObjectFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
field.set(obj, reader.readAbstractObject());
} catch (IllegalAccessException ex) {
throw (org.omg.CORBA.MARSHAL)new org.omg.CORBA.MARSHAL(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(final Object orig, final Object copy, CopyState state) {
try {
field.set(copy, state.copy(field.get(orig)));
} catch (CopyRecursionException e) {
state.registerRecursion(new CopyRecursionResolver(orig) {
public void resolve(Object value) {
try {
field.set(copy, value);
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
});
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Object value = (Object) reader.readAbstractObject();
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Object value = (Object) map.get(java_name);
writer.writeObject(value);
}
}
class BooleanFieldDescriptor extends FieldDescriptor {
BooleanFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
boolean value = reader.readBoolean();
field.setBoolean(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeBoolean(field.getBoolean(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setBoolean(copy, field.getBoolean(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getBoolean(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Boolean value = new Boolean(reader.readBoolean());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Boolean value = (Boolean) map.get(java_name);
if (value == null) {
writer.writeBoolean(false);
} else {
writer.writeBoolean(value.booleanValue());
}
}
}
class ByteFieldDescriptor extends FieldDescriptor {
ByteFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
byte value = reader.readByte();
field.setByte(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeByte(field.getByte(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setByte(copy, field.getByte(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getByte(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Byte value = new Byte(reader.readByte());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Byte value = (Byte) map.get(java_name);
if (value == null) {
writer.writeByte(0);
} else {
writer.writeByte(value.byteValue());
}
}
}
class ShortFieldDescriptor extends FieldDescriptor {
ShortFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
short value = reader.readShort();
field.setShort(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeShort(field.getShort(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setShort(copy, field.getShort(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getShort(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Short value = new Short(reader.readShort());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Short value = (Short) map.get(java_name);
if (value == null) {
writer.writeShort(0);
} else {
writer.writeShort(value.shortValue());
}
}
}
class CharFieldDescriptor extends FieldDescriptor {
CharFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
char value = reader.readChar();
field.setChar(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeChar(field.getChar(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setChar(copy, field.getChar(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
char ch = field.getChar(val);
pw.print(ch);
pw.print('(');
pw.print(Integer.toHexString(0xffff & ((int) ch)));
pw.print(')');
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Character value = new Character(reader.readChar());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Character value = (Character) map.get(java_name);
if (value == null) {
writer.writeChar(0);
} else {
writer.writeChar(value.charValue());
}
}
}
class IntFieldDescriptor extends FieldDescriptor {
IntFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
int value = reader.readInt();
logger.finest("Read int field value " + value);
field.setInt(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeInt(field.getInt(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setInt(copy, field.getInt(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getInt(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Integer value = new Integer(reader.readInt());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Integer value = (Integer) map.get(java_name);
if (value == null) {
writer.writeInt(0);
} else {
writer.writeInt(value.intValue());
}
}
}
class LongFieldDescriptor extends FieldDescriptor {
LongFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
long value = reader.readLong();
logger.finest("Read long field value " + value);
field.setLong(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeLong(field.getLong(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setLong(copy, field.getLong(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getLong(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Long value = new Long(reader.readLong());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Long value = (Long) map.get(java_name);
if (value == null) {
writer.writeLong(0);
} else {
writer.writeLong(value.longValue());
}
}
}
class FloatFieldDescriptor extends FieldDescriptor {
FloatFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
float value = reader.readFloat();
field.setFloat(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeFloat(field.getFloat(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setFloat(copy, field.getFloat(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getFloat(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Float value = new Float(reader.readFloat());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Float value = (Float) map.get(java_name);
if (value == null) {
writer.writeFloat(0.0F);
} else {
writer.writeFloat(value.floatValue());
}
}
}
class DoubleFieldDescriptor extends FieldDescriptor {
DoubleFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f, TypeRepository repository) {
super(owner, type, name, f, repository);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
double value = reader.readDouble();
field.setDouble(obj, value);
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
if (field == null) {
throw new IOException(
"cannot read/write using serialPersistentFields");
}
try {
writer.writeDouble(field.getDouble(obj));
} catch (IllegalAccessException ex) {
throw (IOException)new IOException(ex.getMessage()).initCause(ex);
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setDouble(copy, field.getDouble(orig));
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(java_name);
pw.print("=");
pw.print(field.getDouble(val));
} catch (IllegalAccessException ex) {
}
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#readField(ObjectReader, Map)
*/
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Double value = new Double(reader.readDouble());
map.put(java_name, value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Double value = (Double) map.get(java_name);
if (value == null) {
writer.writeDouble(0.0D);
} else {
writer.writeDouble(value.doubleValue());
}
}
}
class CorbaObjectFieldDescriptor extends FieldDescriptor {
protected CorbaObjectFieldDescriptor(Class owner, Class type, String name, Field f,TypeRepository repository) {
super(owner, type, name, f, repository);
}
void copyState(final Object orig, final Object copy, CopyState state) {
try {
field.set(copy, state.copy(field.get(orig)));
} catch (CopyRecursionException e) {
state.registerRecursion(new CopyRecursionResolver(orig) {
public void resolve(Object value) {
try {
field.set(copy, value);
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
});
} catch (IllegalAccessException ex) {
throw (InternalError)new InternalError(ex.getMessage()).initCause(ex);
}
}
void read(ObjectReader reader, Object obj) throws IOException {
Object value = reader.readCorbaObject(null);
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
throw (IOException)new IOException(e.getMessage()).initCause(e);
}
}
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Object value = reader.readCorbaObject(null);
map.put(java_name, value);
}
void write(ObjectWriter writer, Object obj) throws IOException {
try {
writer.writeCorbaObject(field.get(obj));
}
catch(IllegalAccessException e) {
throw (IOException)new IOException(e.getMessage()).initCause(e);
}
}
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
org.omg.CORBA.Object value = (org.omg.CORBA.Object) map.get(java_name);
writer.writeCorbaObject(value);
}
}
| 3,304 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/CopyState.java | /**
*
* 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.yoko.rmi.impl;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.logging.Logger;
import org.omg.CORBA.MARSHAL;
public final class CopyState {
static Logger logger = Logger.getLogger(CopyState.class.getName());
private IdentityHashMap copied;
private IdentityHashMap recursionResolverMap;
private TypeRepository rep;
private static Object recursionCheck = new Object();
public CopyState(TypeRepository rep) {
this.rep = rep;
this.copied = new IdentityHashMap();
this.recursionResolverMap = new IdentityHashMap();
}
public void registerRecursion(CopyRecursionResolver resolver) {
Object key = resolver.orig;
CopyRecursionResolver orig = (CopyRecursionResolver) recursionResolverMap
.get(key);
resolver.next = orig;
recursionResolverMap.put(key, resolver);
logger.fine("registering recursion resolver " + resolver + " for "
+ key.getClass() + "@" + System.identityHashCode(key));
}
public void put(Object orig, Object copy) {
Object old = copied.put(orig, copy);
if (old == recursionCheck) {
for (CopyRecursionResolver resolver = (CopyRecursionResolver) recursionResolverMap
.get(orig); resolver != null; resolver = resolver.next) {
logger
.fine("invoking " + resolver + " for "
+ orig.getClass() + "@"
+ System.identityHashCode(orig) + " ===> "
+ copy.getClass() + "@"
+ System.identityHashCode(copy));
resolver.resolve(copy);
}
}
}
private String spaces(int c) {
StringBuffer sb = new StringBuffer();
while (c-- != 0) {
sb.append(' ');
}
return sb.toString();
}
private int idx;
public Object copy(Object orig) throws CopyRecursionException {
if (orig == null)
return orig;
Object copy = copied.get(orig);
if (copy != null) {
if (copy == recursionCheck) {
logger.fine("throwign CopyRecursion for " + orig.getClass()
+ "@" + System.identityHashCode(orig));
throw new CopyRecursionException(this, orig);
}
return copy;
}
Class origClass = orig.getClass();
logger.fine("[" + hashCode() + "]" + spaces(idx++)
+ "copying instance of " + origClass);
TypeDescriptor desc = rep.getDescriptor(origClass);
copied.put(orig, recursionCheck);
copy = desc.copyObject(orig, this);
copied.put(orig, copy);
logger.fine(spaces(--idx) + "=> " + copy);
return copy;
}
public ObjectWriter createObjectWriter(final java.io.Serializable obj) {
try {
return (ObjectWriter) java.security.AccessController
.doPrivileged(new java.security.PrivilegedExceptionAction() {
public Object run() throws IOException {
return new Writer(obj);
}
});
} catch (java.security.PrivilegedActionException e) {
throw (InternalError)new InternalError(e.getMessage()).initCause(e);
}
}
class Writer extends ObjectWriter {
List contents = new ArrayList();
private void enqueue(Object o) {
contents.add(o);
}
Writer(java.io.Serializable obj) throws java.io.IOException {
super(obj);
}
public ObjectReader getObjectReader(Object val) {
try {
// register mapping from old value to new
put(object, val);
return new Reader((Serializable) val, contents);
} catch (IOException ex) {
throw (MARSHAL)new MARSHAL(ex.getMessage()).initCause(ex);
}
}
public void write(int val) throws java.io.IOException {
beforeWriteData();
enqueue(new Byte((byte) val));
}
public void write(byte[] val) throws java.io.IOException {
write(val, 0, val.length);
}
public void write(byte[] arr, int off, int len)
throws java.io.IOException {
if (arr == null || arr.length == 0) {
beforeWriteData();
enqueue(null);
} else if (off == 0 && len == arr.length) {
beforeWriteData();
enqueue(arr);
} else {
byte[] data = new byte[len];
System.arraycopy(arr, off, data, 0, len);
beforeWriteData();
enqueue(data);
}
}
public void writeBoolean(boolean val) throws java.io.IOException {
beforeWriteData();
enqueue(new Boolean(val));
}
public void writeByte(int val) throws java.io.IOException {
beforeWriteData();
enqueue(new Byte((byte) val));
}
public void writeShort(int val) throws java.io.IOException {
beforeWriteData();
enqueue(new Short((short) val));
}
public void writeChar(int val) throws java.io.IOException {
beforeWriteData();
enqueue(new Character((char) val));
}
public void writeInt(int val) throws java.io.IOException {
beforeWriteData();
enqueue(new Integer(val));
}
public void writeLong(long val) throws java.io.IOException {
beforeWriteData();
enqueue(new Long(val));
}
public void writeFloat(float val) throws java.io.IOException {
beforeWriteData();
enqueue(new Float(val));
}
public void writeDouble(double val) throws java.io.IOException {
beforeWriteData();
enqueue(new Double(val));
}
public void writeBytes(java.lang.String val) throws java.io.IOException {
beforeWriteData();
byte[] data = val.getBytes();
enqueue(data);
}
public void writeChars(java.lang.String val) throws java.io.IOException {
beforeWriteData();
char[] data = val.toCharArray();
enqueue(data);
}
public void writeUTF(java.lang.String val) throws java.io.IOException {
beforeWriteData();
enqueue(val);
}
public void writeObjectOverride(final Object obj) {
Object copy;
try {
copy = copy(obj);
} catch (CopyRecursionException rec) {
copy = recursionCheck;
// save position of newly added element
final int idx = contents.size();
registerRecursion(new CopyRecursionResolver(obj) {
public void resolve(Object newValue) {
contents.set(idx, newValue);
}
});
}
enqueue(copy);
}
public void writeValueObject(Object obj) {
writeObjectOverride(obj);
}
public void writeCorbaObject(Object obj) {
writeObjectOverride(obj);
}
public void writeRemoteObject(Object obj) {
writeObjectOverride(obj);
}
public void writeAny(Object obj) {
writeObjectOverride(obj);
}
/*
* (non-Javadoc)
*
* @see org.apache.yoko.rmi.impl.ObjectWriter#_startValue(java.lang.String)
*/
protected void _startValue(String rep_id) throws IOException {
}
/*
* (non-Javadoc)
*
* @see org.apache.yoko.rmi.impl.ObjectWriter#_endValue()
*/
protected void _endValue() throws IOException {
}
protected void _nullValue() throws IOException {
}
}
public class Reader extends ObjectReaderBase {
int cpos;
List contents;
private Object dequeue() {
Object result = contents.get(cpos++);
if (result == recursionCheck) {
throw new IllegalStateException("recursion was not resolved?");
} else {
return result;
}
}
private void undequeue(Object o) {
contents.set(--cpos, o);
}
Reader(java.io.Serializable obj, List data) throws IOException {
super(obj);
contents = data;
cpos = 0;
}
public Object readAbstractObject() {
return dequeue();
}
public Object readAny() {
return dequeue();
}
public Object readValueObject() {
return dequeue();
}
public Object readValueObject(Class<?> clz) {
return dequeue();
}
public org.omg.CORBA.Object readCorbaObject(Class<?> type) {
return (org.omg.CORBA.Object) dequeue();
}
public java.rmi.Remote readRemoteObject(Class<?> type) {
return (java.rmi.Remote) dequeue();
}
public void readFully(byte[] arr, int off, int val)
throws java.io.IOException {
while (val > 0) {
int bytes = read(arr, off, val);
off += bytes;
val -= bytes;
}
}
public int read(byte[] arr, int off, int len)
throws java.io.IOException {
Object obj = dequeue();
if (obj instanceof byte[]) {
byte[] data = (byte[]) obj;
if (data.length <= len) {
System.arraycopy(data, 0, arr, off, data.length);
return data.length;
} else {
// copy only portion of the data
System.arraycopy(data, 0, arr, off, len);
byte[] newdata = new byte[data.length - len];
System.arraycopy(data, len, newdata, 0, data.length - len);
undequeue(newdata);
return len;
}
} else if (obj instanceof Byte) {
Byte b = (Byte) obj;
arr[off] = b.byteValue();
return 1;
} else {
throw new IOException("stream contents is not byte[], it is: "
+ obj.getClass().getName());
}
}
public int skipBytes(int len) throws java.io.IOException {
byte[] data = new byte[len];
readFully(data);
return len;
}
public boolean readBoolean() throws java.io.IOException {
try {
return ((Boolean) dequeue()).booleanValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public byte readByte() throws java.io.IOException {
try {
return ((Byte) dequeue()).byteValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public short readShort() throws java.io.IOException {
try {
return ((Short) dequeue()).shortValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public char readChar() throws java.io.IOException {
try {
return ((Character) dequeue()).charValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public int readInt() throws java.io.IOException {
try {
return ((Integer) dequeue()).intValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public long readLong() throws java.io.IOException {
try {
return ((Long) dequeue()).longValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public float readFloat() throws java.io.IOException {
try {
return ((Float) dequeue()).floatValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
public double readDouble() throws java.io.IOException {
try {
return ((Double) dequeue()).doubleValue();
} catch (ClassCastException ex) {
IOException iox = new IOException(ex.getMessage());
iox.initCause(ex);
throw iox;
}
}
/** @deprecated */
public java.lang.String readLine() throws java.io.IOException {
throw new InternalError("cannot use readline");
}
public java.lang.String readUTF() throws java.io.IOException {
return (String) dequeue();
}
@Override
protected void _startValue() {
}
@Override
protected void _endValue() {
}
}
}
| 3,305 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/SimpleDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.ORB;
import org.omg.CORBA.TCKind;
import org.omg.CORBA.TypeCode;
abstract class SimpleDescriptor extends TypeDescriptor {
private final String idl_name;
private final TCKind tc;
SimpleDescriptor(Class type, TypeRepository repository, String idl_name, TCKind tc) {
super(type, repository);
this.idl_name = idl_name;
this.tc = tc;
}
@Override
protected final String genIDLName() {
return idl_name;
}
@Override
protected final String genPackageName() {
return "";
}
@Override
protected final String genTypeName() {
return idl_name;
}
@Override
protected final TypeCode genTypeCode() {
return ORB.init().get_primitive_tc(tc);
}
@Override
boolean copyInStub() {
return false;
}
@Override
public boolean copyBetweenStates() {
return false;
}
@Override
public boolean copyWithinState() {
return false;
}
}
| 3,306 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ValueHandlerImpl.java | /**
*
* 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.yoko.rmi.impl;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.rmi.CORBA.Stub;
import javax.rmi.CORBA.ValueHandler;
import org.omg.CORBA.CompletionStatus;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.ValueDefPackage.FullValueDescription;
import org.omg.SendingContext.RunTime;
public class ValueHandlerImpl implements ValueHandler {
static final Logger logger = Logger.getLogger(ValueHandlerImpl.class
.getName());
private final TypeRepository repo;
RunTimeCodeBaseImpl codeBase;
private ValueHandlerImpl() {
this.repo = TypeRepository.get();
}
private static enum HandlerHolder {
;
static final ValueHandlerImpl value = new ValueHandlerImpl();
}
public static ValueHandlerImpl get() {
return HandlerHolder.value;
}
private ValueDescriptor desc(Class clz) {
return (ValueDescriptor) repo.getDescriptor(clz);
}
private ValueDescriptor desc(String repId) {
return (ValueDescriptor) repo.getDescriptor(repId);
}
private ValueDescriptor desc(Class clz, String repid, RunTime runtime) {
try {
return repo.getDescriptor(clz, repid, runtime);
} catch (ClassNotFoundException ex) {
MARSHAL m = new MARSHAL("class not found " + ex.getMessage());
m.initCause(ex);
throw m;
}
}
public void writeValue(org.omg.CORBA.portable.OutputStream out,
java.io.Serializable val) {
desc(val.getClass()).writeValue(out, val);
}
java.util.Map streamMap = new java.util.HashMap();
public java.io.Serializable readValue(
org.omg.CORBA.portable.InputStream in, int offset,
java.lang.Class clz, java.lang.String repid,
org.omg.SendingContext.RunTime codebase) {
try {
return readValue0(in, offset, clz, repid, codebase);
} catch (Error ex) {
logger.log(Level.FINE, "Exception reading value of type " + repid, ex);
throw ex;
} catch (RuntimeException ex) {
logger.log(Level.FINE, "Exception reading value of type " + repid, ex);
throw ex;
}
}
public java.io.Serializable readValue0(
org.omg.CORBA.portable.InputStream in, int offset,
java.lang.Class clz, java.lang.String repid,
org.omg.SendingContext.RunTime codebase) {
java.io.Serializable obj = null;
ValueDescriptor desc = repid == null ? desc(clz) : desc(clz, repid,
codebase);
Integer key = new Integer(offset);
boolean remove = false;
java.util.Map offsetMap = null;
try {
synchronized (streamMap) {
offsetMap = (java.util.Map) streamMap.get(in);
if (offsetMap == null) {
offsetMap = new java.util.HashMap();
streamMap.put(in, offsetMap);
remove = true;
}
}
obj = desc.readValue(in, offsetMap, key);
/*
* // lazy initialization of recursive fields... for (ValueBox box =
* (ValueBox) offsetMap.get (key); box != null; box = box.next) {
* box.set (obj); }
*/
} finally {
if (remove) {
synchronized (streamMap) {
streamMap.remove(in);
}
}
}
return obj;
}
public java.lang.String getRMIRepositoryID(java.lang.Class clz) {
return repo.getDescriptor(clz).getRepositoryID();
}
@Override
public boolean isCustomMarshaled(java.lang.Class clz) {
return desc(clz).isChunked();
}
public synchronized org.omg.SendingContext.RunTime getRunTimeCodeBase() {
logger.finer("getRunTimeCodeBase");
if (codeBase == null) {
codeBase = new RunTimeCodeBaseImpl(this);
}
org.omg.CORBA.ORB orb = RMIState.current().getORB();
org.omg.PortableServer.POA poa = RMIState.current().getPOA();
try {
org.omg.CORBA.Object ref = poa.servant_to_reference(codeBase);
return org.omg.SendingContext.CodeBaseHelper.narrow(ref);
} catch (org.omg.PortableServer.POAPackage.ServantNotActive ex) {
// ignore //
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw (org.omg.CORBA.INTERNAL)new org.omg.CORBA.INTERNAL("should not happen").initCause(ex);
}
try {
byte[] id = poa.activate_object(codeBase);
org.omg.CORBA.Object ref = poa.id_to_reference(id);
return org.omg.SendingContext.CodeBaseHelper.narrow(ref);
} catch (org.omg.PortableServer.POAPackage.ServantAlreadyActive ex) {
throw (org.omg.CORBA.INTERNAL)new org.omg.CORBA.INTERNAL("should not happen").initCause(ex);
} catch (org.omg.PortableServer.POAPackage.ObjectNotActive ex) {
throw (org.omg.CORBA.INTERNAL)new org.omg.CORBA.INTERNAL("should not happen").initCause(ex);
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw (org.omg.CORBA.INTERNAL)new org.omg.CORBA.INTERNAL("should not happen").initCause(ex);
}
}
public java.io.Serializable writeReplace(java.io.Serializable val) {
if (val instanceof RMIStub) {
RMIStub stub = (RMIStub) val;
Class type = stub._descriptor.type;
RMIState state = RMIState.current();
Stub result = state.getStaticStub(stub._get_codebase(), type);
if (result != null) {
result._set_delegate(stub._get_delegate());
logger.finer("replacing with stub " + result.getClass().getName());
return result;
}
return new org.apache.yoko.rmi.impl.RMIPersistentStub(stub, type);
} else {
ValueDescriptor desc = desc(val.getClass());
java.io.Serializable result = desc.writeReplace(val);
if (result != val) {
logger.finer("replacing with value of type " + val.getClass().getName() + " with " + result.getClass().getName());
}
return result;
}
}
static Class getClassFromRepositoryID(String id) {
String className = null;
if (logger.isLoggable(Level.FINER)) {
logger.finer("getClassFromRepositoryID => " + id);
}
try {
if (id.startsWith("RMI:")) {
className = id.substring(4, id.indexOf(':', 4));
} else if (id.startsWith("IDL:")) {
className = id.substring(4, id.indexOf(':', 4));
} else {
if (logger.isLoggable(Level.FINER)) {
logger.finer("getClassFromRepositoryID =>> " + null);
}
return null;
}
if (logger.isLoggable(Level.FINER)) {
logger.finer("getClassFromRepositoryID =>> " + className);
}
ClassLoader loader = RMIState.current().getClassLoader();
return loader.loadClass(className);
} catch (Throwable ex) {
logger.log(Level.FINE, "error resolving class from id", ex);
return null;
}
}
String getImplementation(String id) {
try {
String result = "";
Class clz = getClassFromRepositoryID(id);
if (clz != null) {
result = javax.rmi.CORBA.Util.getCodebase(clz);
if (result == null) {
if (logger.isLoggable(Level.FINE)) {
logger.fine("failed to find implementation " + id);
}
return "";
}
}
if (logger.isLoggable(Level.FINER)) {
logger.finer("getImplementation " + id + " => " + result);
}
return result;
} catch (RuntimeException ex) {
logger.log(Level.FINE, "error implementation class from id", ex);
throw ex;
}
}
String[] getImplementations(String[] ids) {
if (ids == null)
return new String[0];
String[] result = new String[ids.length];
for (int i = 0; i < ids.length; i++) {
result[i] = getImplementation(ids[i]);
}
return result;
}
FullValueDescription meta(String repId) {
if (logger.isLoggable(Level.FINER))
logger.finer(String.format("meta \"%s\"", repId));
try {
ValueDescriptor desc = desc(repId);
if (null == desc) {
Class clz = getClassFromRepositoryID(repId);
if (clz == null) {
logger.warning("class not found: " + repId);
throw new org.omg.CORBA.MARSHAL(0x4f4d0001,
CompletionStatus.COMPLETED_MAYBE);
}
desc = desc(clz);
}
return desc.getFullValueDescription();
} catch (Throwable ex) {
logger.log(Level.WARNING, "exception in meta", ex);
throw (org.omg.CORBA.OBJECT_NOT_EXIST)new org.omg.CORBA.OBJECT_NOT_EXIST()
.initCause(ex);
}
}
String[] getBases(String id) {
try {
Class clz = getClassFromRepositoryID(id);
if (clz == null)
return new String[0];
Class[] ifaces = clz.getInterfaces();
Class superClz = clz.getSuperclass();
java.util.ArrayList supers = new java.util.ArrayList();
if (superClz != Object.class) {
addIfRMIClass(supers, superClz);
}
for (int i = 0; i < ifaces.length; i++) {
addIfRMIClass(supers, ifaces[i]);
}
String[] result = new String[supers.size()];
for (int i = 0; i < supers.size(); i++) {
result[i] = ((TypeDescriptor) supers.get(i)).getRepositoryID();
}
if (logger.isLoggable(Level.FINER)) {
logger.finer("getBases " + id + " => " + result);
}
return result;
} catch (Throwable ex) {
logger.log(Level.WARNING, "exception in CodeBase::bases", ex);
return new String[0];
}
}
private void addIfRMIClass(java.util.List list, Class clz) {
TypeDescriptor desc = repo.getDescriptor(clz);
if (desc instanceof RemoteDescriptor)
list.add(desc);
else if (desc instanceof ValueDescriptor)
list.add(desc);
}
}
| 3,307 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/VoidDescriptor.java | /**
*
* 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.yoko.rmi.impl;
final class VoidDescriptor extends SimpleDescriptor {
VoidDescriptor(TypeRepository repository) {
super(Void.TYPE, repository, "void", org.omg.CORBA.TCKind.tk_void);
}
public Object read(org.omg.CORBA.portable.InputStream in) {
return null;
}
public void write(org.omg.CORBA.portable.OutputStream out, Object val) {
}
}
| 3,308 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ObjectReader.java | /**
*
* 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.yoko.rmi.impl;
import java.io.Externalizable;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.NotActiveException;
import java.io.ObjectInputStream;
import java.io.ObjectInputValidation;
import java.io.ObjectStreamClass;
import java.io.Serializable;
import java.rmi.Remote;
import java.util.Map;
import org.apache.yoko.rmi.util.PriorityQueue;
import org.omg.CORBA.portable.IndirectionException;
abstract class ObjectReader extends ObjectInputStream {
ObjectReader() throws IOException {}
abstract void _startValue();
abstract void _endValue();
abstract void setCurrentValueDescriptor(ValueDescriptor desc);
abstract Object readAbstractObject() throws IndirectionException;
abstract Object readAny() throws IndirectionException;
abstract Object readValueObject() throws IndirectionException;
abstract Object readValueObject(Class<?> clz) throws IndirectionException;
abstract org.omg.CORBA.Object readCorbaObject(Class<?> type);
abstract Remote readRemoteObject(Class<?> type);
abstract void readExternal(Externalizable ext) throws IOException, ClassNotFoundException;
@Override
protected abstract Object readObjectOverride() throws IOException, ClassNotFoundException;
}
abstract class ObjectReaderBase extends ObjectReader {
int recursionDepth = 0;
final java.io.Serializable object;
PriorityQueue callbacks;
ObjectReaderBase(Serializable obj) throws IOException {
super();
this.object = obj;
}
private ValueDescriptor desc;
private byte streamFormatVersion;
final void setCurrentValueDescriptor(ValueDescriptor desc) {
this.desc = desc;
}
public final void defaultReadObject() throws IOException, ClassNotFoundException, NotActiveException {
if (desc == null) {
throw new java.io.NotActiveException();
}
desc.defaultReadValue(this, object);
}
protected final Object readObjectOverride() throws ClassNotFoundException, IOException {
try {
enterRecursion();
return readAbstractObject();
} finally {
exitRecursion();
}
}
private void enterRecursion() {
recursionDepth += 1;
}
private void exitRecursion() throws InvalidObjectException {
recursionDepth -= 1;
if (recursionDepth == 0) {
if (callbacks != null) {
while (callbacks.size() != 0) {
Validation val = (Validation) callbacks.dequeue();
val.validate();
}
}
}
}
private class Validation implements Comparable<Validation> {
ObjectInputValidation validator;
int pri;
Validation(ObjectInputValidation val, int pri) {
this.validator = val;
this.pri = pri;
}
public int compareTo(Validation other) {
return pri - other.pri;
}
void validate() throws InvalidObjectException {
validator.validateObject();
}
}
public synchronized void registerValidation(ObjectInputValidation obj, int prio) throws NotActiveException, InvalidObjectException {
if (recursionDepth == 0) {
throw new NotActiveException("readObject not Active");
}
if (obj == null) {
throw new InvalidObjectException("Null is not a valid callback object");
}
Validation val = new Validation(obj, prio);
if (callbacks == null) {
callbacks = new PriorityQueue();
}
callbacks.enqueue(val);
}
public void close() throws java.io.IOException {}
public java.io.ObjectInputStream.GetField readFields() throws IOException {
if (desc == null) {
throw new NotActiveException();
}
Map fieldMap = desc.readFields(this);
return new GetFieldImpl(fieldMap);
}
public void readFully(byte[] arr) throws IOException {
readFully(arr, 0, arr.length);
}
public int readUnsignedByte() throws IOException {
return ((int) readByte()) & 0xff;
}
public int readUnsignedShort() throws IOException {
int val = readShort();
return val & 0xffff;
}
static class GetFieldImpl extends GetField {
Map fieldMap;
GetFieldImpl(Map map) {
fieldMap = map;
}
/**
* @see java.io.ObjectInputStream.GetField#defaulted(String)
*/
public boolean defaulted(String name) throws IOException {
return !fieldMap.containsKey(name);
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, boolean)
*/
public boolean get(String name, boolean val) throws IOException {
Boolean value = (Boolean) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.booleanValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, byte)
*/
public byte get(String name, byte val) throws IOException {
Byte value = (Byte) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.byteValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, char)
*/
public char get(String name, char val) throws IOException {
Character value = (Character) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.charValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, double)
*/
public double get(String name, double val) throws IOException {
Double value = (Double) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.doubleValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, float)
*/
public float get(String name, float val) throws IOException {
Float value = (Float) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.floatValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, int)
*/
public int get(String name, int val) throws IOException {
Integer value = (Integer) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.intValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, long)
*/
public long get(String name, long val) throws IOException {
Long value = (Long) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.longValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, Object)
*/
public Object get(String name, Object val) throws IOException {
Object value = (Object) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value;
}
}
/**
* @see java.io.ObjectInputStream.GetField#get(String, short)
*/
public short get(String name, short val) throws IOException {
Short value = (Short) fieldMap.get(name);
if (defaulted(name)) {
return val;
} else {
return value.shortValue();
}
}
/**
* @see java.io.ObjectInputStream.GetField#getObjectStreamClass()
*/
public ObjectStreamClass getObjectStreamClass() {
return null;
}
}
void readExternal(Externalizable ext) throws IOException, ClassNotFoundException {
byte old = streamFormatVersion;
try {
streamFormatVersion = readByte();
ext.readExternal(this);
} finally {
streamFormatVersion = old;
}
}
}
| 3,309 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/FVDEnumSubclassDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.ValueDefPackage.FullValueDescription;
import java.util.Objects;
class FVDEnumSubclassDescriptor extends EnumSubclassDescriptor {
private final FullValueDescription fvd;
private final String repid;
FVDEnumSubclassDescriptor(FullValueDescription fvd, Class clazz, TypeRepository rep, String repid, ValueDescriptor super_desc) {
super(EnumSubclassDescriptor.getEnumType(clazz), rep);
this.fvd = fvd;
this.repid = repid;
init();
_super_descriptor = super_desc;
}
@Override
protected String genRepId() {
return repid;
}
@Override
FullValueDescription getFullValueDescription() {
return fvd;
}
@Override
protected final TypeCode genTypeCode() {
return fvd.type;
}
@Override
public boolean isCustomMarshalled() {
return fvd.is_custom;
}
}
| 3,310 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/CopyRecursionException.java | /**
*
* 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.yoko.rmi.impl;
public final class CopyRecursionException extends Exception {
final public CopyState state;
final public Object original;
CopyRecursionException(CopyState state, Object original) {
this.state = state;
this.original = original;
}
}
| 3,311 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ByteDescriptor.java | /**
*
* 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.yoko.rmi.impl;
final class ByteDescriptor extends SimpleDescriptor {
ByteDescriptor(TypeRepository repository) {
super(Byte.TYPE, repository, "octet", org.omg.CORBA.TCKind.tk_octet);
}
public Object read(org.omg.CORBA.portable.InputStream in) {
return new Byte(in.read_octet());
}
public void write(org.omg.CORBA.portable.OutputStream out, Object val) {
out.write_octet(((Byte) val).byteValue());
}
}
| 3,312 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/RMIStub.java | /**
*
* 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.yoko.rmi.impl;
import org.apache.yoko.rmi.api.PortableRemoteObjectExt;
import org.omg.CORBA.SystemException;
import org.omg.CORBA.portable.Delegate;
import org.omg.CORBA.portable.ServantObject;
public abstract class RMIStub extends javax.rmi.CORBA.Stub {
protected final transient RemoteDescriptor _descriptor;
protected RMIServant _servant;
protected ServantObject _so;
protected Delegate _delegate;
public RMIStub() {
super();
Class remote_interface = getClass().getInterfaces()[0];
RMIState state = (RMIState) PortableRemoteObjectExt.getState();
Object o = state.repo.getRemoteInterface(
remote_interface);
_descriptor = (RemoteDescriptor) o;
}
public String[] _ids() {
return _descriptor.all_interfaces();
}
// replace stub with RMIPersistentStub
protected abstract Object writeReplace();
private void writeObject(java.io.ObjectOutputStream oo)
throws java.io.IOException {
//
// This should never happen, because writeReplace ought to
// have been called.
//
throw new java.io.IOException("should not happen");
}
// apparently this implementation is expected!
public String toString() {
try {
return _orb().object_to_string(this);
} catch (SystemException e) {
return super.toString() + " (unconnected)";
}
}
/**
* @see org.omg.CORBA.portable.ObjectImpl#_get_delegate()
*/
public Delegate _get_delegate() {
if (_delegate != null) {
return _delegate;
} else if (_servant != null) {
return (_delegate = _servant.getDelegate());
} else {
return super._get_delegate();
}
}
public void _set_delegate(Delegate del) {
_delegate = del;
}
/**
* @see org.omg.CORBA.portable.ObjectImpl#_is_local()
*/
public boolean _is_local() {
if (_servant != null) {
return true;
} else {
return super._is_local();
}
}
/**
* @see org.omg.CORBA.portable.ObjectImpl#_servant_postinvoke(ServantObject)
*/
public void _servant_postinvoke(ServantObject servant) {
if (_servant == null) {
super._servant_postinvoke(servant);
} else {
// do nothing //
}
}
/**
* @see org.omg.CORBA.portable.ObjectImpl#_servant_preinvoke(String, Class)
*/
public ServantObject _servant_preinvoke(String operation, Class expectedType) {
if (_servant == null) {
return super._servant_preinvoke(operation, expectedType);
} else {
if (_so == null) {
ServantObject so = new ServantObject();
so.servant = _servant;
_so = so;
}
return _so;
}
}
}
| 3,313 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/FVDValueDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.ValueDefPackage.FullValueDescription;
import org.omg.CORBA.ValueMember;
/**
* @author krab
*/
class FVDValueDescriptor extends ValueDescriptor {
final FullValueDescription fvd;
final String repid;
FVDValueDescriptor(FullValueDescription fvd, Class clazz,
TypeRepository rep, String repid, ValueDescriptor super_desc) {
super(clazz, rep);
this.repid = repid;
this.fvd = fvd;
init();
this._super_descriptor = super_desc;
}
public void init() {
super.init();
// don't override custom loading. Our local version could work differently.
// if (!fvd.is_custom) {
// _read_object_method = null;
// _write_object_method = null;
// _is_externalizable = false;
// }
ValueMember[] members = fvd.members;
FieldDescriptor[] new_fields = new FieldDescriptor[members.length];
for (int i = 0; i < members.length; i++) {
ValueMember valueMember = members[i];
new_fields[i] = findField(valueMember);
}
_fields = new_fields;
}
private FieldDescriptor findField(ValueMember valueMember) {
FieldDescriptor result = null;
for (Class c = type; c != null; c = c.getSuperclass()) {
TypeDescriptor td = repo.getDescriptor(c);
if (td instanceof ValueDescriptor) {
ValueDescriptor vd = (ValueDescriptor) td;
FieldDescriptor[] fds = vd._fields;
if (fds == null) {
continue;
}
for (int i = 0; i < fds.length; i++) {
if (fds[i].getIDLName().equals(valueMember.name)) {
return fds[0];
}
}
}
}
return result;
}
@Override
protected String genRepId() {
return repid;
}
@Override
org.omg.CORBA.ValueDefPackage.FullValueDescription getFullValueDescription() {
return fvd;
}
@Override
protected final TypeCode genTypeCode() {
return fvd.type;
}
@Override
public boolean isCustomMarshalled() {
return fvd.is_custom;
}
}
| 3,314 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/RemoteDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.ORB;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.rmi.Remote;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Comparator;
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.TreeSet;
import java.util.logging.Level;
import javax.rmi.PortableRemoteObject;
abstract class RemoteDescriptor extends TypeDescriptor {
private java.util.Map method_map;
private java.util.Map refl_method_map;
private MethodDescriptor[] operations;
private Class[] remote_interfaces;
protected List super_descriptors;
@Override
protected abstract RemoteInterfaceDescriptor genRemoteInterface();
static final Class REMOTE_CLASS = Remote.class;
static final Class OBJECT_CLASS = java.lang.Object.class;
static final java.lang.Class REMOTE_EXCEPTION = java.rmi.RemoteException.class;
String[] _ids;
public String[] all_interfaces() {
if (_ids == null) {
Class[] ifaces = collect_remote_interfaces(type);
int len = ifaces.length;
String[] ids = new String[len];
for (int i = 0; i < len; i++) {
TypeDescriptor desc = repo.getDescriptor(ifaces[i]);
ids[i] = desc.getRepositoryID();
}
_ids = ids;
}
return _ids;
}
public MethodDescriptor getMethod(String idl_name) {
if (operations == null) {
init_methods();
}
if (method_map == null) {
method_map = new HashMap();
for (int i = 0; i < operations.length; i++) {
method_map.put(operations[i].getIDLName(), operations[i]);
}
}
return (MethodDescriptor) method_map.get(idl_name);
}
void debugMethodMap() {
if (logger.isLoggable(Level.FINER)) {
logger.finer("METHOD MAP FOR " + type.getName());
Iterator it = method_map.keySet().iterator();
while (it.hasNext()) {
String idl_name = (String) it.next();
MethodDescriptor desc = (MethodDescriptor) method_map.get(idl_name);
logger.finer("IDL " + idl_name + " -> "+ desc.reflected_method);
}
}
}
public MethodDescriptor getMethod(Method refl_method) {
if (operations == null) {
init_methods();
}
if (refl_method_map == null) {
refl_method_map = new HashMap();
for (int i = 0; i < operations.length; i++) {
refl_method_map.put(operations[i].getReflectedMethod(), operations[i]);
}
}
return (MethodDescriptor) refl_method_map.get(refl_method);
}
RemoteDescriptor(Class type, TypeRepository repository) {
super(type, repository);
}
public MethodDescriptor[] getMethods() {
if (operations == null) {
init_methods();
}
return operations;
}
public synchronized void init_methods() {
if (operations != null) {
return;
}
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
init_methods0();
return null;
}
});
}
private void init_methods0() {
ArrayList method_list = new ArrayList();
// first step is to build the helpers for any super classes
Class[] supers = type.getInterfaces();
super_descriptors = new ArrayList();
Map all_methods = new HashMap();
Map lower_case_names = new HashMap();
for (int i = 0; i < supers.length; i++) {
Class iface = supers[i];
if (!REMOTE_CLASS.equals(iface) && !OBJECT_CLASS.equals(iface)
&& REMOTE_CLASS.isAssignableFrom(iface)
&& iface.isInterface()) {
RemoteDescriptor superHelper = (RemoteDescriptor)repo.getDescriptor(iface);
super_descriptors.add(superHelper);
MethodDescriptor[] superOps = superHelper.getMethods();
for (int j = 0; j < superOps.length; j++) {
MethodDescriptor op = superOps[j];
method_list.add(op);
addMethodOverloading(all_methods, op.getReflectedMethod());
addMethodCaseSensitive(lower_case_names, op.getReflectedMethod());
}
}
}
// next, build the method helpers for this class
Method[] methods = getLocalMethods();
// register methods
for (int i = 0; i < methods.length; i++) {
addMethodOverloading(all_methods, methods[i]);
addMethodCaseSensitive(lower_case_names, methods[i]);
}
Set overloaded_names = new HashSet();
Iterator it = all_methods.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
String mname = (String) entry.getKey();
Set s = (Set) entry.getValue();
if (s.size() > 1) {
overloaded_names.add(mname);
}
}
for (int i = 0; i < methods.length; i++) {
MethodDescriptor op = new MethodDescriptor(methods[i], repo);
String mname = op.java_name;
// is there another method that differs only in case?
Set same_case_names = (Set) lower_case_names.get(mname.toLowerCase());
if (same_case_names.size() > 1) {
op.setCaseSensitive(true);
}
// is this method overloaded?
Set overload_names = (Set) all_methods.get(mname);
if (overload_names.size() > 1) {
op.setOverloaded(true);
}
op.init();
method_list.add(op);
}
// init method map...
method_map = new HashMap();
for (int i = 0; i < method_list.size(); i++) {
MethodDescriptor desc = (MethodDescriptor) method_list.get(i);
logger.finer("Adding method " + desc.java_name + " to method map under " + desc.getIDLName());
method_map.put(desc.getIDLName(), desc);
}
//
// initialize "operations" from the values of the map, such
// that repeat methods are eliminated.
//
operations = (MethodDescriptor[]) method_map.values().toArray(
new MethodDescriptor[0]);
debugMethodMap();
}
private void addMethodOverloading(Map map, Method m) {
String mname = m.getName();
Set entry = (Set) map.get(mname);
if (entry == null) {
entry = new HashSet();
map.put(mname, entry);
}
entry.add(createMethodSelector(m));
}
Method[] getLocalMethods() {
ArrayList result = new ArrayList();
addNonRemoteInterfaceMethods(type, result);
Method[] out = new Method[result.size()];
result.toArray(out);
return out;
}
void addNonRemoteInterfaceMethods(Class clz, ArrayList result) {
Method[] methods;
try {
methods = clz.getDeclaredMethods();
} catch (NoClassDefFoundError e) {
ClassLoader clzClassLoader = clz.getClassLoader();
logger.log(Level.FINER, "cannot find class " + e.getMessage() + " from "
+ clz.getName() + " (classloader " + clzClassLoader + "): "
+ e.getMessage(), e);
throw e;
}
for (int j = 0; j < methods.length; j++) {
// since this is a remote interface, we need to add everything
result.add(methods[j]);
}
Class[] ifaces = clz.getInterfaces();
for (int i = 0; i < ifaces.length; i++) {
if (!REMOTE_CLASS.isAssignableFrom(ifaces[i])) {
addNonRemoteInterfaceMethods(ifaces[i], result);
}
}
}
boolean isRemoteMethod(Method m) {
Class[] ex = m.getExceptionTypes();
for (int i = 0; i < ex.length; i++) {
if (REMOTE_EXCEPTION.isAssignableFrom(ex[i]))
return true;
}
return false;
}
private static String createMethodSelector(java.lang.reflect.Method m) {
StringBuffer sb = new StringBuffer(m.getName());
sb.append('(');
Class[] parameterTypes = m.getParameterTypes();
for (int n = 0; n < parameterTypes.length; n++) {
sb.append(parameterTypes[n].getName());
if (n < parameterTypes.length - 1) {
sb.append(", ");
}
}
sb.append(')');
return sb.toString().intern();
}
private void addMethodCaseSensitive(Map map, Method m) {
String mname = m.getName();
String lowname = mname.toLowerCase();
Set entry = (Set) map.get(lowname);
if (entry == null) {
entry = new HashSet();
map.put(lowname, entry);
}
entry.add(mname);
}
private void collect_interfaces(Set s, Class c) {
if (c.isInterface() && !REMOTE_CLASS.equals(c))
s.add(c);
Class sup = c.getSuperclass();
if (sup != null && !OBJECT_CLASS.equals(sup)) {
collect_interfaces(s, sup);
}
Class[] supers = c.getInterfaces();
for (int i = 0; i < supers.length; i++) {
Class iface = supers[i];
if (!REMOTE_CLASS.equals(iface)
&& REMOTE_CLASS.isAssignableFrom(iface)) {
collect_interfaces(s, iface);
}
}
}
protected Class[] collect_remote_interfaces(Class c) {
if (remote_interfaces != null)
return remote_interfaces;
Set s = new TreeSet(new Comparator() {
public int compare(Object o1, Object o2) {
Class c1 = (Class) o1;
Class c2 = (Class) o2;
if (c1.equals(c2))
return 0;
if (c1.isAssignableFrom(c2)) {
// c2 is more specific (so it should come first)
return 1;
} else if (c2.isAssignableFrom(c1)) {
// c1 is more specific (so it should come first)
return -1;
} else // they are unrelated
{
// just define some consistent order...
return c1.getName().compareTo(c2.getName());
}
}
});
collect_interfaces(s, c);
remote_interfaces = new Class[s.size()];
s.toArray(remote_interfaces);
return remote_interfaces;
}
/** Read an instance of this value from a CDR stream */
@Override
public Object read(InputStream in) {
return PortableRemoteObject.narrow(in.read_Object(),
type);
}
/** Write an instance of this value to a CDR stream */
@Override
public void write(OutputStream out, Object val) {
javax.rmi.CORBA.Util.writeRemoteObject(out, val);
}
@Override
protected final TypeCode genTypeCode() {
ORB orb = ORB.init();
return orb.create_interface_tc(getRepositoryID(), type.getName());
}
@Override
void writeMarshalValue(PrintWriter pw, String outName,
String paramName) {
pw.print("javax.rmi.CORBA.Util.writeRemoteObject(");
pw.print(outName);
pw.print(',');
pw.print(paramName);
pw.print(')');
}
@Override
void writeUnmarshalValue(PrintWriter pw, String inName) {
pw.print('(');
pw.print(type.getName());
pw.print(')');
pw.print(PortableRemoteObject.class.getName());
pw.print(".narrow(");
pw.print(inName);
pw.print('.');
pw.print("read_Object(),");
pw.print(type.getName());
pw.print(".class)");
}
static String classNameFromStub(String name) {
if (name.startsWith("org.omg.stub."))
name = name.substring("org.omg.stub.".length());
// strip xx._X_Stub -> xx.X
int idx = name.lastIndexOf('.');
if (name.charAt(idx + 1) == '_' && name.endsWith("_Stub")) {
if (idx == -1) {
return name.substring(1, name.length() - 5);
} else {
return name.substring(0, idx + 1) /* package. */
+ name.substring(idx + 2, name.length() - 5);
}
}
return null;
}
static String stubClassName(Class c) {
String cname = c.getName();
String pkgname = null;
int idx = cname.lastIndexOf('.');
if (idx == -1) {
pkgname = "org.omg.stub";
} else {
pkgname = "org.omg.stub." + cname.substring(0, idx);
}
String cplain = cname.substring(idx + 1);
return pkgname + "._" + cplain + "_Stub";
}
void writeStubClass(PrintWriter pw) {
Class c = type;
String cname = c.getName();
String fullname = stubClassName(c);
//String stubname = fullname.substring(fullname.lastIndexOf('.') + 1);
String pkgname = fullname.substring(0, fullname.lastIndexOf('.'));
String cplain = cname.substring(cname.lastIndexOf('.') + 1);
pw.println("/** ");
pw.println(" * RMI/IIOP stub for " + cname);
pw.println(" * Generated using Apache Yoko stub generator.");
pw.println(" */");
pw.println("package " + pkgname + ";\n");
pw.println("public class _" + cplain + "_Stub");
pw.println("\textends javax.rmi.CORBA.Stub");
pw.println("\timplements " + cname);
pw.println("{");
//
// construct String[] _ids;
//
String[] all_interfaces = all_interfaces();
pw.println("\tprivate static final String[] _ids = {");
for (int i = 0; i < all_interfaces.length; i++) {
pw.println("\t\t\"" + all_interfaces[i] + "\",");
}
pw.println("\t};\n");
pw.println("\tpublic String[] _ids() {");
pw.println("\t\treturn _ids;");
pw.println("\t}");
//
// now, construct stub methods
//
MethodDescriptor[] meths = getMethods();
for (int i = 0; i < meths.length; i++) {
meths[i].writeStubMethod(pw);
}
pw.println("}");
}
String getStubClassName() {
Class c = type;
String cname = c.getName();
String pkgname = null;
int idx = cname.lastIndexOf('.');
if (idx == -1) {
pkgname = "org.omg.stub";
} else {
pkgname = "org.omg.stub." + cname.substring(0, idx);
}
String cplain = cname.substring(idx + 1);
return pkgname + "." + "_" + cplain + "_Stub";
}
@Override
void addDependencies(Set classes) {
Class c = type;
if (c == Remote.class || classes.contains(c))
return;
classes.add(c);
if (c.getSuperclass() != null) {
TypeDescriptor desc = repo.getDescriptor(c.getSuperclass());
desc.addDependencies(classes);
}
Class[] ifaces = c.getInterfaces();
for (int i = 0; i < ifaces.length; i++) {
TypeDescriptor desc = repo.getDescriptor(ifaces[i]);
desc.addDependencies(classes);
}
MethodDescriptor[] mths = getMethods();
for (int i = 0; i < mths.length; i++) {
mths[i].addDependencies(classes);
}
}
@Override
boolean copyInStub() {
return false;
}
}
| 3,315 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/EnumSubclassDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import org.omg.CORBA.portable.IndirectionException;
import org.omg.CORBA.portable.InputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.Map;
class EnumSubclassDescriptor extends ValueDescriptor {
@SuppressWarnings("rawtypes")
private final Class enumType;
EnumSubclassDescriptor(Class<?> type, TypeRepository repository) {
super(type, repository);
enumType = type;
}
static Class<?> getEnumType(Class<?> type) {
if (!!!Enum.class.isAssignableFrom(type)) throw new IllegalArgumentException(type.getName() + " is not an Enum");
while (!!!type.isEnum()) type = type.getSuperclass();
return type;
}
@Override
protected final long getSerialVersionUID() {
return 0L;
}
@Override
protected final boolean isEnum() {
return true;
}
@Override
final public Serializable readValue(InputStream in, Map<Integer, Object> offsetMap, Integer offset) {
try {
// Shortcut to reading in just the 'name' field of java.lang.Enum
String name = null;
try {
name = (String) ((org.omg.CORBA_2_3.portable.InputStream) in).read_value(String.class);
} catch (org.omg.CORBA.MARSHAL e) {
// Problem probably due to ordinal field data being sent
// This should be resolved by the 'if (name == null) {' block below, so this
// exception can be safely discarded.
}
if (name == null) {
// ordinal field may have been sent, causing the read of the name field to fail
// If this is the case, the input stream cursor will now be at the start of where the
// name field is located (the 4 bytes of the ordinal having now been read in)
name = (String) ((org.omg.CORBA_2_3.portable.InputStream) in).read_value(String.class);
}
@SuppressWarnings("unchecked")
final Enum<?> value = (Enum<?>) Enum.valueOf(enumType, name);
offsetMap.put(offset, value);
return value;
} catch (IndirectionException ex) {
return (Serializable) offsetMap.get(ex.offset);
}
}
@Override
protected final void writeValue(ObjectWriter writer, Serializable val) throws IOException {
// Don't write out any fields in the Enum subclass
_super_descriptor.writeValue(writer, val);
}
@Override
public final boolean isChunked() {
// Always do chunking for subclasses of Enum - like it's custom marshalled
return true;
}
@Override
public final Serializable writeReplace(Serializable val) {
// Never allow the honoring of writeReplace on an Enum subclass
return val;
}
}
| 3,316 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ValueDescriptor.java | /**
* 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
* <p/>
* http://www.apache.org/licenses/LICENSE-2.0
* <p/>
* 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.yoko.rmi.impl;
import static java.util.Arrays.asList;
import static java.util.Collections.unmodifiableSet;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamField;
import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessController;
import java.security.DigestOutputStream;
import java.security.MessageDigest;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.yoko.rmi.util.StringUtil;
import org.omg.CORBA.AttributeDescription;
import org.omg.CORBA.Initializer;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.ORB;
import org.omg.CORBA.OperationDescription;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.VM_NONE;
import org.omg.CORBA.ValueMember;
import org.omg.CORBA.ValueDefPackage.FullValueDescription;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
import org.omg.CORBA.portable.UnknownException;
import org.omg.SendingContext.CodeBase;
import org.omg.SendingContext.CodeBaseHelper;
import org.omg.SendingContext.RunTime;
import sun.reflect.ReflectionFactory;
class ValueDescriptor extends TypeDescriptor {
static final Logger logger = Logger.getLogger(ValueDescriptor.class.getName());
private boolean _is_externalizable;
private boolean _is_serializable;
private Method _write_replace_method;
private Method _read_resolve_method;
private Constructor _constructor;
private Method _write_object_method;
private Method _read_object_method;
private Field _serial_version_uid_field;
protected ValueDescriptor _super_descriptor;
protected FieldDescriptor[] _fields;
private ObjectDeserializer _object_deserializer;
private boolean _is_immutable_value;
private boolean _is_rmi_stub;
private String _custom_repid;
private static final Set<? extends Class<? extends Serializable>> _immutable_value_classes = unmodifiableSet(new HashSet<>(asList(Integer.class,
Character.class, Boolean.class, Byte.class, Long.class, Float.class, Double.class, Short.class)));
private long _hash_code;
ValueDescriptor(Class type, TypeRepository repository) {
super(type, repository);
}
protected boolean isEnum() { return false; }
@Override
protected String genRepId() {
return String.format("RMI:%s:%016X:%016X", StringUtil.convertToValidIDLNames(type.getName()),
_hash_code, getSerialVersionUID());
}
private String genCustomRepId() {
return String.format("RMI:org.omg.custom.%s", getRepositoryID().substring(4));
}
public final String getCustomRepositoryID() {
if (_custom_repid == null) _custom_repid = genCustomRepId();
return _custom_repid;
}
protected long getSerialVersionUID() {
if (_serial_version_uid_field != null) {
try {
return _serial_version_uid_field.getLong(null);
} catch (IllegalAccessException ex) {
// skip //
}
}
ObjectStreamClass serialForm = ObjectStreamClass.lookup(type);
return (serialForm != null) ? serialForm.getSerialVersionUID() : 0L;
}
public void init() {
try {
init0();
super.init();
if (_fields == null) {
throw new RuntimeException("fields==null after init!");
}
} catch (RuntimeException | Error ex) {
logger.log(Level.FINE, "runtime error in ValueDescriptor.init " + ex.getMessage(), ex);
}
}
private void init0() {
final Class<?> superClass = type.getSuperclass();
_is_rmi_stub = RMIStub.class.isAssignableFrom(type);
_is_externalizable = Externalizable.class.isAssignableFrom(type);
_is_serializable = Serializable.class.isAssignableFrom(type);
_is_immutable_value = _immutable_value_classes.contains(type);
if ((superClass != null) && (superClass != Object.class)) {
TypeDescriptor superDesc = repo.getDescriptor(superClass);
if (superDesc instanceof ValueDescriptor) {
_super_descriptor = (ValueDescriptor) superDesc;
}
}
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
for (Class<?> curr = type; curr != null; curr = curr.getSuperclass()) {
//
// get writeReplace, if any
//
try {
_write_replace_method = curr.getDeclaredMethod("writeReplace");
_write_replace_method.setAccessible(true);
break;
} catch (NoSuchMethodException ignored) {
}
}
//
// Get readResolve, if present
//
try {
_read_resolve_method = type.getDeclaredMethod("readResolve");
_read_resolve_method.setAccessible(true);
} catch (NoSuchMethodException ignored) {
}
//
// get readObject
//
try {
_read_object_method = type.getDeclaredMethod("readObject", ObjectInputStream.class);
_read_object_method.setAccessible(true);
} catch (NoSuchMethodException ignored) {
}
//
// get readObject
//
try {
_write_object_method = type.getDeclaredMethod("writeObject", ObjectOutputStream.class);
_write_object_method.setAccessible(true);
} catch (NoSuchMethodException ignored) {
}
//
// validate readObject
//
if ((_write_object_method == null) || !Modifier.isPrivate(_write_object_method.getModifiers())
|| Modifier.isStatic(_write_object_method.getModifiers()) || (_write_object_method.getDeclaringClass() != type)) {
_write_object_method = null;
}
//
// validate writeObject
//
if ((_read_object_method == null) || !Modifier.isPrivate(_read_object_method.getModifiers())
|| Modifier.isStatic(_read_object_method.getModifiers())) {
_read_object_method = null;
}
//
// get serialVersionUID field
//
try {
_serial_version_uid_field = type.getDeclaredField("serialVersionUID");
if (Modifier.isStatic(_serial_version_uid_field.getModifiers())) {
_serial_version_uid_field.setAccessible(true);
} else {
_serial_version_uid_field = null;
}
} catch (NoSuchFieldException ex) {
// skip //
}
//
// get serialPersistentFields field
//
ObjectStreamField[] serial_persistent_fields = null;
try {
Field _serial_persistent_fields_field = type.getDeclaredField("serialPersistentFields");
_serial_persistent_fields_field.setAccessible(true);
serial_persistent_fields = (ObjectStreamField[]) _serial_persistent_fields_field.get(null);
} catch (IllegalAccessException | NoSuchFieldException ex) {
// skip //
}
if (_is_externalizable) {
//
// Get the default constructor
//
try {
_constructor = type.getDeclaredConstructor();
_constructor.setAccessible(true);
} catch (NoSuchMethodException ex) {
logger.log(Level.WARNING, "Class " + type.getName() + " is not properly externalizable. "
+ "It has not default constructor.", ex);
}
} else if (_is_serializable && !type.isInterface()) {
Class<?> initClass = type;
while ((initClass != null) && Serializable.class.isAssignableFrom(initClass)) {
initClass = initClass.getSuperclass();
}
if (initClass == null) {
logger.warning("Class " + type.getName() + " is not properly serializable. " + "It has no non-serializable super-class");
} else {
try {
Constructor init_cons = initClass.getDeclaredConstructor();
if (Modifier.isPublic(init_cons.getModifiers()) || Modifier.isProtected(init_cons.getModifiers())) {
// do nothing - it's accessible
} else if (!samePackage(type, initClass)) {
logger.warning("Class " + type.getName() + " is not properly serializable. "
+ "The default constructor of its first " + "non-serializable super-class (" + initClass.getName()
+ ") is not accessible.");
}
_constructor = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(type, init_cons);
if (_constructor == null) {
logger.warning("Unable to get constructor for serialization for class " + java_name);
} else {
_constructor.setAccessible(true);
}
} catch (NoSuchMethodException ex) {
logger.log(Level.WARNING, "Class " + type.getName() + " is not properly serializable. "
+ "First non-serializable super-class (" + initClass.getName() + ") has no default constructor.", ex);
}
}
}
if (serial_persistent_fields == null) {
//
// Get relevant field definitions
//
Field[] ff = type.getDeclaredFields();
if ((ff == null) || (ff.length == 0)) {
_fields = new FieldDescriptor[0];
} else {
List<FieldDescriptor> flist = new ArrayList<>();
for (Field f : ff) {
int mod = f.getModifiers();
if (Modifier.isStatic(mod) || Modifier.isTransient(mod)) {
continue;
}
f.setAccessible(true);
FieldDescriptor fd = FieldDescriptor.get(f, repo);
flist.add(fd);
}
_fields = new FieldDescriptor[flist.size()];
_fields = flist.toArray(_fields);
//
// sort the fields
//
Arrays.sort(_fields);
}
} else {
_fields = new FieldDescriptor[serial_persistent_fields.length];
for (int i = 0; i < serial_persistent_fields.length; i++) {
ObjectStreamField f = serial_persistent_fields[i];
FieldDescriptor fd = null;
try {
Field rf = type.getField(f.getName());
rf.setAccessible(true);
if (rf.getType() == f.getType()) {
fd = FieldDescriptor.get(rf,repo);
}
} catch (SecurityException | NoSuchFieldException ex) {
}
if (fd == null) {
fd = FieldDescriptor.get(type, f, repo);
}
_fields[i] = fd;
}
//
// sort the fields (this is also the case for serial
// persistent
// fields, because they have to map to some foreign
// IDL).
//
Arrays.sort(_fields);
}
//
// Compute the structural hash
//
_hash_code = computeHashCode();
//
// Setup the default deserializer
//
_object_deserializer = new ObjectDeserializer(ValueDescriptor.this);
return null;
}
});
}
private boolean samePackage(Class type, Class initClass) {
String pkg1 = getPackageName(type);
String pkg2 = getPackageName(initClass);
return pkg1.equals(pkg2);
}
private String getPackageName(Class type) {
String name = type.getName();
int idx = name.lastIndexOf('.');
return (idx == -1) ? "" : name.substring(0, idx);
}
/** Read an instance of this value from a CDR stream */
public Object read(org.omg.CORBA.portable.InputStream in) {
return ((org.omg.CORBA_2_3.portable.InputStream) in).read_value();
}
/** Write an instance of this value to a CDR stream */
public void write(OutputStream out, Object value) {
((org.omg.CORBA_2_3.portable.OutputStream) out).write_value((Serializable) value);
}
public boolean isCustomMarshalled() {
return (_is_externalizable || (_write_object_method != null));
}
public boolean isChunked() {
if (isCustomMarshalled()) return true;
return (_super_descriptor != null) && _super_descriptor.isChunked();
}
public Serializable writeReplace(Serializable val) {
if (_write_replace_method != null) {
try {
return (Serializable) _write_replace_method.invoke(val);
} catch (IllegalAccessException ex) {
throw (MARSHAL) new MARSHAL("cannot call " + _write_replace_method).initCause(ex);
} catch (IllegalArgumentException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
} catch (InvocationTargetException ex) {
throw (UnknownException) new UnknownException(ex.getTargetException()).initCause(ex.getTargetException());
}
}
return val;
}
public Serializable readResolve(Serializable val) {
if (_read_resolve_method != null) {
try {
return (Serializable) _read_resolve_method.invoke(val);
} catch (IllegalAccessException ex) {
throw (MARSHAL) new MARSHAL("cannot call " + _read_resolve_method).initCause(ex);
} catch (IllegalArgumentException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
} catch (InvocationTargetException ex) {
throw (UnknownException) new UnknownException(ex.getTargetException()).initCause(ex.getTargetException());
}
}
return val;
}
public void writeValue(final OutputStream out, final Serializable value) {
try {
ObjectWriter writer = (ObjectWriter) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
return new CorbaObjectWriter(out, value);
} catch (IOException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
}
}
});
writeValue(writer, value);
} catch (IOException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
}
}
protected void defaultWriteValue(ObjectWriter writer, Serializable val) throws IOException {
logger.finer("writing fields for " + type);
FieldDescriptor[] fields = _fields;
if (fields == null) {
return;
}
for (int i = 0; i < fields.length; i++) {
logger.finer("writing field " + _fields[i].java_name);
fields[i].write(writer, val);
}
}
protected void writeValue(ObjectWriter writer, Serializable val) throws IOException {
if (_is_externalizable) {
writer.invokeWriteExternal((Externalizable) val);
return;
}
if (_super_descriptor != null) {
_super_descriptor.writeValue(writer, val);
}
if (_write_object_method != null) {
try {
writer.invokeWriteObject(this, val, _write_object_method);
} catch (IllegalAccessException | IllegalArgumentException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
} catch (InvocationTargetException ex) {
throw (UnknownException) new UnknownException(ex.getTargetException()).initCause(ex.getTargetException());
}
} else {
defaultWriteValue(writer, val);
}
}
private Serializable createBlankInstance() {
if (_constructor != null) {
try {
return (Serializable) _constructor.newInstance();
} catch (IllegalAccessException ex) {
throw (MARSHAL) new MARSHAL("cannot call " + _constructor).initCause(ex);
} catch (IllegalArgumentException | InstantiationException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
} catch (InvocationTargetException ex) {
throw (UnknownException) new UnknownException(ex.getTargetException()).initCause(ex.getTargetException());
} catch (NullPointerException ex) {
logger.log(Level.WARNING, "unable to create instance of " + type.getName(), ex);
logger.warning("constructor => " + _constructor);
throw ex;
}
} else {
return null;
}
}
public Serializable readValue(final InputStream in, final Map<Integer, Object> offsetMap, final Integer offset) {
final Serializable value = createBlankInstance();
offsetMap.put(offset, value);
try {
ObjectReader reader = (ObjectReader) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
return new CorbaObjectReader(in, offsetMap, value);
} catch (IOException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
}
}
});
readValue(reader, value);
final Serializable resolved = readResolve(value);
if (value != resolved) {
offsetMap.put(offset, resolved);
}
return resolved;
} catch (IOException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
}
}
void print(PrintWriter pw, Map<Object, Integer> recurse, Object val) {
if (val == null) {
pw.print("null");
}
Integer old = recurse.get(val);
if (old != null) {
pw.print("^" + old);
} else {
int key = System.identityHashCode(val);
recurse.put(val, key);
pw.println(type.getName() + "@" + Integer.toHexString(key) + "[");
printFields(pw, recurse, val);
pw.println("]");
}
}
void printFields(PrintWriter pw, Map recurse, Object val) {
pw.print("(" + getClass().getName() + ")");
if (_super_descriptor != null) {
_super_descriptor.printFields(pw, recurse, val);
}
if (_fields == null)
return;
for (int i = 0; i < _fields.length; i++) {
if (i != 0) {
pw.print("; ");
}
_fields[i].print(pw, recurse, val);
}
}
protected void defaultReadValue(ObjectReader reader, Serializable value) throws IOException {
// System.out.println ("defaultReadValue "+getJavaClass());
if (_fields == null) {
// System.out.println ("fields == null for "+getJavaClass ());
return;
}
logger.fine("reading fields for " + type.getName());
for (FieldDescriptor _field : _fields) {
logger.fine("reading field " + _field.java_name + " of type " + _field.getType().getName() + " using " + _field.getClass().getName());
try {
_field.read(reader, value);
} catch (MARSHAL ex) {
if (ex.getMessage() != null)
throw ex;
String msg = String.format("%s, while reading %s.%s", ex, java_name, _field.java_name);
throw (MARSHAL) new MARSHAL(msg, ex.minor, ex.completed).initCause(ex);
}
}
}
Map readFields(ObjectReader reader) throws IOException {
if ((_fields == null) || (_fields.length == 0)) {
return Collections.EMPTY_MAP;
}
logger.finer("reading fields for " + type.getName());
Map map = new HashMap();
for (FieldDescriptor _field : _fields) {
logger.finer("reading field " + _field.java_name);
_field.readFieldIntoMap(reader, map);
}
return map;
}
void writeFields(ObjectWriter writer, Map fieldMap) throws IOException {
if ((_fields == null) || (_fields.length == 0)) {
return;
}
logger.finer("writing fields for " + type.getName());
for (FieldDescriptor _field : _fields) {
logger.finer("writing field " + _field.java_name);
_field.writeFieldFromMap(writer, fieldMap);
}
}
/**
* This methods reads the fields of a single class slice.
*/
protected void readValue(ObjectReader reader, Serializable value) throws IOException {
if (_is_externalizable) {
try {
reader.readExternal((Externalizable) value);
} catch (ClassNotFoundException e) {
throw new IOException("cannot instantiate class", e);
}
return;
}
if (_super_descriptor != null) {
_super_descriptor.readValue(reader, value);
}
// check whether the class (not its ancestors) does any custom marshalling
if (_write_object_method != null) {
// read custom marshalling value header
byte cmsfVersion = reader.readByte(); // custom marshal stream format version
boolean dwoCalled = reader.readBoolean(); // was defaultWriteObject() called?
logger.log(Level.FINE, "Reading value in streamFormatVersion=" + cmsfVersion + " defaultWriteObject=" + dwoCalled);
if (cmsfVersion == 2) {
// use a wrapped reader to open the secondary custom valuetype
ObjectReader wrapper = new CustomMarshaledObjectReader(reader);
readSerializable(_read_object_method == null ? reader : wrapper, value);
// invoke close to skip to the end of the secondary custom valuetype
wrapper.close();
return;
}
}
readSerializable(reader, value);
}
private void readSerializable(ObjectReader reader, Serializable value) throws IOException {
if (_read_object_method != null) {
try {
reader.setCurrentValueDescriptor(this);
_read_object_method.invoke(value, reader);
reader.setCurrentValueDescriptor(null);
} catch (IllegalAccessException | IllegalArgumentException ex) {
throw (MARSHAL) new MARSHAL(ex.getMessage()).initCause(ex);
} catch (InvocationTargetException ex) {
throw (UnknownException) new UnknownException(ex.getTargetException()).initCause(ex.getTargetException());
}
} else {
defaultReadValue(reader, value);
}
}
protected long computeHashCode() {
Class type = this.type;
if (_is_externalizable) {
return 1L;
}
if (!Serializable.class.isAssignableFrom(type)) {
return 0;
}
long hash = 0L;
try {
ByteArrayOutputStream barr = new ByteArrayOutputStream(512);
MessageDigest md = MessageDigest.getInstance("SHA");
DigestOutputStream digestout = new DigestOutputStream(barr, md);
DataOutputStream out = new DataOutputStream(digestout);
Class superType = type.getSuperclass();
if (superType != null) {
TypeDescriptor desc = repo.getDescriptor(superType);
out.writeLong(desc.getHashCode());
}
if (_write_object_method == null)
out.writeInt(1);
else
out.writeInt(2);
FieldDescriptor[] fds = new FieldDescriptor[_fields.length];
System.arraycopy(_fields, 0, fds, 0, _fields.length);
if (fds.length > 1)
Arrays.sort(fds, compareByName);
for (FieldDescriptor f : fds) {
out.writeUTF(f.java_name);
out.writeUTF(makeSignature(f.getType()));
}
/*
* Field[] fields = type.getDeclaredFields (); if (fields.length >
* 1) java.util.Arrays.sort (fields, compareByName); for(int i = 0;
* i < fields.length; i++) { Field f = fields[i]; int mod =
* f.getModifiers (); if (!Modifier.isTransient(mod) &&
* !Modifier.isStatic (mod)) { out.writeUTF(f.getName());
* out.writeUTF( makeSignature (f.getType ())); } }
*/
out.flush();
byte[] data = md.digest();
int end = Math.min(8, data.length);
for (int j = 0; j < end; j++) {
hash += (long) (data[j] & 0xff) << (j * 8);
}
} catch (Exception ex) {
throw new RuntimeException("cannot compute RMI hash code", ex);
}
return hash;
}
private static final Comparator compareByName = new Comparator() {
public int compare(Object f1, Object f2) {
String n1 = ((FieldDescriptor) f1).java_name;
String n2 = ((FieldDescriptor) f2).java_name;
return n1.compareTo(n2);
}
};
long getHashCode() {
return _hash_code;
}
private volatile ValueMember[] valueMembers = null;
protected ValueMember[] genValueMembers() {
final ValueMember[] members = new ValueMember[_fields.length];
for (int i = 0; i < _fields.length; i++) {
members[i] = _fields[i].getValueMember(repo);
}
return members;
}
final ValueMember[] getValueMembers() {
getTypeCode(); // ensure recursion through typecode
if (null == valueMembers) {
synchronized (repo) {
if (null == valueMembers) valueMembers = genValueMembers();
}
}
return valueMembers;
}
@Override
protected TypeCode genTypeCode() {
ORB orb = ORB.init();
setTypeCode(orb.create_recursive_tc(getRepositoryID()));
TypeCode _base = ((_super_descriptor == null) ? null : _super_descriptor.getTypeCode());
TypeCode tc;
if (type.isArray()) {
TypeDescriptor desc = repo.getDescriptor(type.getComponentType());
tc = desc.getTypeCode();
tc = orb.create_sequence_tc(0, tc);
tc = orb.create_value_box_tc(getRepositoryID(), "Sequence", tc);
} else {
tc = orb.create_value_tc(getRepositoryID(), type.getSimpleName(), VM_NONE.value, _base, getValueMembers());
}
return tc;
}
private static final OperationDescription[] ZERO_OPERATIONS = {};
private static final AttributeDescription[] ZERO_ATTRIBUTES = {};
private static final Initializer[] ZERO_INITIALIZERS = {};
private static final String[] ZERO_STRINGS = {};
FullValueDescription getFullValueDescription() {
FullValueDescription fvd = new FullValueDescription();
fvd.name = type.getName();
fvd.id = getRepositoryID();
fvd.is_abstract = false;
fvd.is_custom = isCustomMarshalled();
fvd.defined_in = "";
fvd.version = "1.0";
fvd.operations = ZERO_OPERATIONS;
fvd.attributes = ZERO_ATTRIBUTES;
fvd.members = getValueMembers();
fvd.initializers = ZERO_INITIALIZERS;
fvd.supported_interfaces = ZERO_STRINGS;
fvd.abstract_base_values = ZERO_STRINGS;
fvd.is_truncatable = false;
fvd.base_value = ((_super_descriptor == null) ? "" : _super_descriptor.getRepositoryID());
fvd.type = getTypeCode();
return fvd;
}
class ObjectDeserializer {
ObjectDeserializer super_descriptor;
String repository_id;
final FieldDescriptor[] fields;
ObjectDeserializer(ValueDescriptor desc) {
fields = desc._fields;
repository_id = desc.getRepositoryID();
if (desc._super_descriptor != null) {
super_descriptor = desc._super_descriptor._object_deserializer;
}
}
ObjectDeserializer(FullValueDescription desc, RunTime runtime) throws IOException {
Class myClass = type;
ValueMember[] members = desc.members;
fields = new FieldDescriptor[members.length];
for (int i = 0; i < members.length; i++) {
Class type = getClassFromTypeCode(members[i].type);
fields[i] = FieldDescriptor.get(myClass, type, members[i].name, null, repo);
}
if (!"".equals(desc.base_value)) {
Class clz = ValueHandlerImpl.getClassFromRepositoryID(desc.base_value);
TypeDescriptor tdesc = repo.getDescriptor(clz);
if ((tdesc instanceof ValueDescriptor)) {
super_descriptor = ((ValueDescriptor) tdesc).getObjectDeserializer(desc.base_value, runtime);
}
}
}
}
private ObjectDeserializer getObjectDeserializer(String repositoryID, RunTime runtime) throws IOException {
if (repositoryID.equals(getRepositoryID())) {
return _object_deserializer;
}
CodeBase codebase = CodeBaseHelper.narrow(runtime);
if (codebase == null) {
throw new IOException("cannot narrow RunTime -> CodeBase");
}
FullValueDescription desc = codebase.meta(repositoryID);
return new ObjectDeserializer(desc, codebase);
}
private static Class getClassFromTypeCode(TypeCode tc) {
return null;
}
public boolean copyWithinState() {
return !(_is_immutable_value | _is_rmi_stub);
}
Object copyObject(Object orig, CopyState state) {
if (_is_immutable_value || _is_rmi_stub) {
return orig;
}
Serializable oorig = (Serializable) orig;
logger.finer("copying " + orig);
oorig = writeReplace(oorig);
ValueDescriptor wdesc;
if (oorig == orig) {
wdesc = this;
} else {
wdesc = (ValueDescriptor) repo.getDescriptor(oorig.getClass());
logger.finer("writeReplace -> " + type.getName());
}
return wdesc.copyObject2(oorig, state);
}
/**
* this is called after write-replace on the type descriptor of the correct
* type for writing
*/
private Serializable copyObject2(Serializable oorig, CopyState state) {
// create instance of copied object, and register
Serializable copy = createBlankInstance();
state.put(oorig, copy);
// write original object
ObjectWriter writer = writeObject(oorig, state);
// read into copy
return readObject(writer, copy);
}
private ObjectWriter writeObject(Serializable oorig, CopyState state) {
try {
ObjectWriter writer = state.createObjectWriter(oorig);
writeValue(writer, oorig);
return writer;
} catch (IOException ex) {
String msg = String.format("%s writing %s", ex, type.getName());
throw (MARSHAL) new MARSHAL(msg).initCause(ex);
}
}
private Serializable readObject(ObjectWriter writer, Serializable copy) {
try {
ObjectReader reader = writer.getObjectReader(copy);
readValue(reader, copy);
return readResolve(copy);
} catch (IOException ex) {
String msg = String.format("%s reading instance of %s", ex, type.getName());
throw (MARSHAL) new MARSHAL(msg).initCause(ex);
}
}
void writeMarshalValue(PrintWriter pw, String outName, String paramName) {
pw.print(outName);
pw.print('.');
pw.print("write_value");
// this ValueDescriptor could represent an Abstract Value,
// in which case we need to cast the first argument.
// We'll just always do that, because most of the time
// HotSpot will remove this cast anyway.
pw.print("((java.io.Serializable)");
pw.print(paramName);
pw.print(',');
MethodDescriptor.writeJavaType(pw, type);
pw.print(".class)");
}
void writeUnmarshalValue(PrintWriter pw, String inName) {
pw.print(inName);
pw.print('.');
pw.print("read_value");
pw.print('(');
MethodDescriptor.writeJavaType(pw, type);
pw.print(".class)");
}
@Override
void addDependencies(Set<Class<?>> classes) {
Class c = type;
if ((c == Object.class) || classes.contains(c))
return;
classes.add(c);
if (c.getSuperclass() != null) {
TypeDescriptor desc = repo.getDescriptor(c.getSuperclass());
desc.addDependencies(classes);
}
Class[] ifaces = c.getInterfaces();
for (Class iface : ifaces) {
TypeDescriptor desc = repo.getDescriptor(iface);
desc.addDependencies(classes);
}
if (_fields != null) {
for (FieldDescriptor _field : _fields) {
if (_field.isPrimitive())
continue;
TypeDescriptor desc = repo.getDescriptor(_field.type);
desc.addDependencies(classes);
}
}
}
}
| 3,317 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/RMIStubInitializer.java | /**
*
* 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.yoko.rmi.impl;
class RMIStubInitializer implements org.apache.yoko.rmi.util.stub.StubInitializer {
public RMIStubInitializer() {
}
public Object getStubHandler() {
return RMIStubHandler.instance;
}
}
| 3,318 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ObjectWriter.java | /**
*
* 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.yoko.rmi.impl;
import java.io.Externalizable;
import java.io.IOException;
import java.io.NotActiveException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.apache.yoko.util.cmsf.CmsfThreadLocal;
import org.apache.yoko.util.yasf.Yasf;
import org.apache.yoko.util.yasf.YasfThreadLocal;
abstract class ObjectWriter extends ObjectOutputStream {
protected final Serializable object;
private ValueDescriptor _desc;
private PutFieldImpl _putFields;
private WriteObjectState state = WriteObjectState.NOT_IN_WRITE_OBJECT;
final byte cmsf;
final Set<Yasf> yasfSet;
private enum WriteObjectState {
NOT_IN_WRITE_OBJECT {
void beforeWriteObject(ObjectWriter writer) {
writer.state = IN_WRITE_OBJECT;
}
},
IN_WRITE_OBJECT {
void afterWriteObject(ObjectWriter writer) throws IOException {
writer.state = NOT_IN_WRITE_OBJECT;
// there is no custom (nor default) state written
writer.writeBoolean(false);
// If we're in stream format version 2, we must
// put the "null" marker to say that there isn't
// any optional data
if (writer.cmsf == 2) {
writer._nullValue();
}
}
void beforeDefaultWriteObject(ObjectWriter writer) throws IOException {
writer.state = IN_DEFAULT_WRITE_OBJECT;
writer.writeBoolean(true);
}
void beforeWriteData(ObjectWriter writer) throws IOException {
writer.state = WROTE_CUSTOM_DATA;
// writeDefaultObject was not invoked
writer.writeBoolean(false);
if (writer.cmsf == 2) {
writer._startValue(writer._desc.getCustomRepositoryID());
}
}
},
IN_DEFAULT_WRITE_OBJECT {
void afterDefaultWriteObject(ObjectWriter writer) {
writer.state = WROTE_DEFAULT_DATA;
}
},
WROTE_DEFAULT_DATA {
void afterWriteObject(ObjectWriter writer) throws IOException {
// the boolean identifying that default data was written has already
// been emitted in IN_WRITE_OBJECT.beforeWriteDefaultObject
writer.state = NOT_IN_WRITE_OBJECT;
// write a null-marker to identify that there is no custom
// state being marshalled...
if (writer.cmsf == 2) {
writer._nullValue();
}
}
void beforeWriteData(ObjectWriter writer) throws IOException {
// the boolean identifying that default data was written has already
// been emitted in IN_WRITE_OBJECT.beforeWriteDefaultObject
writer.state = WROTE_CUSTOM_DATA;
if (writer.cmsf == 2) {
writer._startValue(writer._desc.getCustomRepositoryID());
}
}
},
WROTE_CUSTOM_DATA {
void afterWriteObject(ObjectWriter writer) throws IOException {
if (writer.cmsf == 2) {
writer._endValue();
}
writer.state = NOT_IN_WRITE_OBJECT;
}
}
;
void beforeWriteObject(ObjectWriter writer) {
throw new IllegalStateException();
}
void afterWriteObject(ObjectWriter writer) throws IOException {
throw new IllegalStateException();
}
void beforeDefaultWriteObject(ObjectWriter writer) throws IOException {
throw new IllegalStateException();
}
void afterDefaultWriteObject(ObjectWriter writer) {
throw new IllegalStateException();
}
void beforeWriteData(ObjectWriter writer) throws IOException {
}
}
protected void beforeWriteData() throws IOException {
state.beforeWriteData(this);
}
ObjectWriter(Serializable obj) throws IOException {
object = obj;
cmsf = CmsfThreadLocal.get();
yasfSet = YasfThreadLocal.get();
}
abstract ObjectReader getObjectReader(Object newObject);
private void setCurrentValueDescriptor(ValueDescriptor desc) {
_desc = desc;
_putFields = null;
}
public final void defaultWriteObject() throws IOException {
if (_desc == null) {
throw new NotActiveException();
}
state.beforeDefaultWriteObject(this);
try {
_desc.defaultWriteValue(this, object);
} finally {
state.afterDefaultWriteObject(this);
}
}
public ObjectOutputStream.PutField putFields()
throws IOException {
if (_desc == null) {
throw new NotActiveException();
}
_putFields = new PutFieldImpl(_desc);
return _putFields;
}
public void writeFields() throws IOException {
if (_putFields == null) {
throw new NotActiveException("no current PutFields");
}
if (_putFields.slice != _desc) {
throw new NotActiveException(
"PutField cannot survive writeObject invocation");
}
state.beforeDefaultWriteObject(this);
try {
_putFields.write(this);
} finally {
state.afterDefaultWriteObject(this);
}
}
public void close() { /* skip */
}
public void flush() { /* skip */
}
public abstract void writeValueObject(Object obj) throws IOException;
public abstract void writeRemoteObject(Object obj) throws IOException;
public abstract void writeCorbaObject(Object obj) throws IOException;
public abstract void writeAny(Object obj) throws IOException;
static class PutFieldImpl extends PutField {
final ValueDescriptor slice;
final Map<String, Object> valueMap = new HashMap<>();
PutFieldImpl(ValueDescriptor slice) {
this.slice = slice;
}
@Override
public void put(String name, boolean val) {
valueMap.put(name, val);
}
@Override
public void put(String name, byte val) {
valueMap.put(name, val);
}
@Override
public void put(String name, char val) {
valueMap.put(name, val);
}
@Override
public void put(String name, double val) {
valueMap.put(name, val);
}
@Override
public void put(String name, float val) {
valueMap.put(name, val);
}
@Override
public void put(String name, int val) {
valueMap.put(name, val);
}
@Override
public void put(String name, long val) {
valueMap.put(name, val);
}
@Override
public void put(String name, Object val) {
valueMap.put(name, val);
}
@Override
public void put(String name, short val) {
valueMap.put(name, val);
}
@Override
public void write(ObjectOutput out) throws IOException {
slice.writeFields((ObjectWriter) out, valueMap);
}
}
void invokeWriteObject(ValueDescriptor descriptor, Serializable val,
Method _write_object_method) throws IllegalArgumentException,
IllegalAccessException, InvocationTargetException, IOException {
final ValueDescriptor desc = _desc;
final WriteObjectState old_state = state;
state = WriteObjectState.NOT_IN_WRITE_OBJECT;
try {
setCurrentValueDescriptor(descriptor);
writeByte(cmsf);
state.beforeWriteObject(this);
_write_object_method.invoke(val, this);
state.afterWriteObject(this);
} finally {
state = old_state;
setCurrentValueDescriptor(desc);
}
}
protected abstract void _startValue(String rep_id) throws IOException;
protected abstract void _endValue() throws IOException;
protected abstract void _nullValue() throws IOException;
void invokeWriteExternal(Externalizable externalizable) throws IOException {
writeByte(cmsf);
externalizable.writeExternal(this);
}
}
| 3,319 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/ArrayDescriptor.java | /**
*
* 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.yoko.rmi.impl;
import java.io.Externalizable;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.rmi.Remote;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import org.omg.CORBA.MARSHAL;
import org.omg.CORBA.ORB;
import org.omg.CORBA.TypeCode;
import org.omg.CORBA.ValueMember;
import org.omg.CORBA.portable.IndirectionException;
import org.omg.CORBA.portable.InputStream;
import org.omg.CORBA.portable.OutputStream;
abstract class ArrayDescriptor extends ValueDescriptor {
final Class elementType;
final Class basicType;
private final int order;
protected ArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, rep);
logger.fine("Creating an array descriptor for type " + type.getName() + " holding elements of " + elemType.getName());
this.elementType = elemType;
int order = 1;
Class basicType = elemType;
while (basicType.isArray()) {
basicType = basicType.getComponentType();
order++;
}
this.basicType = basicType;
this.order = order;
}
@Override
protected String genRepId() {
if (elementType.isPrimitive() || elementType == Object.class)
return String.format("RMI:%s:%016X", type.getName(), 0);
TypeDescriptor desc = repo.getDescriptor(elementType);
String elemRep = desc.getRepositoryID();
String hash = elemRep.substring(elemRep.indexOf(':', 4));
return String.format("RMI:%s:%s", type.getName(), hash);
}
// repository ID for the contained elements
private volatile String _elementRepid = null;
private final String genElemRepId() {
if (elementType.isPrimitive() || elementType == Object.class) {
// use the descriptor type past the array type marker
return String.format("RMI:%s:%016X", type.getName().substring(1), 0);
}
return repo.getDescriptor(elementType).getRepositoryID();
}
public String getElementRepositoryID() {
if (_elementRepid == null) _elementRepid = genElemRepId();
return _elementRepid;
}
@Override
protected final String genIDLName() {
StringBuffer sb = new StringBuffer("org_omg_boxedRMI_");
TypeDescriptor desc = repo.getDescriptor(basicType);
// The logic that looks for the last "_" fails when this is a
// long_long primitive type. The primitive types have a "" package
// name, so check those first. If it's not one of the primitives,
// then we can safely split using the last index position.
String pkgName = desc.getPackageName();
if (pkgName.length() == 0) {
sb.append("seq");
sb.append(order);
sb.append('_');
sb.append(desc.getTypeName());
}
else {
String elemName = desc.getIDLName();
int idx = elemName.lastIndexOf('_');
pkgName = elemName.substring(0, idx + 1);
String elmName = elemName.substring(idx + 1);
sb.append(pkgName);
sb.append("seq");
sb.append(order);
sb.append('_');
sb.append(elmName);
}
return sb.toString();
}
static ArrayDescriptor get(final Class type, TypeRepository rep) {
logger.fine("retrieving an array descriptor for class " + type.getName());
if (!type.isArray()) {
throw new IllegalArgumentException("type is not an array");
}
Class elemType = type.getComponentType();
if (elemType.isPrimitive()) {
if (elemType == Boolean.TYPE) {
return new BooleanArrayDescriptor(type, elemType, rep);
} else if (elemType == Byte.TYPE) {
return new ByteArrayDescriptor(type, elemType, rep);
} else if (elemType == Character.TYPE) {
return new CharArrayDescriptor(type, elemType, rep);
} else if (elemType == Short.TYPE) {
return new ShortArrayDescriptor(type, elemType, rep);
} else if (elemType == Integer.TYPE) {
return new IntArrayDescriptor(type, elemType, rep);
} else if (elemType == Long.TYPE) {
return new LongArrayDescriptor(type, elemType, rep);
} else if (elemType == Float.TYPE) {
return new FloatArrayDescriptor(type, elemType, rep);
} else if (elemType == Double.TYPE) {
return new DoubleArrayDescriptor(type, elemType, rep);
} else {
throw new RuntimeException("unknown array type " + type);
}
}
if (Serializable.class.equals(elemType) ||
Externalizable.class.equals(elemType) || Object.class.equals(elemType)) {
return new ObjectArrayDescriptor(type, elemType, rep);
} else if (Remote.class.isAssignableFrom(elemType)) {
return new RemoteArrayDescriptor(type, elemType, rep);
} else if (Serializable.class.isAssignableFrom(elemType)) {
return new ValueArrayDescriptor(type, elemType, rep);
} else {
return new AbstractObjectArrayDescriptor(type, elemType, rep);
}
}
/**
* Read an instance of this value from a CDR stream. Overridden to provide a
* specific type
*/
@Override
public Object read(InputStream in) {
org.omg.CORBA_2_3.portable.InputStream _in = (org.omg.CORBA_2_3.portable.InputStream) in;
logger.fine("Reading an array value with repository id " + getRepositoryID() + " java class is " + type);
// if we have a resolved class, read using that, otherwise fall back on the
// repository id.
return ((null == type) ? _in.read_value(getRepositoryID()) : _in.read_value(type));
}
/** Write an instance of this value to a CDR stream */
@Override
public void write(OutputStream out, Object value) {
org.omg.CORBA_2_3.portable.OutputStream _out = (org.omg.CORBA_2_3.portable.OutputStream) out;
_out.write_value((Serializable)value, getRepositoryID());
}
@Override
protected final ValueMember[] genValueMembers() {
final ValueMember[] members = new ValueMember[1];
final TypeDescriptor elemDesc = repo.getDescriptor(elementType);
final String elemRepID = elemDesc.getRepositoryID();
final ORB orb = ORB.init();
TypeCode memberTC = orb.create_sequence_tc(0, elemDesc.getTypeCode());
members[0] = new ValueMember("", // member has no name!
elemRepID, this.getRepositoryID(), "1.0", memberTC, null,
(short) 1);
return members;
}
@Override
void addDependencies(Set classes) {
repo.getDescriptor(basicType).addDependencies(classes);
}
final CorbaObjectReader makeCorbaObjectReader(final InputStream in, final Map offsetMap, final Serializable obj)
throws IOException {
try {
return AccessController.doPrivileged(new PrivilegedExceptionAction<CorbaObjectReader>() {
public CorbaObjectReader run() throws IOException {
return new CorbaObjectReader(in, offsetMap, obj);
}
});
} catch (PrivilegedActionException e) {
throw (IOException)e.getException();
}
}
}
class ObjectArrayDescriptor extends ArrayDescriptor {
static Logger logger = Logger.getLogger(ArrayDescriptor.class.getName());
ObjectArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public void writeValue(OutputStream out, Serializable value) {
// System.out.println ("ObjectArrayDescriptor::writeValue
// "+getRepositoryID ());
Object[] arr = (Object[]) value;
out.write_long(arr.length);
logger.finer("writing " + type.getName() + " size="
+ arr.length);
for (int i = 0; i < arr.length; i++) {
javax.rmi.CORBA.Util.writeAny(out, arr[i]);
}
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
try {
ObjectReader reader = makeCorbaObjectReader(in, offsetMap, null);
int length = reader.readInt();
Object[] arr = (Object[]) Array.newInstance(elementType, length);
offsetMap.put(key, arr);
logger.fine("reading " + type.getName() + " size="
+ arr.length);
for (int i = 0; i < length; i++) {
try {
arr[i] = reader.readAny();
if (arr[i] != null) {
logger.finer("Array item " + i + " is of type " + arr[i].getClass().getName());
}
else {
logger.finer("Array item " + i + " is null");
}
} catch (IndirectionException ex) {
arr[i] = offsetMap.get(new Integer(ex.offset));
// reader.addValueBox (ex.offset, new ArrayBox (i, arr));
}
}
return arr;
} catch (IOException ex) {
throw (MARSHAL)new MARSHAL(ex.getMessage()).initCause(ex);
}
}
@Override
Object copyObject(Object value, CopyState state) {
final Object[] orig = (Object[]) value;
final Object[] result = new Object[orig.length];
state.put(value, result);
for (int i = 0; i < orig.length; i++) {
try {
result[i] = state.copy(orig[i]);
} catch (CopyRecursionException e) {
final int idx = i;
state.registerRecursion(new CopyRecursionResolver(orig[i]) {
public void resolve(Object value) {
result[idx] = value;
}
});
}
}
return result;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
Object[] arr = (Object[]) val;
TypeDescriptor desc = repo.getDescriptor(elementType);
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
desc.print(pw, recurse, arr[i]);
}
}
}
class RemoteArrayDescriptor extends ArrayDescriptor {
RemoteArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
Object[] arr = (Object[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
javax.rmi.CORBA.Util.writeRemoteObject(out, arr[i]);
}
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
try {
ObjectReader reader = makeCorbaObjectReader(in, offsetMap, null);
int length = reader.readInt();
Object[] arr = (Object[]) Array.newInstance(elementType, length);
offsetMap.put(key, arr);
for (int i = 0; i < length; i++) {
try {
arr[i] = reader.readRemoteObject(elementType);
} catch (IndirectionException ex) {
arr[i] = offsetMap.get(new Integer(ex.offset));
// reader.addValueBox (ex.offset, new ArrayBox (i, arr));
}
}
return arr;
} catch (IOException ex) {
throw (MARSHAL)new MARSHAL(ex.getMessage()).initCause(ex);
}
}
@Override
Object copyObject(Object value, CopyState state) {
final Object[] orig = (Object[]) value;
final Object[] result = (Object[]) Array.newInstance(elementType,
orig.length);
state.put(value, result);
for (int i = 0; i < orig.length; i++) {
try {
result[i] = state.copy(orig[i]);
} catch (CopyRecursionException e) {
final int idx = i;
state.registerRecursion(new CopyRecursionResolver(orig[i]) {
public void resolve(Object value) {
result[idx] = value;
}
});
}
}
return result;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
Object[] arr = (Object[]) val;
TypeDescriptor desc = repo.getDescriptor(elementType);
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
desc.print(pw, recurse, arr[i]);
}
}
}
class ValueArrayDescriptor extends ArrayDescriptor {
ValueArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
Object[] arr = (Object[]) value;
out.write_long(arr.length);
Serializable[] sarr = (Serializable[]) arr;
org.omg.CORBA_2_3.portable.OutputStream _out = (org.omg.CORBA_2_3.portable.OutputStream) out;
for (int i = 0; i < sarr.length; i++) {
_out.write_value(sarr[i], getElementRepositoryID());
}
}
@Override
public Serializable readValue(InputStream in, Map offsetMap, Integer key) {
final int length = in.read_long();
Object[] arr = (Object[]) Array.newInstance(elementType, length);
offsetMap.put(key, arr);
final org.omg.CORBA_2_3.portable.InputStream _in = (org.omg.CORBA_2_3.portable.InputStream) in;
for (int i = 0; i < length; i++) {
try {
arr[i] = _in.read_value(elementType);
} catch (IndirectionException ex) {
arr[i] = offsetMap.get(new Integer(ex.offset));
}
}
return arr;
}
@Override
Object copyObject(Object value, CopyState state) {
Object[] orig = (Object[]) value;
final Object[] result = (Object[]) Array.newInstance(value.getClass()
.getComponentType(), orig.length);
state.put(value, result);
for (int i = 0; i < orig.length; i++) {
try {
result[i] = state.copy(orig[i]);
} catch (CopyRecursionException e) {
final int idx = i;
state.registerRecursion(new CopyRecursionResolver(orig[i]) {
public void resolve(Object value) {
result[idx] = value;
}
});
}
}
return result;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
Object[] arr = (Object[]) val;
TypeDescriptor desc = repo.getDescriptor(elementType);
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
desc.print(pw, recurse, arr[i]);
}
}
}
class AbstractObjectArrayDescriptor extends ArrayDescriptor {
AbstractObjectArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
Object[] arr = (Object[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
javax.rmi.CORBA.Util.writeAbstractObject(out, arr[i]);
}
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
try {
ObjectReader reader = makeCorbaObjectReader(in, offsetMap, null);
int length = reader.readInt();
Object[] arr = (Object[]) Array.newInstance(elementType, length);
offsetMap.put(key, arr);
for (int i = 0; i < length; i++) {
try {
arr[i] = reader.readAbstractObject();
} catch (IndirectionException ex) {
arr[i] = offsetMap.get(new Integer(ex.offset));
// reader.addValueBox (ex.offset, new ArrayBox (i, arr));
}
}
return arr;
} catch (IOException ex) {
throw (MARSHAL)new MARSHAL(ex.getMessage()).initCause(ex);
}
}
@Override
Object copyObject(Object value, CopyState state) {
final Object[] orig = (Object[]) value;
final Object[] result = (Object[]) Array.newInstance(elementType,
orig.length);
state.put(value, result);
for (int i = 0; i < orig.length; i++) {
try {
result[i] = state.copy(orig[i]);
} catch (CopyRecursionException e) {
final int idx = i;
state.registerRecursion(new CopyRecursionResolver(orig[i]) {
public void resolve(Object value) {
result[idx] = value;
}
});
}
}
return result;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
Object[] arr = (Object[]) val;
TypeDescriptor desc = repo.getDescriptor(elementType);
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
desc.print(pw, recurse, arr[i]);
}
}
}
class BooleanArrayDescriptor extends ArrayDescriptor {
BooleanArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
boolean[] arr = new boolean[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_boolean();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
boolean[] arr = (boolean[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_boolean(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((boolean[]) value).length == 0)
return value;
Object copy = ((boolean[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
boolean[] arr = (boolean[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class ByteArrayDescriptor extends ArrayDescriptor {
ByteArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
byte[] arr = new byte[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_octet();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
byte[] arr = (byte[]) value;
out.write_long(arr.length);
out.write_octet_array(arr, 0, arr.length);
}
@Override
Object copyObject(Object value, CopyState state) {
if (((byte[]) value).length == 0)
return value;
Object copy = ((byte[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
byte[] arr = (byte[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class CharArrayDescriptor extends ArrayDescriptor {
CharArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
int len = in.read_long();
char[] arr = new char[len];
offsetMap.put(key, arr);
in.read_wchar_array(arr, 0, len);
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
char[] arr = (char[]) value;
out.write_long(arr.length);
out.write_wchar_array(arr, 0, arr.length);
}
@Override
Object copyObject(Object value, CopyState state) {
if (((char[]) value).length == 0)
return value;
Object copy = ((char[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
char[] arr = (char[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class ShortArrayDescriptor extends ArrayDescriptor {
ShortArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
short[] arr = new short[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_short();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
short[] arr = (short[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_short(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((short[]) value).length == 0)
return value;
Object copy = ((short[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
short[] arr = (short[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class IntArrayDescriptor extends ArrayDescriptor {
IntArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
int[] arr = new int[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_long();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
int[] arr = (int[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_long(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((int[]) value).length == 0)
return value;
Object copy = ((int[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
int[] arr = (int[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class LongArrayDescriptor extends ArrayDescriptor {
LongArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
long[] arr = new long[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_longlong();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
long[] arr = (long[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_longlong(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((long[]) value).length == 0)
return value;
Object copy = ((long[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
long[] arr = (long[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class FloatArrayDescriptor extends ArrayDescriptor {
FloatArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
float[] arr = new float[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_float();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
float[] arr = (float[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_float(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((float[]) value).length == 0)
return value;
Object copy = ((float[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
float[] arr = (float[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
class DoubleArrayDescriptor extends ArrayDescriptor {
DoubleArrayDescriptor(Class type, Class elemType, TypeRepository rep) {
super(type, elemType, rep);
}
@Override
public Serializable readValue(
InputStream in, Map offsetMap,
Integer key) {
double[] arr = new double[in.read_long()];
offsetMap.put(key, arr);
for (int i = 0; i < arr.length; i++) {
arr[i] = in.read_double();
}
return arr;
}
@Override
public void writeValue(OutputStream out,
Serializable value) {
double[] arr = (double[]) value;
out.write_long(arr.length);
for (int i = 0; i < arr.length; i++) {
out.write_double(arr[i]);
}
}
@Override
Object copyObject(Object value, CopyState state) {
if (((double[]) value).length == 0)
return value;
Object copy = ((double[]) value).clone();
state.put(value, copy);
return copy;
}
@Override
void printFields(PrintWriter pw, Map recurse, Object val) {
double[] arr = (double[]) val;
pw.print("length=" + arr.length + "; ");
for (int i = 0; i < arr.length; i++) {
if (i != 0) {
pw.print(", ");
}
pw.print(arr[i]);
}
}
}
| 3,320 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/impl/BooleanDescriptor.java | /**
*
* 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.yoko.rmi.impl;
final class BooleanDescriptor extends SimpleDescriptor {
BooleanDescriptor(TypeRepository repository) {
super(Boolean.TYPE, repository, "boolean",
org.omg.CORBA.TCKind.tk_boolean);
}
public Object read(org.omg.CORBA.portable.InputStream in) {
return new Boolean(in.read_boolean());
}
public void write(org.omg.CORBA.portable.OutputStream out, Object val) {
out.write_boolean(((Boolean) val).booleanValue());
}
}
| 3,321 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/ByteString.java | /**
*
* 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.yoko.rmi.util;
public class ByteString implements Comparable, Cloneable {
private byte[] data;
private final int pos;
private final int len;
private String string;
private int hash;
public ByteString(byte[] data, int pos, int len) {
this.data = data;
this.pos = pos;
this.len = len;
if (len < 0 || pos + len > data.length || pos < 0) {
throw new IndexOutOfBoundsException("byte[" + data.length + "], "
+ pos + ", " + len);
}
}
public ByteString(byte[] data) {
this(data, 0, data.length);
}
public ByteString(String value) {
pos = 0;
len = value.length();
data = new byte[len];
for (int i = 0; i < len; i++) {
data[i] = (byte) value.charAt(i);
}
}
public char charAt(int i) {
return (char) byteAt(i);
}
public byte byteAt(int i) {
if (i < 0 || i >= len)
throw new IndexOutOfBoundsException("" + i);
return data[pos + i];
}
public int length() {
return len;
}
public Object clone() {
ByteString result = new ByteString(data, pos, len);
result.string = string;
result.hash = hash;
return result;
}
public int compareTo(Object o) {
ByteString other = (ByteString) o;
int min = (len < other.len) ? len : other.len;
for (int i = 0; i < min; i++) {
byte me = data[pos + i];
byte him = other.data[other.pos + i];
if (me < him)
return -1;
else if (me > him)
return +1;
}
return (len - other.len);
}
public ByteString substring(int index) {
if (index < 0 || index > len)
throw new IndexOutOfBoundsException("" + index);
return new ByteString(data, pos + index, len - index);
}
public ByteString substring(int index, int endindex) {
if (index < 0 || endindex > len)
throw new IndexOutOfBoundsException("" + index);
ByteString result = new ByteString(data, pos + index, endindex - index);
// System.out.println ("substring "+this+" ("+index+","+endindex+") =>
// "+result);
return result;
}
public int indexOf(char ch) {
return indexOf(ch, 0);
}
public int indexOf(char ch, int index) {
return indexOf((byte) ch, index);
}
public int indexOf(byte by, int index) {
int start = pos + index;
int end = start + len;
if (index < 0 || index >= len)
return -1;
for (int i = start; i < end; i++) {
if (data[i] == by)
return (i - pos);
}
return -1;
}
public int lastIndexOf(char ch) {
return lastIndexOf(ch, len - 1);
}
public int lastIndexOf(char ch, int index) {
return lastIndexOf((byte) ch, index);
}
public int lastIndexOf(byte by, int index) {
int start = pos + index;
int end = pos;
if (start >= pos + len)
return -1;
for (int i = start; i >= end; i--) {
if (data[i] == by) {
return (i - pos);
}
}
return -1;
}
public boolean startsWith(ByteString prefix) {
if (prefix.len > len)
return false;
for (int i = 0; i < prefix.len; i++) {
if (byteAt(i) != prefix.byteAt(i))
return false;
}
return true;
}
public boolean startsWithIgnoreCase(ByteString prefix) {
if (prefix.len > len)
return false;
for (int i = 0; i < prefix.len; i++) {
byte b1 = byteAt(i);
byte b2 = prefix.byteAt(i);
if (b1 == b2)
continue;
if (toLowerCase(b1) != toLowerCase(b2))
return false;
}
return true;
}
public boolean startsWithIgnoreCase(String prefix) {
if (prefix.length() > len)
return false;
for (int i = 0; i < prefix.length(); i++) {
if (toLowerCase(byteAt(i)) != toLowerCase((byte) prefix.charAt(i)))
return false;
}
return true;
}
public boolean endsWith(ByteString postfix) {
if (postfix.len > len)
return false;
for (int i = 0; i < postfix.len; i++) {
if (byteAt(i) != postfix.byteAt(i))
return false;
}
return true;
}
public boolean startsWith(String prefix) {
if (prefix.length() > len)
return false;
for (int i = 0; i < prefix.length(); i++) {
if (charAt(i) != prefix.charAt(i))
return false;
}
return true;
}
public boolean endsWith(String postfix) {
if (postfix.length() > len)
return false;
for (int i = 0; i < postfix.length(); i++) {
if (charAt(i) != postfix.charAt(i))
return false;
}
return true;
}
private static byte toUpperCase(byte ch) {
if (ch >= (byte) 'a' && ch <= (byte) 'z') {
return (byte) ((int) ch - (int) 'a' + (int) 'A');
} else if (ch >= (byte) 0xe0 && ch <= (byte) 0xfe && ch != (byte) 0xf7) {
return (byte) ((int) ch - 0xe0 + 0xc0);
} else {
return ch;
}
}
private static byte toLowerCase(byte ch) {
if (ch >= (byte) 'A' && ch <= (byte) 'Z') {
return (byte) ((int) ch - (int) 'A' + (int) 'a');
} else if (ch >= (byte) 0xc0 && ch <= (byte) 0xde && ch != (byte) 0xd7) {
return (byte) ((int) ch - 0xc0 + 0xe0);
} else {
return ch;
}
}
public ByteString toUpperCase(boolean overwrite) {
if (overwrite == false) {
return toUpperCase();
}
for (int i = 0; i < len; i++) {
data[pos + i] = toUpperCase(data[pos + i]);
}
return this;
}
public ByteString toUpperCase() {
boolean didChange = false;
byte[] up = null;
for (int i = 0; i < len; i++) {
byte ch = data[pos + i];
byte newCh = toUpperCase(ch);
if (ch != newCh) {
if (didChange == false) {
up = new byte[len];
didChange = true;
for (int j = 0; j < i; j++) {
up[j] = data[pos + j];
}
}
}
if (didChange)
up[i] = newCh;
}
if (didChange) {
return new ByteString(up, 0, len);
} else {
return this;
}
}
public int hashCode() {
int h = hash;
if (h == 0) {
int off = pos;
byte val[] = data;
for (int i = 0; i < len; i++)
h = 31 * h + val[off++];
hash = h;
}
return h;
}
public int lowerCaseHashCode() {
int h = 0;
int off = pos;
byte val[] = data;
for (int i = 0; i < len; i++)
h = 31 * h + toLowerCase(val[off++]);
hash = h;
return h;
}
public boolean equals(ByteString bs) {
if (bs == null)
return false;
if (len != bs.len)
return false;
for (int i = 0; i < len; i++) {
if (data[pos + i] != bs.data[bs.pos + i])
return false;
}
return true;
}
public boolean equals(Object other) {
if (this == other)
return true;
if (other == null)
return false;
if (!(other instanceof ByteString)) {
if (other instanceof String) {
return toString().equals(other);
} else {
return false;
}
}
return equals((ByteString) other);
}
public boolean equalsIgnoreCase(Object other) {
if (other instanceof ByteString)
return equalsIgnoreCase((ByteString) other);
if (this == other)
return true;
if (other == null)
return false;
if (other instanceof String) {
return equalsIgnoreCase((String) other);
} else {
return false;
}
}
public boolean equalsIgnoreCase(ByteString bs) {
if (bs == null)
return false;
if (len != bs.len)
return false;
for (int i = 0; i < len; i++) {
if (toLowerCase(data[pos + i]) != toLowerCase(bs.data[bs.pos + i]))
return false;
}
return true;
}
public boolean equalsIgnoreCase(String s) {
if (len != s.length())
return false;
for (int i = 0; i < len; i++) {
char c1 = (char) toLowerCase(byteAt(i));
char c2 = s.charAt(i);
if (c1 == c2)
continue;
if (c1 != Character.toLowerCase(c2))
return false;
}
return true;
}
public static boolean isSpace(byte value) {
return value == ' ' || value == '\t' || value == '\n' || value == '\r';
}
public ByteString trim() {
int newStart = pos;
int newEnd = pos + len;
while (newStart < newEnd && isSpace(data[newStart]))
newStart++;
while (newStart < newEnd && isSpace(data[newEnd - 1]))
newEnd--;
int newLen = (newEnd - newStart);
if (newLen == len)
return this;
else
return new ByteString(data, newStart, newLen);
}
public String toString() {
if (string == null) {
char[] chars = new char[len];
for (int i = 0; i < len; i++) {
chars[i] = (char) data[pos + i];
}
string = new String(chars);
}
return string;
}
public ByteString[] split(char c) {
java.util.ArrayList list = new java.util.ArrayList();
int start = 0;
for (int pos = 0; pos < len; pos++) {
if (charAt(pos) == c) {
list.add(substring(start, pos));
start = pos + 1;
}
}
if (start == 0) {
return new ByteString[] { this };
} else {
list.add(substring(start, len));
ByteString[] bsa = new ByteString[list.size()];
list.toArray(bsa);
return bsa;
}
}
public void copyInto(byte[] data, int off) {
for (int i = 0; i < len; i++) {
data[i + off] = byteAt(i);
}
}
byte[] getData() {
return data;
}
protected void setData(byte[] data) {
this.data = data;
}
int getOffset() {
return pos;
}
public int parseInt(int start) {
int off = this.pos + start;
int pos = off;
int value = 0;
// skip blanks...
while (data[pos] == (byte) ' ' || data[pos] == (byte) '\t')
pos += 1;
while (pos < off + len) {
byte ch = data[pos++];
if (ch >= (byte) '0' && ch <= (byte) '9') {
int digit = (int) ch - (int) '0';
value = (value * 10) + digit;
} else {
break;
}
}
return value;
}
}
| 3,322 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/StringUtil.java | /**
*
* 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.yoko.rmi.util;
import java.util.ArrayList;
/**
*
* @author Jeppe Sommer (jso@eos.dk)
* @author Kim Harding Christensen (khc@eos.dk)
*/
public class StringUtil {
public static String capitalize(String str) {
StringBuffer sb = new StringBuffer(str);
sb.setCharAt(0, Character.toUpperCase(str.charAt(0)));
return sb.toString();
}
public static String join(String[] strings, String delimiter) {
StringBuffer sb = new StringBuffer();
for (int n = 0; n < strings.length; n++) {
sb.append(strings[n]);
if (n < strings.length - 1) {
sb.append(delimiter);
}
}
return sb.toString();
}
public static String[] split(String str, char splitChar) {
ArrayList al = new ArrayList(8);
int i = -1;
String s;
String rest = str;
while ((i = rest.indexOf(splitChar)) != -1) {
s = rest.substring(0, i);
al.add(s);
rest = rest.substring(i + 1);
}
al.add(rest);
String[] result = new String[al.size()];
al.toArray(result);
return result;
}
public static String replace(String str, String oldStr, String newStr) {
int prevIndex = 0, nextIndex;
StringBuffer result = new StringBuffer();
while ((nextIndex = str.indexOf(oldStr, prevIndex)) != -1) {
result.append(str.substring(prevIndex, nextIndex));
result.append(newStr);
prevIndex = nextIndex + oldStr.length();
}
result.append(str.substring(prevIndex));
return result.toString();
}
public static final byte[] HEX_CHARS = {
(byte)'0',
(byte)'1',
(byte)'2',
(byte)'3',
(byte)'4',
(byte)'5',
(byte)'6',
(byte)'7',
(byte)'8',
(byte)'9',
(byte)'A',
(byte)'B',
(byte)'C',
(byte)'D',
(byte)'E',
(byte)'F',
};
public static final byte[] VALID_IDL_CHARS = {
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0,
1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0,
0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,1,
0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
0,1,1,1, 1,1,1,0, 1,1,1,1, 1,0,0,1,
1,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
0,1,1,1, 1,1,1,0, 1,1,1,1, 1,0,0,1,
};
public static String convertToValidIDLNames(String str) {
int length = str.length();
if (length == 0) {
return str;
}
StringBuilder builder = new StringBuilder();
for (char c : str.toCharArray()) {
if (c > 255 || VALID_IDL_CHARS[c] == 0) {
builder.append("\\U" +
(char)HEX_CHARS[(c & 0xF000) >>> 12] +
(char)HEX_CHARS[(c & 0x0F00) >>> 8] +
(char)HEX_CHARS[(c & 0x00F0) >>> 4] +
(char)HEX_CHARS[(c & 0x000F)] );
} else {
builder.append(c);
}
}
if (builder.length() > 0) {
str = builder.toString();
}
return str;
}
}
| 3,323 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/Queue.java | /**
*
* 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.yoko.rmi.util;
/**
*
*
* @author Kim Harding Christensen (khc@eos.dk)
**/
public interface Queue {
void enqueue(Object o);
Object dequeue();
int size();
void clear ();
Object[] toArray (Object[] result);
void push(Object o);
}
| 3,324 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/StreamUtil.java | /**
*
* 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.yoko.rmi.util;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author Jeppe Sommer (jso@eos.dk)
*/
public class StreamUtil {
final static Logger logger = Logger.getLogger(StreamUtil.class.getName());
static final int BUF_SIZE = 4096;
public static void copyStream(InputStream is, OutputStream os)
throws IOException {
byte[] buf = new byte[BUF_SIZE];
if (logger.isLoggable(Level.FINER)) {
logger.finer("copyStream(" + is + ", " + os);
}
try {
int count;
while ((count = is.read(buf)) != -1) {
// log.debug("copyStream, copying " + count + " bytes");
os.write(buf, 0, count);
}
} finally {
}
}
public static void copyStream(Reader reader, Writer writer)
throws IOException {
char[] buf = new char[BUF_SIZE];
if (logger.isLoggable(Level.FINER)) {
logger.finer("copyStream(" + reader + ", " + writer);
}
try {
int count;
while ((count = reader.read(buf)) != -1) {
// log.debug("copyStream, copying " + count + " bytes");
writer.write(buf, 0, count);
}
} finally {
}
}
}
| 3,325 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/PriorityQueue.java | /**
*
* 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.yoko.rmi.util;
import java.util.Comparator;
/**
*
* @author Kresten Krab Thorup
*/
public class PriorityQueue implements org.apache.yoko.rmi.util.Queue
{
/** the default queue size is 4 */
public static final int DEFAULT_QUEUE_SIZE = 4;
Comparator cmp;
int elem_count = 0;
int elem_max;
Object[] elem_data;
/** Construct a new <code>PriorityQueue</code> (primary constructor) */
public PriorityQueue (int size, Comparator cmp)
{
if (size < 4)
elem_max = 4;
else
elem_max = size;
elem_count = 0;
elem_data = new Object[elem_max+2];
this.cmp = cmp;
}
public PriorityQueue (int size)
{
this (size, new ComparableComparator() );
}
public PriorityQueue ()
{
this (DEFAULT_QUEUE_SIZE, new ComparableComparator());
}
public PriorityQueue (Comparator cmp)
{
this (DEFAULT_QUEUE_SIZE, cmp);
}
public int size ()
{
return elem_count;
}
public Object[] toArray (Object[] result)
{
if (result.length < size ()) {
Class elementClass = result.getClass ().getComponentType ();
result = (Object[])
java.lang.reflect.Array.newInstance
(elementClass, size ());
}
int count = elem_count;
for (int i = 0; i < count; i++) {
result[i] = dequeue ();
}
return result;
}
public void clear ()
{
elem_count = 0;
}
public Object dequeue ()
{
if (elem_count == 0)
return null;
Object result = elem_data[1];
elem_data[1] = elem_data[elem_count];
elem_count -= 1;
sift_down (1);
return result;
}
private void sift_down (int i)
{
final int top_idx = i;
final int left_idx = i*2;
final int right_idx = left_idx+1;
if (elem_count < left_idx) {
return;
}
// the left one is the last
else if (elem_count == left_idx) {
Object top = elem_data[top_idx];
Object left = elem_data[left_idx];
if (cmp.compare (left, top) < 0) {
elem_data[top_idx] = left;
elem_data[left_idx] = top;
}
return;
}
// there are more...
else
{
Object top = elem_data[top_idx];
Object left = elem_data[left_idx];
Object right = elem_data[right_idx];
if (cmp.compare (left, right) < 0) {
// left is now the smaller
if (cmp.compare (left, top) < 0)
{
elem_data[top_idx] = left;
elem_data[left_idx] = top;
sift_down (left_idx);
}
}
else if (cmp.compare (right, top) < 0) {
// the right one is the smaller
elem_data[top_idx] = right;
elem_data[right_idx] = top;
sift_down (right_idx);
}
}
}
public void enqueue (Object o)
{
// make room
if (elem_max == elem_count)
{
int new_max = elem_max * 2;
Object[] new_data = new Object[new_max + 2];
System.arraycopy (elem_data, 0, new_data, 0, elem_max+2);
elem_max = new_max;
elem_data = new_data;
}
elem_count += 1;
elem_data[elem_count] = o;
sift_up (elem_count);
}
private void sift_up (int idx)
{
if (idx == 1)
return;
Object me = elem_data[idx];
Object top = elem_data[idx/2];
if (cmp.compare (me, top) < 0)
{
elem_data[idx] = top;
elem_data[idx/2] = me;
sift_up (idx/2);
}
}
public void push(Object o) {
enqueue(o);
}
}
class ComparableComparator implements Comparator
{
public int compare (Object o1, Object o2)
{
return ((Comparable)o1).compareTo ((Comparable)o2);
}
}
| 3,326 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/ByteBuffer.java | /**
*
* 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.yoko.rmi.util;
public class ByteBuffer {
byte[] contents;
int pos = 0;
public ByteBuffer(int size) {
contents = new byte[size];
}
public ByteBuffer() {
this(48);
}
public void append(byte b) {
ensure(1);
contents[pos++] = b;
}
public void append(char c) {
ensure(1);
contents[pos++] = (byte) c;
}
static final char[] integerData = new char[] { '0', '1', '2', '3', '4',
'5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
public void append(int v, int radix) {
if (v > radix) {
append(v / radix, radix);
}
append(integerData[v % radix]);
}
public void append(int v) {
append(v, 10);
}
public void append(String value) {
int len = value.length();
ensure(len);
for (int i = 0; i < len; i++) {
contents[pos++] = (byte) value.charAt(i);
}
}
public void append(byte[] b) {
append(b, 0, b.length);
}
public void append(ByteString b) {
append(b.getData(), b.getOffset(), b.length());
}
public void append(byte[] b, int off, int len) {
if (b.length == 0 || len == 0)
return;
ensure(len);
System.arraycopy(b, off, contents, pos, len);
pos += len;
}
public byte[] toByteArray() {
byte[] barr = new byte[pos];
System.arraycopy(contents, 0, barr, 0, pos);
return barr;
}
public ByteString toByteString() {
return new ByteString(contents, 0, pos);
}
public String toString() {
return toByteString().toString();
}
private void ensure(int size) {
if (pos + size > contents.length) {
grow(pos + size);
}
}
private void grow(int minimumSize) {
int newSize = minimumSize > (contents.length * 2) ? minimumSize
: (contents.length * 2);
byte[] barr = new byte[newSize];
System.arraycopy(contents, 0, barr, 0, contents.length);
contents = barr;
}
public void writeTo(java.io.OutputStream out) throws java.io.IOException {
writeFully(out, contents, 0, pos);
}
private void writeFully(java.io.OutputStream os, byte[] data, int off,
int len) throws java.io.IOException {
while (len > 0) {
int bytes = len;
try {
os.write(data, off, len);
} catch (java.io.InterruptedIOException ex) {
bytes = ex.bytesTransferred;
}
off += bytes;
len -= bytes;
}
}
public byte[] getContents() {
return contents;
}
}
| 3,327 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/Key.java | package org.apache.yoko.rmi.util;
interface Key<T> {
T get();
}
| 3,328 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/ClientUtil.java | /**
*
* 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.yoko.rmi.util;
public class ClientUtil {
public static boolean isRunningAsClientContainer() {
return ClientUtil.runningAsClientContainer;
}
public static void setRunningAsClientContainer(boolean flag) {
ClientUtil.runningAsClientContainer = flag;
}
static boolean runningAsClientContainer = false;
}
| 3,329 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/GetSystemPropertyAction.java | /*
* 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.yoko.rmi.util;
import java.security.PrivilegedAction;
/**
* Simple utility class for retrieving a system property
* value using the AccessController.
*/
public class GetSystemPropertyAction implements PrivilegedAction<String> {
// property name to retrieve
String name;
// potential default value
String defaultValue = null;
/**
* Retrive a value using the name with no default value.
*
* @param name The property name.
*/
public GetSystemPropertyAction(String name) {
this.name = name;
this.defaultValue = null;
}
/**
* Retrieve a property using a name and a specified default value.
*
* @param name The property name.
* @param defaultValue
* The default value if the property has not been set.
*/
public GetSystemPropertyAction(String name, String defaultValue) {
this.name = name;
this.defaultValue = defaultValue;
}
/**
* Perform the AccessController action of retrieving the system property.
*
* @return The retrieved property. Returns either null or the
* specified default value if this has not been set.
*/
public String run() {
if (defaultValue == null) {
return System.getProperty(name);
}
else {
return System.getProperty(name, defaultValue);
}
}
}
| 3,330 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/SearchKey.java | package org.apache.yoko.rmi.util;
public class SearchKey<T> implements Key<T> {
private final T value;
private final int hash;
public SearchKey(T value) {
this.value = value;
hash = value.hashCode();
}
@Override
public T get() {
return value;
}
@Override
public int hashCode() {
return hash;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!!!(o instanceof Key)) return false;
return value.equals(((Key)o).get());
}
}
| 3,331 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/NodeleteSynchronizedMap.java | /**
*
* 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.yoko.rmi.util;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
public class NodeleteSynchronizedMap implements Map {
Map global;
ThreadLocal local = new ThreadLocal() {
public Object initialValue() {
return NodeleteSynchronizedMap.this.initialValue();
}
};
public NodeleteSynchronizedMap() {
global = Collections.synchronizedMap(initialValue());
}
private Map localMap() {
return (Map) local.get();
}
public int size() {
return global.size();
}
public boolean isEmpty() {
return global.isEmpty();
}
public boolean containsKey(java.lang.Object key) {
Map local = localMap();
if (local.containsKey(key)) {
return true;
}
if (global.containsKey(key)) {
local.put(key, global.get(key));
return true;
} else {
return false;
}
}
public boolean containsValue(java.lang.Object val) {
Map local = localMap();
if (local.containsValue(val)) {
return true;
}
return global.containsValue(val);
}
public java.lang.Object get(java.lang.Object key) {
Map local = localMap();
Object val = local.get(key);
if (val != null)
return val;
if (local.containsKey(key)) {
return null;
}
val = global.get(key);
if (val != null) {
local.put(key, val);
}
return val;
}
public boolean equals(java.lang.Object other) {
return global.equals(other);
}
public int hashCode() {
return global.hashCode();
}
public java.util.Set keySet() {
return global.keySet();
}
public java.util.Collection values() {
return global.values();
}
public java.util.Set entrySet() {
return global.entrySet();
}
public java.lang.Object put(java.lang.Object key, java.lang.Object val) {
return global.put(key, val);
}
public java.lang.Object remove(java.lang.Object key) {
throw new UnsupportedOperationException();
}
public void putAll(java.util.Map other) {
global.putAll(other);
}
public void clear() {
throw new UnsupportedOperationException();
}
public Map initialValue() {
return new HashMap();
}
}
| 3,332 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/ClassLoaderLocal.java | /**
*
* 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.yoko.rmi.util;
import java.lang.reflect.Field;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.HashMap;
import java.util.Vector;
import java.util.WeakHashMap;
public class ClassLoaderLocal {
private Object key = new Object();
private static class ClassLocalMap extends HashMap {
ClassLocalMap() {
}
}
private static final ClassLocalMap globalMap = new ClassLocalMap();
private String name;
public ClassLoaderLocal() {
this("<anonymous>");
}
public ClassLoaderLocal(String name) {
this.name = name;
}
public Object initialValue() {
return null;
}
public void set(Object o) {
ClassLocalMap map = getLoaderLocalMap();
synchronized (map) {
map.put(key, o);
}
}
public void setGlobal(Object o) {
synchronized (globalMap) {
globalMap.put(key, o);
}
}
public Object getGlobal() {
return getOrCreate(globalMap);
}
public Object get() {
return getOrCreate(getLoaderLocalMap());
}
private Object getOrCreate(ClassLocalMap globalMap) {
synchronized (globalMap) {
if (globalMap.containsKey(key)) {
return globalMap.get(key);
} else {
Object init = initialValue();
globalMap.put(key, init);
return init;
}
}
}
// table for tracking the CL to map relationships. We're
// using a WeakHashMap to prevent us pinning class loaders.
static final private WeakHashMap localMaps = new WeakHashMap();
private ClassLocalMap getLoaderLocalMap() {
ClassLoader cl = Thread.currentThread().getContextClassLoader();
ClassLocalMap map;
if (cl == null) {
map = globalMap;
} else {
synchronized (localMaps) {
// create a local map and store in our tracking table.
map = (ClassLocalMap)localMaps.get(cl);
if (map == null) {
map = new ClassLocalMap();
localMaps.put(cl, map);
}
}
}
return map;
}
}
| 3,333 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/WeakKey.java | package org.apache.yoko.rmi.util;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
public class WeakKey<T> extends WeakReference<T> implements Key<T> {
private final int hash;
public WeakKey(T r, ReferenceQueue<T> q) {
super(r, q);
hash = r.hashCode();
}
@Override
public int hashCode() {
return hash;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!!!(o instanceof Key)) return false;
final Object otherKey = ((Key<?>)o).get();
if (null == otherKey) return false;
return otherKey.equals(get());
}
}
| 3,334 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/corba/Field.java | /**
*
* 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.yoko.rmi.util.corba;
import java.lang.reflect.Modifier;
import java.util.logging.Level;
import java.util.logging.Logger;
import sun.misc.Unsafe;
public class Field {
final long fieldID;
// static final Category log = Category.getInstance(Field.class);
static final Unsafe unsafe = getUnsafe();
static final Logger logger = Logger.getLogger(Field.class
.getName());
private static Unsafe getUnsafe() {
Unsafe unsafe = null;
try {
Class uc = Unsafe.class;
java.lang.reflect.Field[] fields = uc.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
if (fields[i].getName().equals("theUnsafe")) {
fields[i].setAccessible(true);
unsafe = (Unsafe) fields[i].get(uc);
break;
}
}
} catch (Exception ignore) {
logger.log(Level.FINE, "exception getting unsafe", ignore);
}
return unsafe;
}
public Field(java.lang.reflect.Field f) {
if (Modifier.isStatic(f.getModifiers()))
fieldID = unsafe.staticFieldOffset(f);
else
fieldID = unsafe.objectFieldOffset(f);
}
public void set(Object obj, Object val) throws IllegalArgumentException,
IllegalAccessException {
unsafe.putObject(obj, fieldID, val);
}
public void setByte(Object obj, byte val) throws IllegalArgumentException,
IllegalAccessException {
unsafe.putByte(obj, fieldID, val);
}
public void setBoolean(Object obj, boolean val)
throws IllegalArgumentException, IllegalAccessException {
unsafe.putBoolean(obj, fieldID, val);
}
public void setShort(Object obj, short val)
throws IllegalArgumentException, IllegalAccessException {
unsafe.putShort(obj, fieldID, val);
}
public void setChar(Object obj, char val) throws IllegalArgumentException,
IllegalAccessException {
unsafe.putChar(obj, fieldID, val);
}
public void setInt(Object obj, int val) throws IllegalArgumentException,
IllegalAccessException {
unsafe.putInt(obj, fieldID, val);
}
public void setLong(Object obj, long val) throws IllegalArgumentException,
IllegalAccessException {
unsafe.putLong(obj, fieldID, val);
}
public void setFloat(Object obj, float val)
throws IllegalArgumentException, IllegalAccessException {
unsafe.putFloat(obj, fieldID, val);
}
public void setDouble(Object obj, double val)
throws IllegalArgumentException, IllegalAccessException {
unsafe.putDouble(obj, fieldID, val);
}
public Object get(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getObject(obj, fieldID);
}
public byte getByte(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getByte(obj, fieldID);
}
public boolean getBoolean(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getBoolean(obj, fieldID);
}
public short getShort(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getShort(obj, fieldID);
}
public char getChar(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getChar(obj, fieldID);
}
public int getInt(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getInt(obj, fieldID);
}
public long getLong(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getLong(obj, fieldID);
}
public float getFloat(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getFloat(obj, fieldID);
}
public double getDouble(Object obj) throws IllegalArgumentException,
IllegalAccessException {
return unsafe.getDouble(obj, fieldID);
}
}
| 3,335 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/corba/POAObject.java | /**
*
* 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.yoko.rmi.util.corba;
import org.omg.PortableServer.POA;
import org.omg.PortableServer.Servant;
public class POAObject extends org.omg.CORBA_2_3.portable.ObjectImpl {
private Servant servant;
protected POA poa;
// non-null if object is exported
protected byte[] id;
protected POAObject(Servant servant, POA poa) {
this.servant = servant;
this.poa = poa;
if (servant == null || poa == null) {
throw new IllegalArgumentException();
}
}
public String[] _ids() {
return servant._all_interfaces(poa, null);
}
public org.omg.CORBA.portable.Delegate _get_delegate() {
try {
return super._get_delegate();
} catch (org.omg.CORBA.BAD_OPERATION ex) {
//
}
synchronized (this) {
try {
return super._get_delegate();
} catch (org.omg.CORBA.BAD_OPERATION ex) {
//
}
org.omg.CORBA.portable.ObjectImpl ref = export();
org.omg.CORBA.portable.Delegate delegate = ref._get_delegate();
this._set_delegate(delegate);
return delegate;
}
}
private org.omg.CORBA.portable.ObjectImpl export() {
try {
if (id != null) {
throw new Error("Internal consistency error!");
}
id = poa.activate_object(servant);
return (org.omg.CORBA.portable.ObjectImpl) poa.id_to_reference(id);
} catch (org.omg.PortableServer.POAPackage.ServantAlreadyActive ex) {
throw new Error(ex.getMessage(), ex);
} catch (org.omg.PortableServer.POAPackage.ObjectNotActive ex) {
throw new Error(ex.getMessage(), ex);
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw new Error(ex.getMessage(), ex);
}
}
public synchronized void unexport() {
if (id == null) {
return;
}
try {
poa.deactivate_object(id);
id = null;
} catch (org.omg.PortableServer.POAPackage.ObjectNotActive ex) {
throw (org.omg.CORBA.INTERNAL)new
org.omg.CORBA.INTERNAL("ObjectNotActive::" + ex.getMessage()).initCause(ex);
} catch (org.omg.PortableServer.POAPackage.WrongPolicy ex) {
throw (org.omg.CORBA.INTERNAL)new
org.omg.CORBA.INTERNAL("WrongPolicy::" + ex.getMessage()).initCause(ex);
}
}
}
| 3,336 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/Util.java | /**
*
* 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.yoko.rmi.util.stub;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.security.AccessController;
import java.security.CodeSource;
import java.security.PrivilegedAction;
import java.security.SecureClassLoader;
import java.security.cert.Certificate;
class Util {
static String getPackageName(Class clazz) {
String class_name = clazz.getName();
int idx = class_name.lastIndexOf('.');
if (idx == -1) {
return null;
} else {
return class_name.substring(0, idx);
}
}
static String getClassName(Class clazz) {
String class_name = clazz.getName();
int idx = class_name.lastIndexOf('.');
if (idx == -1) {
return class_name;
} else {
return class_name.substring(idx + 1);
}
}
static private java.lang.reflect.Method defineClassMethod;
static {
try {
// get the method object
defineClassMethod = (SecureClassLoader.class).getDeclaredMethod(
"defineClass", new Class[] { String.class, byte[].class,
Integer.TYPE, Integer.TYPE, CodeSource.class });
} catch (Error ex) {
throw ex;
} catch (RuntimeException ex) {
throw ex;
} catch (Throwable ex) {
throw new Error("unexpected exception: " + ex.getMessage(), ex);
}
}
static Class defineClass(final ClassLoader loader, String className,
byte[] data, int off, int len) {
final Object[] args = new Object[5];
try {
args[0] = className;
args[1] = data;
args[2] = new Integer(off);
args[3] = new Integer(len);
args[4] = new CodeSource(new URL("file:stub"), new Certificate[0]);
} catch (java.net.MalformedURLException ex) {
throw new Error(ex.getMessage(), ex);
}
return (Class) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
ClassLoader the_loader = (loader == null ? (SecureClassLoader) Thread
.currentThread().getContextClassLoader()
: (SecureClassLoader) loader);
// make it accessible
defineClassMethod.setAccessible(true);
try {
return defineClassMethod.invoke(the_loader, args);
} catch (IllegalAccessException ex) {
throw new Error("internal error", ex);
} catch (IllegalArgumentException ex) {
throw new Error("internal error", ex);
} catch (InvocationTargetException ex) {
Throwable th = ex.getTargetException();
if (th instanceof Error) {
throw (Error) th;
} else if (th instanceof RuntimeException) {
throw (RuntimeException) th;
} else {
throw new Error("unexpected exception: " + ex.getMessage(), ex);
}
}
}
});
}
static String methodFieldName(int i) {
return "__method$" + i;
}
static String handlerFieldName() {
return "__handler";
}
static String initializerFieldName() {
return "__initializer";
}
static String handlerDataFieldName() {
return "__data";
}
static String getSuperMethodName(String name) {
return "__super_" + name + "$"
+ Integer.toHexString(name.hashCode() & 0xffff);
}
}
| 3,337 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/Stub.java | /**
*
* 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.yoko.rmi.util.stub;
/**
* Interface implemented by stub classes. Surprise!
* <p>
* For now, this plays no significant role; but we may use it in the future to
* handle serialization of stubs.
*/
public interface Stub {
/** Object array used for calling methods with no arguments */
public static final Object[] noarg = new Object[0];
/**
* Get the stub handler object.
*
* This method is generated separately for each stub method.
*/
public Object ____getTriforkStubHandler();
}
| 3,338 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/BCELClassBuilder.java | /**
*
* 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.yoko.rmi.util.stub;
import java.util.Collection;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.bcel.Constants;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Synthetic;
import org.apache.bcel.generic.ALOAD;
import org.apache.bcel.generic.ARETURN;
import org.apache.bcel.generic.ASTORE;
import org.apache.bcel.generic.ATHROW;
import org.apache.bcel.generic.ArrayType;
import org.apache.bcel.generic.ClassGen;
import org.apache.bcel.generic.ConstantPoolGen;
import org.apache.bcel.generic.DLOAD;
import org.apache.bcel.generic.DRETURN;
import org.apache.bcel.generic.FLOAD;
import org.apache.bcel.generic.FRETURN;
import org.apache.bcel.generic.FieldGen;
import org.apache.bcel.generic.ILOAD;
import org.apache.bcel.generic.INVOKESPECIAL;
import org.apache.bcel.generic.IRETURN;
import org.apache.bcel.generic.Instruction;
import org.apache.bcel.generic.InstructionConstants;
import org.apache.bcel.generic.InstructionFactory;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.InstructionList;
import org.apache.bcel.generic.LLOAD;
import org.apache.bcel.generic.LRETURN;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.NEW;
import org.apache.bcel.generic.ObjectType;
import org.apache.bcel.generic.PUSH;
import org.apache.bcel.generic.PUTFIELD;
import org.apache.bcel.generic.Type;
class BCELClassBuilder {
static final Logger logger = Logger.getLogger(BCELClassBuilder.class
.getName());
static Class make(ClassLoader loader, Class superClass, Class[] interfaces,
MethodRef[] methods, MethodRef[] superMethodRefs, Object[] data,
MethodRef handlerMethodRef, String className,
StubInitializer initializer)
throws IllegalAccessException, InstantiationException,
IllegalArgumentException {
String superClassName = superClass.getName();
String[] interfaceNames = new String[interfaces.length + 1];
for (int i = 0; i < interfaces.length; i++)
interfaceNames[i] = interfaces[i].getName();
interfaceNames[interfaces.length] = Stub.class.getName();
ClassGen newStubClass = new ClassGen(className, superClassName,
"generated", // file name
Constants.ACC_PUBLIC | Constants.ACC_FINAL, interfaceNames);
ConstantPoolGen cp = newStubClass.getConstantPool();
if (handlerMethodRef == null)
throw new IllegalArgumentException("handler method is null");
//
// Check that the handler method is valid
//
Class[] paramTypes = handlerMethodRef.getParameterTypes();
if (paramTypes.length != 3) {
throw new IllegalArgumentException(
"handler method must have three arguments");
}
if (!paramTypes[0].isAssignableFrom(superClass)) {
throw new IllegalArgumentException(
"Handler's 1st argument must be super-type for "
+ superClass);
}
// the type of data fields
Type typeOfDataFields = translate(paramTypes[1]);
if (Object[].class != paramTypes[2]) {
throw new IllegalArgumentException(
"Handler's 3rd argument must be Object[]");
}
//
// Construct field for the handler reference
//
Class handlerClass = handlerMethodRef.getDeclaringClass();
FieldGen handlerFieldGen = new FieldGen(Constants.ACC_PRIVATE
| Constants.ACC_FINAL, translate(handlerClass), Util
.handlerFieldName(), cp);
newStubClass.addField(handlerFieldGen.getField());
//
// Construct the method that gets the stub handler.
//
generateHandlerGetter(newStubClass, handlerFieldGen);
//
// construct the field that holds the initializer
//
FieldGen initializerFieldGen = new FieldGen(Constants.ACC_PRIVATE
| Constants.ACC_STATIC, translate(StubInitializer.class), Util
.initializerFieldName(), cp);
newStubClass.addField(initializerFieldGen.getField());
//
// Emit constructor
//
emitInitializerConstructor(newStubClass, handlerFieldGen,
initializerFieldGen);
//
// Construct data fields
//
FieldGen[] dataFieldGens = new FieldGen[methods.length];
for (int i = 0; i < methods.length; i++) {
MethodRef method = methods[i];
dataFieldGens[i] = new FieldGen(Constants.ACC_PRIVATE
| Constants.ACC_STATIC, typeOfDataFields, Util
.methodFieldName(i), cp);
newStubClass.addField(dataFieldGens[i].getField());
}
//
// Construct method stubs
//
for (int i = 0; i < methods.length; i++) {
generate(newStubClass, methods[i], dataFieldGens[i],
handlerFieldGen, handlerMethodRef);
}
//
// Construct super-method trampolines
//
for (int i = 0; i < superMethodRefs.length; i++) {
generateSuperMethod(newStubClass, superMethodRefs[i]);
}
JavaClass javaClass = newStubClass.getJavaClass();
byte[] classData = javaClass.getBytes();
try {
if (Boolean.getBoolean("org.apache.yoko.rmi.util.stub.debug")) {
java.io.File out = new java.io.File(className + ".class");
// System.out.println ("dumping to file "+out);
javaClass.dump(out);
}
} catch (java.io.IOException ex) {
logger.log(Level.WARNING, "", ex);
}
Class proxyClass = Util.defineClass(loader, className, classData, 0,
classData.length);
// initialize the static data fields
for (int i = 0; i < methods.length; i++) {
try {
java.lang.reflect.Field f = proxyClass
.getDeclaredField(dataFieldGens[i].getName());
f.setAccessible(true);
f.set(null, data[i]);
f.setAccessible(false);
} catch (NoSuchFieldException ex) {
logger
.log(
Level.WARNING,
"cannot find field "
+ dataFieldGens[i].getName()
+ " for stub class "
+ className
+ " extends: "
+ superClassName
+ "implements: "
+ interfaceNames[0]
+ (interfaceNames.length > 2 ? " (among others) "
: ""), ex);
throw new Error("internal error!", ex);
}
}
// set the initializer
try {
java.lang.reflect.Field f = proxyClass.getDeclaredField(Util
.initializerFieldName());
f.setAccessible(true);
f.set(null, initializer);
} catch (NoSuchFieldException ex) {
throw new Error("internal error!", ex);
}
return proxyClass;
}
static Class make(ClassLoader loader, Class superClass, Class[] interfaces,
MethodRef[] methods, Object[] data, MethodRef handlerMethodRef,
String className)
throws IllegalAccessException, InstantiationException,
IllegalArgumentException {
// construct the name of the new class
String superClassName = superClass.getName();
String[] interfaceNames = new String[interfaces.length + 1];
for (int i = 0; i < interfaces.length; i++)
interfaceNames[i] = interfaces[i].getName();
interfaceNames[interfaces.length] = Stub.class.getName();
ClassGen newStubClass = new ClassGen(className, superClassName,
"generated", // file name
Constants.ACC_PUBLIC | Constants.ACC_FINAL, interfaceNames);
ConstantPoolGen cp = newStubClass.getConstantPool();
if (handlerMethodRef == null)
throw new IllegalArgumentException("handler method is null");
//
// Check that the handler method is valid
//
Class[] paramTypes = handlerMethodRef.getParameterTypes();
if (paramTypes.length != 3) {
throw new IllegalArgumentException(
"handler method must have three arguments");
}
if (!paramTypes[0].isAssignableFrom(superClass)) {
throw new IllegalArgumentException(
"Handler's 1st argument must be super-type for "
+ superClass);
}
// the type of data fields
Type typeOfDataFields = translate(paramTypes[1]);
if (Object[].class != paramTypes[2]) {
throw new IllegalArgumentException(
"Handler's 3rd argument must be Object[]");
}
//
// Construct field for the handler reference
//
Class handlerClass = handlerMethodRef.getDeclaringClass();
FieldGen handlerFieldGen = new FieldGen(Constants.ACC_PRIVATE
| Constants.ACC_FINAL, translate(handlerClass), Util
.handlerFieldName(), cp);
newStubClass.addField(handlerFieldGen.getField());
//
// Construct the method that gets the stub handler.
//
generateHandlerGetter(newStubClass, handlerFieldGen);
//
// Emit constructor
//
emitOneArgConstructor(newStubClass, handlerFieldGen);
//
// Construct data fields
//
FieldGen[] dataFieldGens = new FieldGen[methods.length];
for (int i = 0; i < methods.length; i++) {
MethodRef method = methods[i];
dataFieldGens[i] = new FieldGen(Constants.ACC_PRIVATE
| Constants.ACC_STATIC, typeOfDataFields, Util
.methodFieldName(i), cp);
newStubClass.addField(dataFieldGens[i].getField());
}
//
// Construct method stubs
//
for (int i = 0; i < methods.length; i++) {
generate(newStubClass, methods[i], dataFieldGens[i],
handlerFieldGen, handlerMethodRef);
}
JavaClass javaClass = newStubClass.getJavaClass();
byte[] classData = javaClass.getBytes();
try {
if (Boolean.getBoolean("org.apache.yoko.rmi.util.stub.debug")) {
java.io.File out = new java.io.File(className + ".class");
// System.out.println ("dumping to file "+out);
javaClass.dump(out);
}
} catch (java.io.IOException ex) {
logger.log(Level.WARNING, "", ex);
}
Class proxyClass = Util.defineClass(loader, className, classData, 0,
classData.length);
// initialize the static data fields
for (int i = 0; i < methods.length; i++) {
try {
java.lang.reflect.Field f = proxyClass
.getDeclaredField(dataFieldGens[i].getName());
f.setAccessible(true);
f.set(null, data[i]);
f.setAccessible(false);
} catch (NoSuchFieldException ex) {
throw new Error("internal error!", ex);
}
}
return proxyClass;
}
static Type translate(Class clazz) {
if (clazz.isPrimitive()) {
if (clazz == Integer.TYPE) {
return Type.INT;
} else if (clazz == Boolean.TYPE) {
return Type.BOOLEAN;
} else if (clazz == Short.TYPE) {
return Type.SHORT;
} else if (clazz == Byte.TYPE) {
return Type.BYTE;
} else if (clazz == Long.TYPE) {
return Type.LONG;
} else if (clazz == Double.TYPE) {
return Type.DOUBLE;
} else if (clazz == Float.TYPE) {
return Type.FLOAT;
} else if (clazz == Character.TYPE) {
return Type.CHAR;
} else if (clazz == Void.TYPE) {
return Type.VOID;
} else {
throw new InternalError();
}
} else if (clazz.isArray()) {
return new ArrayType(translate(clazz.getComponentType()), 1);
} else {
return new ObjectType(clazz.getName());
}
}
static Type[] translate(Class[] clazz) {
Type[] result = new Type[clazz.length];
for (int i = 0; i < clazz.length; i++) {
result[i] = translate(clazz[i]);
}
return result;
}
public static MethodRef[] getAbstractMethods(Class base, Class[] interfaces) {
if (base == null)
base = Object.class;
MethodRef[] methods = collectMethods(base, interfaces);
return methods;
}
/**
* Collect the set of method objects that are would be abstract in a
* subclass of <code>super_class</code>, implementing
* <code>interfaces</code>.
*/
public static MethodRef[] collectMethods(Class super_class,
Class[] interfaces) {
HashMap methods = new HashMap();
if (interfaces != null) {
for (int i = 0; i < interfaces.length; i++)
collectAbstractMethods(methods, interfaces[i]);
}
collectAbstractMethods(methods, super_class);
removeImplementedMethods(methods, super_class);
Collection c = methods.values();
return (MethodRef[]) c.toArray(new MethodRef[c.size()]);
}
/**
* Collect all methods to be generated. We'll only collect each method once;
* so multiple redeclations will be eliminetd.
*/
private static void collectAbstractMethods(HashMap methods, Class type) {
if (type == java.lang.Object.class || type == null)
return;
Class[] if_types = type.getInterfaces();
for (int i = 0; i < if_types.length; i++) {
collectAbstractMethods(methods, if_types[i]);
}
collectAbstractMethods(methods, type.getSuperclass());
boolean type_is_interface = type.isInterface();
java.lang.reflect.Method[] declared = type.getDeclaredMethods();
for (int i = 0; i < declared.length; i++) {
MethodRef m = new MethodRef(declared[i]);
if (type_is_interface
|| java.lang.reflect.Modifier.isAbstract(m.getModifiers())) {
String key = m.getName() + m.getSignature();
if (!methods.containsKey(key)) {
methods.put(key, m);
}
}
}
}
/**
* This is used in the second phase of collect, to remove methods that have
* been collected in collectAbstractMethods.
*/
private static void removeImplementedMethods(HashMap methods, Class type) {
if (type == java.lang.Object.class || type == null)
return;
removeImplementedMethods(methods, type.getSuperclass());
java.lang.reflect.Method[] declared = type.getDeclaredMethods();
for (int i = 0; i < declared.length; i++) {
MethodRef m = new MethodRef(declared[i]);
if (!java.lang.reflect.Modifier.isAbstract(m.getModifiers())) {
String key = m.getName() + m.getSignature();
methods.remove(key);
}
}
}
static String className(String packageName, Class superClass,
Class[] interfaces) {
String className;
String fullName;
if (packageName == null) {
if (!java.lang.reflect.Modifier.isPublic(superClass.getModifiers())) {
packageName = Util.getPackageName(superClass);
} else {
for (int i = 0; i < interfaces.length; i++) {
if (java.lang.reflect.Modifier.isProtected(interfaces[i]
.getModifiers())) {
packageName = Util.getPackageName(interfaces[i]);
}
}
}
if (packageName == null) {
packageName = "org.apache.yoko.rmi.util.stub.gen";
}
}
synchronized (BCELClassBuilder.class) {
className = "Stub$$" + counter++;
}
return packageName + "." + className;
}
static int counter = 0;
static Type stubHandlerType = translate(StubHandler.class);
static Type initializerType = translate(StubInitializer.class);
static MethodRef getStubHandlerRef;
static {
try {
getStubHandlerRef = new MethodRef(StubInitializer.class
.getDeclaredMethod("getStubHandler", new Class[0]));
} catch (NoSuchMethodException ex) {
throw new Error(ex.getMessage(), ex);
}
}
//
// Constructor for a stub with an initializer
//
static void emitInitializerConstructor(ClassGen stubClass,
FieldGen handlerField, FieldGen initializerField) {
String stubClassName = stubClass.getClassName();
ConstantPoolGen cp = stubClass.getConstantPool();
InstructionList il = new InstructionList();
MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, Type.VOID,
Type.NO_ARGS, null, "<init>", stubClassName, il, cp);
InstructionFactory fac = new InstructionFactory(stubClass, cp);
// call super-constructor
il.append(InstructionFactory.createThis());
il.append(fac.createInvoke(stubClass.getSuperclassName(), "<init>",
Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
// push "this"
il.append(InstructionFactory.createThis());
// get static initializer
il.append(fac.createGetStatic(stubClassName,
initializerField.getName(), initializerField.getType()));
emitInvoke(il, fac, getStubHandlerRef);
// checkCast
il.append(fac.createCast(Type.OBJECT, handlerField.getType()));
// put handlerField
il.append(new PUTFIELD(cp.addFieldref(stubClassName, handlerField
.getName(), handlerField.getSignature())));
// return
il.append(InstructionConstants.RETURN);
// compute stack and locals...
mg.setMaxStack();
mg.setMaxLocals();
stubClass.addMethod(mg.getMethod());
}
//
// Constructor for a stub with an initializer
//
static void emitOneArgConstructor(ClassGen stubClass, FieldGen handlerField) {
String stubClassName = stubClass.getClassName();
ConstantPoolGen cp = stubClass.getConstantPool();
InstructionList il = new InstructionList();
Type[] args = new Type[] { handlerField.getType() };
MethodGen mg = new MethodGen(Constants.ACC_PUBLIC, Type.VOID, args,
null, "<init>", stubClassName, il, cp);
InstructionFactory fac = new InstructionFactory(stubClass, cp);
// call super-constructor
il.append(InstructionFactory.createThis());
il.append(fac.createInvoke(stubClass.getSuperclassName(), "<init>",
Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL));
// push this again...
il.append(InstructionFactory.createThis());
// push the handler
il.append(InstructionFactory.createLoad(handlerField.getType(), 1));
// put handlerField
il.append(new PUTFIELD(cp.addFieldref(stubClassName, handlerField
.getName(), handlerField.getSignature())));
// return
il.append(InstructionConstants.RETURN);
// compute stack and locals...
mg.setMaxStack();
mg.setMaxLocals();
stubClass.addMethod(mg.getMethod());
}
static void generateHandlerGetter(ClassGen clazz, FieldGen handlerField) {
java.lang.reflect.Method[] stub_methods = Stub.class
.getDeclaredMethods();
if (stub_methods.length != 1) {
throw new IllegalStateException("" + Stub.class
+ " has wrong # methods");
}
String handlerGetName = stub_methods[0].getName();
ConstantPoolGen cp = clazz.getConstantPool();
InstructionList il = new InstructionList();
InstructionFactory fac = new InstructionFactory(clazz, cp);
Type methodReturnType = translate(Object.class);
Type[] methodArgTypes = new Type[0];
MethodGen mg = new MethodGen(
Constants.ACC_FINAL | Constants.ACC_PUBLIC, methodReturnType,
methodArgTypes, null, // arg names
handlerGetName, clazz.getClassName(), il, cp);
mg.addAttribute(new Synthetic(cp.addUtf8("Synthetic"), 0, null, cp
.getConstantPool()));
//
// construct method body
//
il.append(InstructionFactory.createThis());
il.append(fac.createGetField(clazz.getClassName(), handlerField
.getName(), handlerField.getType()));
emitReturn(il, methodReturnType);
//
// finish up...
//
mg.setMaxStack();
mg.setMaxLocals();
clazz.addMethod(mg.getMethod());
}
static void generate(ClassGen clazz, MethodRef method, FieldGen dataField,
FieldGen handlerField, MethodRef handlerMethodRef) {
ConstantPoolGen cp;
InstructionList il;
cp = clazz.getConstantPool();
il = new InstructionList();
InstructionFactory fac = new InstructionFactory(clazz, cp);
Type methodReturnType = translate(method.getReturnType());
Type[] methodArgTypes = translate(method.getParameterTypes());
MethodGen mg = new MethodGen(
Constants.ACC_FINAL | Constants.ACC_PUBLIC, methodReturnType,
methodArgTypes, null, // arg names
method.getName(), clazz.getClassName(), il, cp);
mg.addAttribute(new Synthetic(cp.addUtf8("Synthetic"), 0, null, cp
.getConstantPool()));
Class[] throwsException = method.getExceptionTypes();
for (int i = 0; i < throwsException.length; i++) {
mg.addException(throwsException[i].getName());
}
//
// BODY
//
il.append(InstructionFactory.createThis());
il.append(fac.createGetField(clazz.getClassName(), handlerField
.getName(), handlerField.getType()));
// push "this" as invoke's first argument
il.append(InstructionFactory.createThis());
// load data value
if (dataField.isStatic()) {
il.append(fac.createGetStatic(clazz.getClassName(), dataField
.getName(), dataField.getType()));
} else {
il.append(InstructionFactory.createThis());
il.append(fac.createGetField(clazz.getClassName(), dataField
.getName(), dataField.getType()));
}
il.append(new PUSH(cp, methodArgTypes.length));
il.append((Instruction) fac.createNewArray(Type.OBJECT, (short) 1));
int index = 1;
for (int i = 0; i < methodArgTypes.length; i++) {
// dup array ref
il.append(InstructionConstants.DUP);
// push index
il.append(new PUSH(cp, i));
// transform parameter
il.append(InstructionFactory.createLoad(methodArgTypes[i], index));
emitCoerceToObject(il, fac, methodArgTypes[i]);
// and store into array
il.append(InstructionFactory.createArrayStore(Type.OBJECT));
index += methodArgTypes[i].getSize();
}
//
// invoke handler's method
//
InstructionHandle tryStart = emitInvoke(il, fac, handlerMethodRef);
// convert to primitive type
emitCoerceFromObject(il, fac, methodReturnType);
// and return
InstructionHandle tryEnd = emitReturn(il, methodReturnType);
//
// catch...
//
InstructionHandle rethrowLocation = il.append(new ATHROW());
Class[] exceptions = method.getExceptionTypes();
boolean handle_throwable_exception = true;
boolean handle_runtime_exception = true;
if (exceptions != null) {
for (int i = 0; i < exceptions.length; i++) {
Class ex = exceptions[i];
if (ex == java.lang.Throwable.class)
handle_throwable_exception = false;
if (ex == java.lang.RuntimeException.class
|| ex == java.lang.Exception.class)
handle_runtime_exception = false;
mg.addExceptionHandler(tryStart, tryEnd, rethrowLocation,
(ObjectType) translate(ex));
}
}
// A RuntimeException should not cause an
// UndeclaredThrowableException, so we catch and re-throw it
// that before throwable.
if (handle_throwable_exception && handle_runtime_exception) {
mg.addExceptionHandler(tryStart, tryEnd, rethrowLocation,
new ObjectType("java.lang.RuntimeException"));
}
// If anything else is thrown, it is wrapped in an
// UndeclaredThrowable
if (handle_throwable_exception) {
InstructionHandle handlerStart = il.append(new ASTORE(1));
il
.append(new NEW(
cp
.addClass("java.lang.reflect.UndeclaredThrowableException")));
il.append(InstructionConstants.DUP);
il.append(new ALOAD(1));
il.append(new INVOKESPECIAL(cp.addMethodref(
"java.lang.reflect.UndeclaredThrowableException", "<init>",
"(Ljava/lang/Throwable;)V")));
il.append(new ATHROW());
mg.addExceptionHandler(tryStart, tryEnd, handlerStart,
new ObjectType("java.lang.Throwable"));
}
//
// DONE
//
mg.setMaxStack();
mg.setMaxLocals();
clazz.addMethod(mg.getMethod());
}
static void generateSuperMethod(ClassGen clazz, MethodRef method) {
ConstantPoolGen cp;
InstructionList il;
cp = clazz.getConstantPool();
il = new InstructionList();
InstructionFactory fac = new InstructionFactory(clazz, cp);
Type methodReturnType = translate(method.getReturnType());
Type[] methodArgTypes = translate(method.getParameterTypes());
MethodGen mg = new MethodGen(
Constants.ACC_FINAL | Constants.ACC_PUBLIC, methodReturnType,
methodArgTypes, null, // arg names
method.getName(), clazz.getClassName(), il, cp);
mg.addAttribute(new Synthetic(cp.addUtf8("Synthetic"), 0, null, cp
.getConstantPool()));
Class[] throwsException = method.getExceptionTypes();
for (int i = 0; i < throwsException.length; i++) {
mg.addException(throwsException[i].getName());
}
// push this
il.append(InstructionFactory.createThis());
// push arguments
int index = 1;
for (int i = 0; i < methodArgTypes.length; i++) {
emitLoad(il, index, methodArgTypes[i]);
index += methodArgTypes[i].getSize();
}
// call method
il.append(new INVOKESPECIAL(cp.addMethodref(method.getDeclaringClass()
.getName(), method.getName(), method.getSignature())));
emitReturn(il, methodReturnType);
//
// DONE
//
mg.setMaxStack();
mg.setMaxLocals();
clazz.addMethod(mg.getMethod());
}
static InstructionHandle emitLoad(InstructionList il, int index, Type type) {
switch (type.getType()) {
case Constants.T_BOOLEAN:
case Constants.T_CHAR:
case Constants.T_BYTE:
case Constants.T_SHORT:
case Constants.T_INT:
return il.append(new ILOAD(index));
case Constants.T_LONG:
return il.append(new LLOAD(index));
case Constants.T_FLOAT:
return il.append(new FLOAD(index));
case Constants.T_DOUBLE:
return il.append(new DLOAD(index));
default:
return il.append(new ALOAD(index));
}
}
static InstructionHandle emitReturn(InstructionList il, Type type) {
switch (type.getType()) {
case Constants.T_BOOLEAN:
case Constants.T_CHAR:
case Constants.T_BYTE:
case Constants.T_SHORT:
case Constants.T_INT:
return il.append(new IRETURN());
case Constants.T_LONG:
return il.append(new LRETURN());
case Constants.T_FLOAT:
return il.append(new FRETURN());
case Constants.T_DOUBLE:
return il.append(new DRETURN());
case Constants.T_VOID:
return il.append(InstructionConstants.RETURN);
default:
return il.append(new ARETURN());
}
}
static void emitCoerceToObject(InstructionList il, InstructionFactory fac,
Type type) {
int tag = type.getType();
switch (tag) {
case Constants.T_BOOLEAN:
case Constants.T_CHAR:
case Constants.T_BYTE:
case Constants.T_SHORT:
case Constants.T_INT:
case Constants.T_FLOAT:
// float
il.append(fac.createNew(new ObjectType(BASIC_CLASS_NAMES[tag])));
// float Float
il.append(InstructionConstants.DUP_X1);
// Float float Float
il.append(InstructionConstants.SWAP);
// Float Float float
il.append(fac.createInvoke(BASIC_CLASS_NAMES[tag], "<init>",
Type.VOID, new Type[] { type }, Constants.INVOKESPECIAL));
// Float
return;
case Constants.T_DOUBLE:
case Constants.T_LONG:
// double/2
il.append(fac.createNew(new ObjectType(BASIC_CLASS_NAMES[tag])));
// double/2 Double
il.append(InstructionConstants.DUP_X2);
// Double double/2 Double
il.append(InstructionConstants.DUP_X2);
// Double Double double/2 Double
il.append(InstructionConstants.POP);
// Double Double double/2
il.append(fac.createInvoke(BASIC_CLASS_NAMES[tag], "<init>",
Type.VOID, new Type[] { type }, Constants.INVOKESPECIAL));
// Double
return;
case Constants.T_VOID:
il.append(InstructionConstants.ACONST_NULL);
default:
return;
}
}
public static final String[] BASIC_CLASS_NAMES = { null, null, null, null,
"java.lang.Boolean", "java.lang.Character", "java.lang.Float",
"java.lang.Double", "java.lang.Byte", "java.lang.Short",
"java.lang.Integer", "java.lang.Long", "java.lang.Void", null,
null, null, null };
static MethodRef[] UNBOXING_METHOD = new MethodRef[Constants.T_VOID];
static {
try {
UNBOXING_METHOD[Constants.T_BOOLEAN] = new MethodRef(
java.lang.Boolean.class.getDeclaredMethod("booleanValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_CHAR] = new MethodRef(
java.lang.Character.class.getDeclaredMethod("charValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_BYTE] = new MethodRef(
java.lang.Byte.class.getDeclaredMethod("byteValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_SHORT] = new MethodRef(
java.lang.Short.class.getDeclaredMethod("shortValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_INT] = new MethodRef(
java.lang.Integer.class.getDeclaredMethod("intValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_LONG] = new MethodRef(
java.lang.Long.class.getDeclaredMethod("longValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_FLOAT] = new MethodRef(
java.lang.Float.class.getDeclaredMethod("floatValue",
new Class[0]));
UNBOXING_METHOD[Constants.T_DOUBLE] = new MethodRef(
java.lang.Double.class.getDeclaredMethod("doubleValue",
new Class[0]));
} catch (NoSuchMethodException ex) {
throw new Error(ex);
}
}
static InstructionHandle emitCoerceFromObject(InstructionList il,
InstructionFactory fac, Type type) {
int tag = type.getType();
switch (tag) {
case Constants.T_BOOLEAN:
case Constants.T_CHAR:
case Constants.T_BYTE:
case Constants.T_SHORT:
case Constants.T_INT:
case Constants.T_LONG:
case Constants.T_FLOAT:
case Constants.T_DOUBLE:
il.append(fac.createCast(Type.OBJECT, new ObjectType(
BASIC_CLASS_NAMES[tag])));
return emitInvoke(il, fac, UNBOXING_METHOD[tag]);
case Constants.T_OBJECT:
case Constants.T_ARRAY:
return il.append(fac.createCast(Type.OBJECT, type));
case Constants.T_VOID:
return il.append(InstructionConstants.POP);
default:
throw new RuntimeException("internal error");
}
}
static InstructionHandle emitInvoke(InstructionList il,
InstructionFactory fac, MethodRef method) {
String signature = method.getSignature();
Type[] args = Type.getArgumentTypes(signature);
Type ret = Type.getReturnType(signature);
String mname = method.getName();
String cname = method.getDeclaringClass().getName();
short kind;
if (method.getDeclaringClass().isInterface()) {
kind = Constants.INVOKEINTERFACE;
} else if (java.lang.reflect.Modifier.isStatic(method.getModifiers())) {
kind = Constants.INVOKESTATIC;
} else if (method.getName().charAt(0) == '<') {
kind = Constants.INVOKESPECIAL;
} else {
kind = Constants.INVOKEVIRTUAL;
}
return il.append(fac.createInvoke(cname, mname, ret, args, kind));
}
}
| 3,339 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/StubInitializer.java | /**
*
* 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.yoko.rmi.util.stub;
/**
*
*/
public interface StubInitializer {
Object getStubHandler();
}
| 3,340 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/StubHandler.java | /**
*
* 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.yoko.rmi.util.stub;
public interface StubHandler {
Object invoke(Object object, Object data, Object[] args) throws Throwable;
}
| 3,341 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/MethodRef.java | /**
*
* 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.yoko.rmi.util.stub;
import java.lang.reflect.Method;
/**
* Describes the interface of a method to be generated by the stub utility
*/
public class MethodRef {
String name;
Class declaringClass;
Class[] parameterTypes;
Class returnType;
Class[] exceptionTypes;
int modifiers;
Method method;
String signature;
public MethodRef() {
}
public MethodRef(Method method) {
this.method = method;
name = method.getName();
setDeclaringClass(method.getDeclaringClass());
setParameterTypes(method.getParameterTypes());
setReturnType(method.getReturnType());
setExceptionTypes(method.getExceptionTypes());
setModifiers(method.getModifiers());
}
public Method getMethod() {
return method;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setDeclaringClass(Class declaringClass) {
this.declaringClass = declaringClass;
}
public Class getDeclaringClass() {
return declaringClass;
}
public void setParameterTypes(Class[] parameterTypes) {
this.parameterTypes = parameterTypes;
}
public Class[] getParameterTypes() {
return parameterTypes;
}
public void setReturnType(Class returnType) {
this.returnType = returnType;
}
public Class getReturnType() {
return returnType;
}
public void setExceptionTypes(Class[] exceptionTypes) {
this.exceptionTypes = exceptionTypes;
}
public Class[] getExceptionTypes() {
return exceptionTypes;
}
public void setModifiers(int modifiers) {
this.modifiers = modifiers;
}
public int getModifiers() {
return modifiers;
}
public String getSignature() {
if (signature != null)
return signature;
StringBuffer sb = new StringBuffer();
sb.append('(');
for (int i = 0; i < parameterTypes.length; i++)
sb.append(getSignature(parameterTypes[i]));
sb.append(')');
sb.append(getSignature(returnType));
signature = sb.toString();
return signature;
}
static String getSignature(Class clz) {
if (clz.isPrimitive()) {
if (clz == Integer.TYPE) {
return "I";
} else if (clz == Boolean.TYPE) {
return "Z";
} else if (clz == Byte.TYPE) {
return "B";
} else if (clz == Short.TYPE) {
return "S";
} else if (clz == Long.TYPE) {
return "J";
} else if (clz == Double.TYPE) {
return "D";
} else if (clz == Float.TYPE) {
return "F";
} else if (clz == Void.TYPE) {
return "V";
} else if (clz == Character.TYPE) {
return "C";
} else {
throw new InternalError("cannot handle " + clz);
}
} else if (clz.isArray()) {
return "[" + getSignature(clz.getComponentType());
} else {
return "L" + clz.getName().replace('.', '/') + ";";
}
}
}
| 3,342 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/util/stub/StubClass.java | /**
*
* 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.yoko.rmi.util.stub;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.logging.Level;
import java.util.logging.Logger;
public final class StubClass {
static final Logger logger = Logger.getLogger(StubClass.class.getName());
/**
* Return the stub handler for the given stub.
*/
public static Object getStubHandler(final Stub stub) {
return stub.____getTriforkStubHandler();
}
/**
* Construct a StubClass.
*
* @param loader
* designates the classloader to use for constructing the
* stubclass. If <code>null</code>, the current context class
* loader will be used.
* @param super_class
* is the base class for the new stub. If <code>null</code>
* java.lang.Object will be used.
* @param interfaces
* designates the interfaces the stub class should implement.
* This value may be <code>null</code> if no additional
* interfaces should be included.
* @param methods
* is the list of methods to implement in the stub class. If this
* parameter is <code>null</code>, stub methods will be
* generated for all abstract methods declared but not
* implemented.
* @param data
* describes the data to be passed along as the second argument
* to a handler method.
* @param handler_method
* is the method used for delegating the call handled by a stub
* method. If <code>null</code>, then
* <code>com.trifork.StubHandler.invoke()</code> is used. This
* method must have a signature `public Object <i>Handler</i>.<i>name</i>(Object,
* <i>Data</i>, Object)'. The constructor to the resulting stub
* class takes as it's argument, a <i>Handler</i> object.
* @param package_name
* is the name of the package into which the stub class is
* defined. If <code>null</code>, then the package of the
* <i>super_class</i> is used; unless it lives in a sealed
* package, in which case the package anme is undefined.
*/
public static Class make(final ClassLoader loader, final Class super_class,
final Class[] interfaces, final MethodRef[] methods,
final Object[] data, final Method handler_method,
final String package_name) {
return (Class) java.security.AccessController
.doPrivileged(new java.security.PrivilegedAction() {
public Object run() {
try {
Class superClass = super_class;
if (superClass == null)
superClass = java.lang.Object.class;
Class[] theInterfaces = interfaces;
if (theInterfaces == null)
theInterfaces = new java.lang.Class[0];
ClassLoader theLoader = chooseLoader(loader,
superClass, theInterfaces, handler_method);
MethodRef[] theMethods = methods;
if (theMethods == null)
theMethods = BCELClassBuilder.collectMethods(
superClass, theInterfaces);
String className = BCELClassBuilder.className(
package_name, superClass, theInterfaces);
return BCELClassBuilder.make(theLoader, superClass,
theInterfaces, theMethods, data,
new MethodRef(handler_method), className);
/*
* return StubClassBuilder.make (loader,
* super_class, interfaces, methods, data,
* handler_method, package_name);
*/
} catch (IllegalAccessException ex) {
throw new Error("illegal access", ex);
} catch (InstantiationException ex) {
throw new Error("illegal access", ex);
}
}
});
}
public static MethodRef[] getAbstractMethodRefs(final Class base,
final Class[] interfaces) {
return (MethodRef[]) java.security.AccessController
.doPrivileged(new java.security.PrivilegedAction() {
public Object run() {
return BCELClassBuilder.getAbstractMethods(base,
interfaces);
}
});
}
public static Class make(final ClassLoader loader, final Class super_class,
final Class[] interfaces, final MethodRef[] methods,
final Method[] superMethods, final Object[] data,
final Method handler_method, final String package_name,
final StubInitializer initializer) {
return make(loader, super_class, interfaces, methods, superMethods,
data, handler_method, package_name, (String) null, initializer);
}
/**
* Construct a stub for which it's handler is determined by using a
* StubInitializer. Using this, the resulting class has a no-arg
* constructor.
* <p>
*
* @param superMethods
* is an array of methods defined in the super_class, for which
* super.method trampolines should be generated. Upon return, the
* array has filled in java.lang.reflect.Method objects for the
* generated trampolines.
*/
public static Class make(final ClassLoader loader, final Class super_class,
final Class[] interfaces, final MethodRef[] methods,
final Method[] superMethods, final Object[] data,
final Method handler_method, final String package_name,
final String class_name, final StubInitializer initializer) {
return (Class) java.security.AccessController
.doPrivileged(new java.security.PrivilegedAction() {
public Object run() {
try {
Class superClass = super_class;
if (superClass == null)
superClass = java.lang.Object.class;
Class[] theInterfaces = interfaces;
if (theInterfaces == null)
theInterfaces = new java.lang.Class[0];
ClassLoader theLoader = chooseLoader(loader,
superClass, theInterfaces, handler_method);
MethodRef[] theMethods = methods;
if (theMethods == null)
theMethods = BCELClassBuilder.collectMethods(
superClass, theInterfaces);
MethodRef[] superMethodRefs;
if (superMethods == null) {
superMethodRefs = new MethodRef[0];
} else {
superMethodRefs = new MethodRef[superMethods.length];
for (int i = 0; i < superMethods.length; i++)
superMethodRefs[i] = new MethodRef(
superMethods[i]);
}
Object[] theData = data;
if (theData == null)
theData = theMethods;
MethodRef handlerMethodRef = new MethodRef(
handler_method);
String className = class_name;
if (className == null)
className = BCELClassBuilder
.className(package_name, superClass,
theInterfaces);
Class result = BCELClassBuilder.make(theLoader,
superClass, theInterfaces, theMethods,
superMethodRefs, theData, handlerMethodRef,
className, initializer);
if (superMethods != null) {
try {
for (int i = 0; i < superMethods.length; i++) {
java.lang.reflect.Method m = superMethods[i];
superMethods[i] = result
.getDeclaredMethod(Util
.getSuperMethodName(m
.getName()), m
.getParameterTypes());
}
} catch (NoSuchMethodException ex) {
throw new Error("internal error!", ex);
}
}
return result;
} catch (IllegalAccessException ex) {
throw new Error("illegal access", ex);
} catch (InstantiationException ex) {
throw new Error("illegal access", ex);
}
}
});
}
/**
*
*/
public static Stub createInstance(final Class clazz, final Object handler) {
return (Stub) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
java.lang.reflect.Constructor[] con = clazz
.getConstructors();
// create an instance of it
return con[0].newInstance(new Object[] { handler });
} catch (InstantiationException ex) {
logger.log(Level.WARNING, "", ex);
} catch (InvocationTargetException ex) {
logger.log(Level.WARNING, "", ex.getCause());
} catch (IllegalAccessException ex) {
logger.log(Level.WARNING, "", ex);
}
return null;
}
});
}
public static Stub createInstance(final Class clazz) {
return (Stub) AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
try {
return clazz.newInstance();
} catch (InstantiationException ex) {
logger.log(Level.WARNING, "", ex);
} catch (IllegalAccessException ex) {
logger.log(Level.WARNING, "", ex);
}
return null;
}
});
}
private static ClassLoader chooseLoader(ClassLoader loader,
Class superClass, Class[] interfaces, Method handler) {
java.util.Set loaders = new java.util.HashSet();
loaders.add(Stub.class.getClassLoader());
loaders.add(handler.getDeclaringClass().getClassLoader());
if (loader != null) {
loaders.add(loader);
}
if (superClass != null && superClass.getClassLoader() != null) {
loaders.add(superClass.getClassLoader());
}
for (int i = 0; i < interfaces.length; i++) {
if (interfaces[i].getClassLoader() != null) {
loaders.add(interfaces[i].getClassLoader());
}
}
if (loaders.size() == 0) {
return superClass.getClassLoader();
}
ClassLoader first = (ClassLoader) loaders.iterator().next();
if (loaders.size() == 1) {
return (ClassLoader) first;
}
loaders.remove(first);
ClassLoader[] rest = new ClassLoader[loaders.size()];
loaders.toArray(rest);
return new SetClassLoader(rest, first);
}
static class SetClassLoader extends java.security.SecureClassLoader {
ClassLoader[] rest;
SetClassLoader(ClassLoader[] loaders, ClassLoader parent) {
super(parent);
rest = loaders;
}
protected Class loadClass(String name, boolean resolve)
throws ClassNotFoundException {
try {
//
// will try parent
//
return super.loadClass(name, resolve);
} catch (ClassNotFoundException ex) {
// ignore //
}
for (int i = 0; i < rest.length; i++) {
try {
return rest[i].loadClass(name);
} catch (ClassNotFoundException ex) {
// ignore //
}
}
throw new ClassNotFoundException(name);
}
}
}
| 3,343 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/osgi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/osgi/activator/Activator.java | package org.apache.yoko.rmi.osgi.activator;
import javax.rmi.CORBA.Stub;
import org.apache.yoko.osgi.locator.ProviderRegistryImpl;
import org.apache.yoko.osgi.locator.Register;
import org.apache.yoko.osgi.locator.activator.AbstractBundleActivator;
import org.omg.stub.java.rmi._Remote_Stub;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
public class Activator extends AbstractBundleActivator {
private ServiceRegistration<Register> sr;
private ProviderRegistryImpl register;
public Activator() {
super(new Info[] {
new Info(_Remote_Stub.class.getName(), _Remote_Stub.class.getName(), 1),
new Info(Stub.class.getName(), Stub.class.getName(), 1)
},
new Info[] {
new Info("javax.rmi.CORBA.PortableRemoteObjectClass", "org.apache.yoko.rmi.impl.PortableRemoteObjectImpl", 1),
new Info("javax.rmi.CORBA.UtilClass", "org.apache.yoko.rmi.impl.UtilImpl", 1),
new Info("org.apache.yoko.rmi.PortableRemoteObjectExtClass", "org.apache.yoko.rmi.impl.PortableRemoteObjectExtImpl", 1),
new Info("org.apache.yoko.rmi.RMIStubInitializerClass", "org.apache.yoko.rmi.impl.RMIStubInitializer", 1),
new Info("javax.rmi.CORBA.StubClass", "org.apache.yoko.rmi.impl.StubImpl", 1)
});
}
@Override
public void start(BundleContext context) throws Exception {
register = new ProviderRegistryImpl();
register.start();
sr = context.registerService(Register.class, register, null);
super.start(context);
}
@Override
public void stop(BundleContext context) throws Exception {
super.stop(context);
sr.unregister();
register.stop();
}
}
| 3,344 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/api/PortableRemoteObjectState.java | /**
*
* 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.yoko.rmi.api;
import java.rmi.Remote;
import java.rmi.RemoteException;
/**
* An instance of PortableRemoteObjectState represents a POA, with possible
* sub-POA's that service the objects published through this state.
*/
public interface PortableRemoteObjectState {
/**
*
*/
org.omg.CORBA.ORB getORB();
/**
* ContextClassLoader for this state
*/
ClassLoader getClassLoader();
/**
* Shutdown this state
*/
public void shutdown();
public void exportObject(Remote object) throws RemoteException;
public void unexportObject(Remote object) throws RemoteException;
}
| 3,345 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/api/RemoteOnewayException.java | /**
*
* 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.yoko.rmi.api;
public class RemoteOnewayException extends RuntimeException {
public RemoteOnewayException() {
super("");
}
}
| 3,346 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/api/PortableRemoteObjectExt.java | /**
*
* 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.yoko.rmi.api;
import java.security.AccessController;
import org.apache.yoko.rmi.util.GetSystemPropertyAction;
import org.apache.yoko.osgi.ProviderLocator;
public class PortableRemoteObjectExt {
private static PortableRemoteObjectExtDelegate delegate;
private static void init() {
if (delegate != null)
return;
try {
delegate = (PortableRemoteObjectExtDelegate) ProviderLocator.getService("org.apache.yoko.rmi.PortableRemoteObjectExtClass", PortableRemoteObjectExt.class, Thread.currentThread().getContextClassLoader());
} catch (Exception ex) {
throw new RuntimeException("internal problem: " + ex.getMessage(), ex);
}
if (delegate == null) {
String name = (String)AccessController.doPrivileged(new GetSystemPropertyAction(
"org.apache.yoko.rmi.PortableRemoteObjectExtClass",
"org.apache.yoko.rmi.impl.PortableRemoteObjectExtImpl"));
try {
delegate = (PortableRemoteObjectExtDelegate)ProviderLocator.loadClass(name, PortableRemoteObjectExt.class, Thread.currentThread().getContextClassLoader()).newInstance();
} catch (InstantiationException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch (IllegalAccessException ex) {
throw new RuntimeException(ex.getMessage(), ex);
} catch (ClassNotFoundException ex) {
throw new RuntimeException(ex.getMessage(), ex);
}
}
}
/** Return the currently active state for this thread */
public static PortableRemoteObjectState getState() {
init();
return delegate.getCurrentState();
}
}
| 3,347 |
0 | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi | Create_ds/geronimo-yoko/yoko-rmi-impl/src/main/java/org/apache/yoko/rmi/api/PortableRemoteObjectExtDelegate.java | /**
*
* 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.yoko.rmi.api;
public interface PortableRemoteObjectExtDelegate {
PortableRemoteObjectState getCurrentState();
}
| 3,348 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ITTAbsent.java | package org.omg.CSI;
/**
* org/omg/CSI/ITTAbsent.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface ITTAbsent
{
// OMG. All IdentityTokenType constants shall be a power of 2.
public static final int value = (int)(0L);
}
| 3,349 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/SASContextBodyHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/SASContextBodyHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class SASContextBodyHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.SASContextBody value = null;
public SASContextBodyHolder ()
{
}
public SASContextBodyHolder (org.omg.CSI.SASContextBody initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.SASContextBodyHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.SASContextBodyHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.SASContextBodyHelper.type ();
}
}
| 3,350 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSS_NT_Scoped_Username_OID.java | package org.omg.CSI;
/**
* org/omg/CSI/GSS_NT_Scoped_Username_OID.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface GSS_NT_Scoped_Username_OID
{
// naming (2) scoped-username(1) }
public static final String value = "oid:2.23.130.1.2.1";
}
| 3,351 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/X509CertificateChainHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/X509CertificateChainHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// representation of Certificate is as defined in [IETF RFC 2459].
abstract public class X509CertificateChainHelper
{
private static String _id = "IDL:omg.org/CSI/X509CertificateChain:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.X509CertificateChainHelper.id (), "X509CertificateChain", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,352 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/X501DistinguishedNameHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/X501DistinguishedNameHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// octets containing the ASN.1 encoding.
abstract public class X501DistinguishedNameHelper
{
private static String _id = "IDL:omg.org/CSI/X501DistinguishedName:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.X501DistinguishedNameHelper.id (), "X501DistinguishedName", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,353 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/CompleteEstablishContext.java | package org.omg.CSI;
/**
* org/omg/CSI/CompleteEstablishContext.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class CompleteEstablishContext implements org.omg.CORBA.portable.IDLEntity
{
public long client_context_id = (long)0;
public boolean context_stateful = false;
public byte final_context_token[] = null;
public CompleteEstablishContext ()
{
} // ctor
public CompleteEstablishContext (long _client_context_id, boolean _context_stateful, byte[] _final_context_token)
{
client_context_id = _client_context_id;
context_stateful = _context_stateful;
final_context_token = _final_context_token;
} // ctor
} // class CompleteEstablishContext
| 3,354 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityTokenHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityTokenHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class IdentityTokenHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.IdentityToken value = null;
public IdentityTokenHolder ()
{
}
public IdentityTokenHolder (org.omg.CSI.IdentityToken initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.IdentityTokenHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.IdentityTokenHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.IdentityTokenHelper.type ();
}
}
| 3,355 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/CompleteEstablishContextHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/CompleteEstablishContextHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class CompleteEstablishContextHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.CompleteEstablishContext value = null;
public CompleteEstablishContextHolder ()
{
}
public CompleteEstablishContextHolder (org.omg.CSI.CompleteEstablishContext initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.CompleteEstablishContextHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.CompleteEstablishContextHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.CompleteEstablishContextHelper.type ();
}
}
| 3,356 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityTokenHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityTokenHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class IdentityTokenHelper
{
private static String _id = "IDL:omg.org/CSI/IdentityToken:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.IdentityToken that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.IdentityToken extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
org.omg.CORBA.TypeCode _disTypeCode0;
_disTypeCode0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulong);
_disTypeCode0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.IdentityTokenTypeHelper.id (), "IdentityTokenType", _disTypeCode0);
org.omg.CORBA.UnionMember[] _members0 = new org.omg.CORBA.UnionMember [6];
org.omg.CORBA.TypeCode _tcOf_members0;
org.omg.CORBA.Any _anyOf_members0;
// Branch for absent (case label org.omg.CSI.ITTAbsent.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_ulong ((int)org.omg.CSI.ITTAbsent.value);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_boolean);
_members0[0] = new org.omg.CORBA.UnionMember (
"absent",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for anonymous (case label org.omg.CSI.ITTAnonymous.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_ulong ((int)org.omg.CSI.ITTAnonymous.value);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_boolean);
_members0[1] = new org.omg.CORBA.UnionMember (
"anonymous",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for principal_name (case label org.omg.CSI.ITTPrincipalName.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_ulong ((int)org.omg.CSI.ITTPrincipalName.value);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSS_NT_ExportedNameHelper.id (), "GSS_NT_ExportedName", _tcOf_members0);
_members0[2] = new org.omg.CORBA.UnionMember (
"principal_name",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for certificate_chain (case label org.omg.CSI.ITTX509CertChain.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_ulong ((int)org.omg.CSI.ITTX509CertChain.value);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.X509CertificateChainHelper.id (), "X509CertificateChain", _tcOf_members0);
_members0[3] = new org.omg.CORBA.UnionMember (
"certificate_chain",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for dn (case label org.omg.CSI.ITTDistinguishedName.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_ulong ((int)org.omg.CSI.ITTDistinguishedName.value);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.X501DistinguishedNameHelper.id (), "X501DistinguishedName", _tcOf_members0);
_members0[4] = new org.omg.CORBA.UnionMember (
"dn",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for id (Default case)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_octet ((byte)0); // default member label
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.IdentityExtensionHelper.id (), "IdentityExtension", _tcOf_members0);
_members0[5] = new org.omg.CORBA.UnionMember (
"id",
_anyOf_members0,
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_union_tc (org.omg.CSI.IdentityTokenHelper.id (), "IdentityToken", _disTypeCode0, _members0);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.IdentityToken read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.IdentityToken value = new org.omg.CSI.IdentityToken ();
int _dis0 = (int)0;
_dis0 = istream.read_ulong ();
switch (_dis0)
{
case org.omg.CSI.ITTAbsent.value:
boolean _absent = false;
_absent = istream.read_boolean ();
value.absent (_absent);
break;
case org.omg.CSI.ITTAnonymous.value:
boolean _anonymous = false;
_anonymous = istream.read_boolean ();
value.anonymous (_anonymous);
break;
case org.omg.CSI.ITTPrincipalName.value:
byte _principal_name[] = null;
_principal_name = org.omg.CSI.GSS_NT_ExportedNameHelper.read (istream);
value.principal_name (_principal_name);
break;
case org.omg.CSI.ITTX509CertChain.value:
byte _certificate_chain[] = null;
_certificate_chain = org.omg.CSI.X509CertificateChainHelper.read (istream);
value.certificate_chain (_certificate_chain);
break;
case org.omg.CSI.ITTDistinguishedName.value:
byte _dn[] = null;
_dn = org.omg.CSI.X501DistinguishedNameHelper.read (istream);
value.dn (_dn);
break;
default:
byte _id[] = null;
_id = org.omg.CSI.IdentityExtensionHelper.read (istream);
value.id (_dis0, _id);
break;
}
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.IdentityToken value)
{
ostream.write_ulong (value.discriminator ());
switch (value.discriminator ())
{
case org.omg.CSI.ITTAbsent.value:
ostream.write_boolean (value.absent ());
break;
case org.omg.CSI.ITTAnonymous.value:
ostream.write_boolean (value.anonymous ());
break;
case org.omg.CSI.ITTPrincipalName.value:
org.omg.CSI.GSS_NT_ExportedNameHelper.write (ostream, value.principal_name ());
break;
case org.omg.CSI.ITTX509CertChain.value:
org.omg.CSI.X509CertificateChainHelper.write (ostream, value.certificate_chain ());
break;
case org.omg.CSI.ITTDistinguishedName.value:
org.omg.CSI.X501DistinguishedNameHelper.write (ostream, value.dn ());
break;
default:
org.omg.CSI.IdentityExtensionHelper.write (ostream, value.id ());
break;
}
}
}
| 3,357 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/CompleteEstablishContextHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/CompleteEstablishContextHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class CompleteEstablishContextHelper
{
private static String _id = "IDL:omg.org/CSI/CompleteEstablishContext:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.CompleteEstablishContext that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.CompleteEstablishContext extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
private static boolean __active = false;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
synchronized (org.omg.CORBA.TypeCode.class)
{
if (__typeCode == null)
{
if (__active)
{
return org.omg.CORBA.ORB.init().create_recursive_tc ( _id );
}
__active = true;
org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [3];
org.omg.CORBA.TypeCode _tcOf_members0 = null;
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulonglong);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.ContextIdHelper.id (), "ContextId", _tcOf_members0);
_members0[0] = new org.omg.CORBA.StructMember (
"client_context_id",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_boolean);
_members0[1] = new org.omg.CORBA.StructMember (
"context_stateful",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSSTokenHelper.id (), "GSSToken", _tcOf_members0);
_members0[2] = new org.omg.CORBA.StructMember (
"final_context_token",
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (org.omg.CSI.CompleteEstablishContextHelper.id (), "CompleteEstablishContext", _members0);
__active = false;
}
}
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.CompleteEstablishContext read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.CompleteEstablishContext value = new org.omg.CSI.CompleteEstablishContext ();
value.client_context_id = istream.read_ulonglong ();
value.context_stateful = istream.read_boolean ();
value.final_context_token = org.omg.CSI.GSSTokenHelper.read (istream);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.CompleteEstablishContext value)
{
ostream.write_ulonglong (value.client_context_id);
ostream.write_boolean (value.context_stateful);
org.omg.CSI.GSSTokenHelper.write (ostream, value.final_context_token);
}
}
| 3,358 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/X509CertificateChainHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/X509CertificateChainHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// representation of Certificate is as defined in [IETF RFC 2459].
public final class X509CertificateChainHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public X509CertificateChainHolder ()
{
}
public X509CertificateChainHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.X509CertificateChainHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.X509CertificateChainHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.X509CertificateChainHelper.type ();
}
}
| 3,359 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/X501DistinguishedNameHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/X501DistinguishedNameHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// octets containing the ASN.1 encoding.
public final class X501DistinguishedNameHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public X501DistinguishedNameHolder ()
{
}
public X501DistinguishedNameHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.X501DistinguishedNameHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.X501DistinguishedNameHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.X501DistinguishedNameHelper.type ();
}
}
| 3,360 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/SASContextBodyHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/SASContextBodyHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class SASContextBodyHelper
{
private static String _id = "IDL:omg.org/CSI/SASContextBody:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.SASContextBody that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.SASContextBody extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
org.omg.CORBA.TypeCode _disTypeCode0;
_disTypeCode0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_short);
_disTypeCode0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.MsgTypeHelper.id (), "MsgType", _disTypeCode0);
org.omg.CORBA.UnionMember[] _members0 = new org.omg.CORBA.UnionMember [4];
org.omg.CORBA.TypeCode _tcOf_members0;
org.omg.CORBA.Any _anyOf_members0;
// Branch for establish_msg (case label org.omg.CSI.MTEstablishContext.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_short ((short)org.omg.CSI.MTEstablishContext.value);
_tcOf_members0 = org.omg.CSI.EstablishContextHelper.type ();
_members0[0] = new org.omg.CORBA.UnionMember (
"establish_msg",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for complete_msg (case label org.omg.CSI.MTCompleteEstablishContext.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_short ((short)org.omg.CSI.MTCompleteEstablishContext.value);
_tcOf_members0 = org.omg.CSI.CompleteEstablishContextHelper.type ();
_members0[1] = new org.omg.CORBA.UnionMember (
"complete_msg",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for error_msg (case label org.omg.CSI.MTContextError.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_short ((short)org.omg.CSI.MTContextError.value);
_tcOf_members0 = org.omg.CSI.ContextErrorHelper.type ();
_members0[2] = new org.omg.CORBA.UnionMember (
"error_msg",
_anyOf_members0,
_tcOf_members0,
null);
// Branch for in_context_msg (case label org.omg.CSI.MTMessageInContext.value)
_anyOf_members0 = org.omg.CORBA.ORB.init ().create_any ();
_anyOf_members0.insert_short ((short)org.omg.CSI.MTMessageInContext.value);
_tcOf_members0 = org.omg.CSI.MessageInContextHelper.type ();
_members0[3] = new org.omg.CORBA.UnionMember (
"in_context_msg",
_anyOf_members0,
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_union_tc (org.omg.CSI.SASContextBodyHelper.id (), "SASContextBody", _disTypeCode0, _members0);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.SASContextBody read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.SASContextBody value = new org.omg.CSI.SASContextBody ();
short _dis0 = (short)0;
_dis0 = istream.read_short ();
switch (_dis0)
{
case org.omg.CSI.MTEstablishContext.value:
org.omg.CSI.EstablishContext _establish_msg = null;
_establish_msg = org.omg.CSI.EstablishContextHelper.read (istream);
value.establish_msg (_establish_msg);
break;
case org.omg.CSI.MTCompleteEstablishContext.value:
org.omg.CSI.CompleteEstablishContext _complete_msg = null;
_complete_msg = org.omg.CSI.CompleteEstablishContextHelper.read (istream);
value.complete_msg (_complete_msg);
break;
case org.omg.CSI.MTContextError.value:
org.omg.CSI.ContextError _error_msg = null;
_error_msg = org.omg.CSI.ContextErrorHelper.read (istream);
value.error_msg (_error_msg);
break;
case org.omg.CSI.MTMessageInContext.value:
org.omg.CSI.MessageInContext _in_context_msg = null;
_in_context_msg = org.omg.CSI.MessageInContextHelper.read (istream);
value.in_context_msg (_in_context_msg);
break;
default:
value._default( _dis0 ) ;
break;
}
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.SASContextBody value)
{
ostream.write_short (value.discriminator ());
switch (value.discriminator ())
{
case org.omg.CSI.MTEstablishContext.value:
org.omg.CSI.EstablishContextHelper.write (ostream, value.establish_msg ());
break;
case org.omg.CSI.MTCompleteEstablishContext.value:
org.omg.CSI.CompleteEstablishContextHelper.write (ostream, value.complete_msg ());
break;
case org.omg.CSI.MTContextError.value:
org.omg.CSI.ContextErrorHelper.write (ostream, value.error_msg ());
break;
case org.omg.CSI.MTMessageInContext.value:
org.omg.CSI.MessageInContextHelper.write (ostream, value.in_context_msg ());
break;
}
}
}
| 3,361 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/StringOIDHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/StringOIDHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// as: "oid:2.23.130"
abstract public class StringOIDHelper
{
private static String _id = "IDL:omg.org/CSI/StringOID:1.0";
public static void insert (org.omg.CORBA.Any a, String that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static String extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().create_string_tc (0);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.StringOIDHelper.id (), "StringOID", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static String read (org.omg.CORBA.portable.InputStream istream)
{
String value = null;
value = istream.read_string ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, String value)
{
ostream.write_string (value);
}
}
| 3,362 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ITTPrincipalName.java | package org.omg.CSI;
/**
* org/omg/CSI/ITTPrincipalName.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface ITTPrincipalName
{
public static final int value = (int)(2L);
}
| 3,363 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ContextError.java | package org.omg.CSI;
/**
* org/omg/CSI/ContextError.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class ContextError implements org.omg.CORBA.portable.IDLEntity
{
public long client_context_id = (long)0;
public int major_status = (int)0;
public int minor_status = (int)0;
public byte error_token[] = null;
public ContextError ()
{
} // ctor
public ContextError (long _client_context_id, int _major_status, int _minor_status, byte[] _error_token)
{
client_context_id = _client_context_id;
major_status = _major_status;
minor_status = _minor_status;
error_token = _error_token;
} // ctor
} // class ContextError
| 3,364 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ITTDistinguishedName.java | package org.omg.CSI;
/**
* org/omg/CSI/ITTDistinguishedName.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface ITTDistinguishedName
{
public static final int value = (int)(8L);
}
| 3,365 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MTEstablishContext.java | package org.omg.CSI;
/**
* org/omg/CSI/MTEstablishContext.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface MTEstablishContext
{
public static final short value = (short)(0);
}
| 3,366 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSSTokenHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/GSSTokenHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// tokens) is mechanism dependent.
public final class GSSTokenHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public GSSTokenHolder ()
{
}
public GSSTokenHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.GSSTokenHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.GSSTokenHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.GSSTokenHelper.type ();
}
}
| 3,367 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MessageInContext.java | package org.omg.CSI;
/**
* org/omg/CSI/MessageInContext.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class MessageInContext implements org.omg.CORBA.portable.IDLEntity
{
public long client_context_id = (long)0;
public boolean discard_context = false;
public MessageInContext ()
{
} // ctor
public MessageInContext (long _client_context_id, boolean _discard_context)
{
client_context_id = _client_context_id;
discard_context = _discard_context;
} // ctor
} // class MessageInContext
| 3,368 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityExtensionHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityExtensionHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class IdentityExtensionHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public IdentityExtensionHolder ()
{
}
public IdentityExtensionHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.IdentityExtensionHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.IdentityExtensionHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.IdentityExtensionHelper.type ();
}
}
| 3,369 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MTCompleteEstablishContext.java | package org.omg.CSI;
/**
* org/omg/CSI/MTCompleteEstablishContext.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface MTCompleteEstablishContext
{
public static final short value = (short)(1);
}
| 3,370 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityExtensionHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityExtensionHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class IdentityExtensionHelper
{
private static String _id = "IDL:omg.org/CSI/IdentityExtension:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.IdentityExtensionHelper.id (), "IdentityExtension", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,371 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSSTokenHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/GSSTokenHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// tokens) is mechanism dependent.
abstract public class GSSTokenHelper
{
private static String _id = "IDL:omg.org/CSI/GSSToken:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSSTokenHelper.id (), "GSSToken", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,372 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ITTAnonymous.java | package org.omg.CSI;
/**
* org/omg/CSI/ITTAnonymous.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface ITTAnonymous
{
public static final int value = (int)(1L);
}
| 3,373 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/OMGVMCID.java | package org.omg.CSI;
/**
* org/omg/CSI/OMGVMCID.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface OMGVMCID
{
// The OMG VMCID; same value as CORBA::OMGVMCID. Do not change ever.
public static final int value = (int)(0x4F4D0L);
}
| 3,374 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/SASContextBody.java | package org.omg.CSI;
/**
* org/omg/CSI/SASContextBody.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class SASContextBody implements org.omg.CORBA.portable.IDLEntity
{
private org.omg.CSI.EstablishContext ___establish_msg;
private org.omg.CSI.CompleteEstablishContext ___complete_msg;
private org.omg.CSI.ContextError ___error_msg;
private org.omg.CSI.MessageInContext ___in_context_msg;
private short __discriminator;
private boolean __uninitialized = true;
public SASContextBody ()
{
}
public short discriminator ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
return __discriminator;
}
public org.omg.CSI.EstablishContext establish_msg ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyestablish_msg (__discriminator);
return ___establish_msg;
}
public void establish_msg (org.omg.CSI.EstablishContext value)
{
__discriminator = org.omg.CSI.MTEstablishContext.value;
___establish_msg = value;
__uninitialized = false;
}
public void establish_msg (short discriminator, org.omg.CSI.EstablishContext value)
{
verifyestablish_msg (discriminator);
__discriminator = discriminator;
___establish_msg = value;
__uninitialized = false;
}
private void verifyestablish_msg (short discriminator)
{
if (discriminator != org.omg.CSI.MTEstablishContext.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public org.omg.CSI.CompleteEstablishContext complete_msg ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifycomplete_msg (__discriminator);
return ___complete_msg;
}
public void complete_msg (org.omg.CSI.CompleteEstablishContext value)
{
__discriminator = org.omg.CSI.MTCompleteEstablishContext.value;
___complete_msg = value;
__uninitialized = false;
}
public void complete_msg (short discriminator, org.omg.CSI.CompleteEstablishContext value)
{
verifycomplete_msg (discriminator);
__discriminator = discriminator;
___complete_msg = value;
__uninitialized = false;
}
private void verifycomplete_msg (short discriminator)
{
if (discriminator != org.omg.CSI.MTCompleteEstablishContext.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public org.omg.CSI.ContextError error_msg ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyerror_msg (__discriminator);
return ___error_msg;
}
public void error_msg (org.omg.CSI.ContextError value)
{
__discriminator = org.omg.CSI.MTContextError.value;
___error_msg = value;
__uninitialized = false;
}
public void error_msg (short discriminator, org.omg.CSI.ContextError value)
{
verifyerror_msg (discriminator);
__discriminator = discriminator;
___error_msg = value;
__uninitialized = false;
}
private void verifyerror_msg (short discriminator)
{
if (discriminator != org.omg.CSI.MTContextError.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public org.omg.CSI.MessageInContext in_context_msg ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyin_context_msg (__discriminator);
return ___in_context_msg;
}
public void in_context_msg (org.omg.CSI.MessageInContext value)
{
__discriminator = org.omg.CSI.MTMessageInContext.value;
___in_context_msg = value;
__uninitialized = false;
}
public void in_context_msg (short discriminator, org.omg.CSI.MessageInContext value)
{
verifyin_context_msg (discriminator);
__discriminator = discriminator;
___in_context_msg = value;
__uninitialized = false;
}
private void verifyin_context_msg (short discriminator)
{
if (discriminator != org.omg.CSI.MTMessageInContext.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public void _default ()
{
__discriminator = -32768;
__uninitialized = false;
}
public void _default (short discriminator)
{
verifyDefault( discriminator ) ;
__discriminator = discriminator ;
__uninitialized = false;
}
private void verifyDefault( short value )
{
switch (value) {
case org.omg.CSI.MTEstablishContext.value:
case org.omg.CSI.MTCompleteEstablishContext.value:
case org.omg.CSI.MTContextError.value:
case org.omg.CSI.MTMessageInContext.value:
throw new org.omg.CORBA.BAD_OPERATION() ;
default:
return;
}
}
} // class SASContextBody
| 3,375 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MessageInContextHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/MessageInContextHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class MessageInContextHelper
{
private static String _id = "IDL:omg.org/CSI/MessageInContext:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.MessageInContext that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.MessageInContext extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
private static boolean __active = false;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
synchronized (org.omg.CORBA.TypeCode.class)
{
if (__typeCode == null)
{
if (__active)
{
return org.omg.CORBA.ORB.init().create_recursive_tc ( _id );
}
__active = true;
org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [2];
org.omg.CORBA.TypeCode _tcOf_members0 = null;
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulonglong);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.ContextIdHelper.id (), "ContextId", _tcOf_members0);
_members0[0] = new org.omg.CORBA.StructMember (
"client_context_id",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_boolean);
_members0[1] = new org.omg.CORBA.StructMember (
"discard_context",
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (org.omg.CSI.MessageInContextHelper.id (), "MessageInContext", _members0);
__active = false;
}
}
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.MessageInContext read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.MessageInContext value = new org.omg.CSI.MessageInContext ();
value.client_context_id = istream.read_ulonglong ();
value.discard_context = istream.read_boolean ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.MessageInContext value)
{
ostream.write_ulonglong (value.client_context_id);
ostream.write_boolean (value.discard_context);
}
}
| 3,376 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MessageInContextHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/MessageInContextHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class MessageInContextHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.MessageInContext value = null;
public MessageInContextHolder ()
{
}
public MessageInContextHolder (org.omg.CSI.MessageInContext initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.MessageInContextHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.MessageInContextHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.MessageInContextHelper.type ();
}
}
| 3,377 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/KRB5MechOID.java | package org.omg.CSI;
/**
* org/omg/CSI/KRB5MechOID.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface KRB5MechOID
{
// gssapi(2) krb5(2) }
public static final String value = "oid:1.2.840.113554.1.2.2";
}
| 3,378 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/UTF8StringHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/UTF8StringHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// UTF-8 Encoding of String
public final class UTF8StringHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public UTF8StringHolder ()
{
}
public UTF8StringHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.UTF8StringHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.UTF8StringHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.UTF8StringHelper.type ();
}
}
| 3,379 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MTMessageInContext.java | package org.omg.CSI;
/**
* org/omg/CSI/MTMessageInContext.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface MTMessageInContext
{
public static final short value = (short)(5);
}
| 3,380 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSS_NT_ExportedNameListHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/GSS_NT_ExportedNameListHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class GSS_NT_ExportedNameListHelper
{
private static String _id = "IDL:omg.org/CSI/GSS_NT_ExportedNameList:1.0";
public static void insert (org.omg.CORBA.Any a, byte[][] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[][] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSS_NT_ExportedNameHelper.id (), "GSS_NT_ExportedName", __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSS_NT_ExportedNameListHelper.id (), "GSS_NT_ExportedNameList", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[][] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[][] = null;
int _len0 = istream.read_long ();
value = new byte[_len0][];
for (int _o1 = 0;_o1 < value.length; ++_o1)
value[_o1] = org.omg.CSI.GSS_NT_ExportedNameHelper.read (istream);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[][] value)
{
ostream.write_long (value.length);
for (int _i0 = 0;_i0 < value.length; ++_i0)
org.omg.CSI.GSS_NT_ExportedNameHelper.write (ostream, value[_i0]);
}
}
| 3,381 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ContextIdHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/ContextIdHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// identifier value of 0.
abstract public class ContextIdHelper
{
private static String _id = "IDL:omg.org/CSI/ContextId:1.0";
public static void insert (org.omg.CORBA.Any a, long that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static long extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulonglong);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.ContextIdHelper.id (), "ContextId", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static long read (org.omg.CORBA.portable.InputStream istream)
{
long value = (long)0;
value = istream.read_ulonglong ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, long value)
{
ostream.write_ulonglong (value);
}
}
| 3,382 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSS_NT_ExportedNameListHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/GSS_NT_ExportedNameListHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class GSS_NT_ExportedNameListHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[][] = null;
public GSS_NT_ExportedNameListHolder ()
{
}
public GSS_NT_ExportedNameListHolder (byte[][] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.GSS_NT_ExportedNameListHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.GSS_NT_ExportedNameListHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.GSS_NT_ExportedNameListHelper.type ();
}
}
| 3,383 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/UTF8StringHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/UTF8StringHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// UTF-8 Encoding of String
abstract public class UTF8StringHelper
{
private static String _id = "IDL:omg.org/CSI/UTF8String:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.UTF8StringHelper.id (), "UTF8String", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,384 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSS_NT_ExportedNameHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/GSS_NT_ExportedNameHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// Exported Name Object Format," p. 84.
public final class GSS_NT_ExportedNameHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public GSS_NT_ExportedNameHolder ()
{
}
public GSS_NT_ExportedNameHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.GSS_NT_ExportedNameHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.GSS_NT_ExportedNameHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.GSS_NT_ExportedNameHelper.type ();
}
}
| 3,385 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationElementHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationElementHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class AuthorizationElementHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.AuthorizationElement value = null;
public AuthorizationElementHolder ()
{
}
public AuthorizationElementHolder (org.omg.CSI.AuthorizationElement initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.AuthorizationElementHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.AuthorizationElementHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.AuthorizationElementHelper.type ();
}
}
| 3,386 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ContextErrorHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/ContextErrorHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class ContextErrorHolder implements org.omg.CORBA.portable.Streamable
{
public org.omg.CSI.ContextError value = null;
public ContextErrorHolder ()
{
}
public ContextErrorHolder (org.omg.CSI.ContextError initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.ContextErrorHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.ContextErrorHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.ContextErrorHelper.type ();
}
}
| 3,387 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityToken.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityToken.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class IdentityToken implements org.omg.CORBA.portable.IDLEntity
{
private boolean ___absent;
private boolean ___anonymous;
private byte[] ___principal_name;
private byte[] ___certificate_chain;
private byte[] ___dn;
private byte[] ___id;
private int __discriminator;
private boolean __uninitialized = true;
public IdentityToken ()
{
}
public int discriminator ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
return __discriminator;
}
public boolean absent ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyabsent (__discriminator);
return ___absent;
}
public void absent (boolean value)
{
__discriminator = org.omg.CSI.ITTAbsent.value;
___absent = value;
__uninitialized = false;
}
public void absent (int discriminator, boolean value)
{
verifyabsent (discriminator);
__discriminator = discriminator;
___absent = value;
__uninitialized = false;
}
private void verifyabsent (int discriminator)
{
if (discriminator != org.omg.CSI.ITTAbsent.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public boolean anonymous ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyanonymous (__discriminator);
return ___anonymous;
}
public void anonymous (boolean value)
{
__discriminator = org.omg.CSI.ITTAnonymous.value;
___anonymous = value;
__uninitialized = false;
}
public void anonymous (int discriminator, boolean value)
{
verifyanonymous (discriminator);
__discriminator = discriminator;
___anonymous = value;
__uninitialized = false;
}
private void verifyanonymous (int discriminator)
{
if (discriminator != org.omg.CSI.ITTAnonymous.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public byte[] principal_name ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyprincipal_name (__discriminator);
return ___principal_name;
}
public void principal_name (byte[] value)
{
__discriminator = org.omg.CSI.ITTPrincipalName.value;
___principal_name = value;
__uninitialized = false;
}
public void principal_name (int discriminator, byte[] value)
{
verifyprincipal_name (discriminator);
__discriminator = discriminator;
___principal_name = value;
__uninitialized = false;
}
private void verifyprincipal_name (int discriminator)
{
if (discriminator != org.omg.CSI.ITTPrincipalName.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public byte[] certificate_chain ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifycertificate_chain (__discriminator);
return ___certificate_chain;
}
public void certificate_chain (byte[] value)
{
__discriminator = org.omg.CSI.ITTX509CertChain.value;
___certificate_chain = value;
__uninitialized = false;
}
public void certificate_chain (int discriminator, byte[] value)
{
verifycertificate_chain (discriminator);
__discriminator = discriminator;
___certificate_chain = value;
__uninitialized = false;
}
private void verifycertificate_chain (int discriminator)
{
if (discriminator != org.omg.CSI.ITTX509CertChain.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public byte[] dn ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifydn (__discriminator);
return ___dn;
}
public void dn (byte[] value)
{
__discriminator = org.omg.CSI.ITTDistinguishedName.value;
___dn = value;
__uninitialized = false;
}
public void dn (int discriminator, byte[] value)
{
verifydn (discriminator);
__discriminator = discriminator;
___dn = value;
__uninitialized = false;
}
private void verifydn (int discriminator)
{
if (discriminator != org.omg.CSI.ITTDistinguishedName.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
public byte[] id ()
{
if (__uninitialized)
throw new org.omg.CORBA.BAD_OPERATION ();
verifyid (__discriminator);
return ___id;
}
public void id (byte[] value)
{
__discriminator = 0;
___id = value;
__uninitialized = false;
}
public void id (int discriminator, byte[] value)
{
verifyid (discriminator);
__discriminator = discriminator;
___id = value;
__uninitialized = false;
}
private void verifyid (int discriminator)
{
if (discriminator == org.omg.CSI.ITTAbsent.value || discriminator == org.omg.CSI.ITTAnonymous.value || discriminator == org.omg.CSI.ITTPrincipalName.value || discriminator == org.omg.CSI.ITTX509CertChain.value || discriminator == org.omg.CSI.ITTDistinguishedName.value)
throw new org.omg.CORBA.BAD_OPERATION ();
}
} // class IdentityToken
| 3,388 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationElementTypeHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationElementTypeHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// contain the VMCID allocated to the OMG (that is, 0x4F4D0).
abstract public class AuthorizationElementTypeHelper
{
private static String _id = "IDL:omg.org/CSI/AuthorizationElementType:1.0";
public static void insert (org.omg.CORBA.Any a, int that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static int extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulong);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.AuthorizationElementTypeHelper.id (), "AuthorizationElementType", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static int read (org.omg.CORBA.portable.InputStream istream)
{
int value = (int)0;
value = istream.read_ulong ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, int value)
{
ostream.write_ulong (value);
}
}
| 3,389 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ContextErrorHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/ContextErrorHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class ContextErrorHelper
{
private static String _id = "IDL:omg.org/CSI/ContextError:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.ContextError that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.ContextError extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
private static boolean __active = false;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
synchronized (org.omg.CORBA.TypeCode.class)
{
if (__typeCode == null)
{
if (__active)
{
return org.omg.CORBA.ORB.init().create_recursive_tc ( _id );
}
__active = true;
org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [4];
org.omg.CORBA.TypeCode _tcOf_members0 = null;
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulonglong);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.ContextIdHelper.id (), "ContextId", _tcOf_members0);
_members0[0] = new org.omg.CORBA.StructMember (
"client_context_id",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_long);
_members0[1] = new org.omg.CORBA.StructMember (
"major_status",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_long);
_members0[2] = new org.omg.CORBA.StructMember (
"minor_status",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSSTokenHelper.id (), "GSSToken", _tcOf_members0);
_members0[3] = new org.omg.CORBA.StructMember (
"error_token",
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (org.omg.CSI.ContextErrorHelper.id (), "ContextError", _members0);
__active = false;
}
}
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.ContextError read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.ContextError value = new org.omg.CSI.ContextError ();
value.client_context_id = istream.read_ulonglong ();
value.major_status = istream.read_long ();
value.minor_status = istream.read_long ();
value.error_token = org.omg.CSI.GSSTokenHelper.read (istream);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.ContextError value)
{
ostream.write_ulonglong (value.client_context_id);
ostream.write_long (value.major_status);
ostream.write_long (value.minor_status);
org.omg.CSI.GSSTokenHelper.write (ostream, value.error_token);
}
}
| 3,390 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/ITTX509CertChain.java | package org.omg.CSI;
/**
* org/omg/CSI/ITTX509CertChain.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface ITTX509CertChain
{
public static final int value = (int)(4L);
}
| 3,391 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationElementHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationElementHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class AuthorizationElementHelper
{
private static String _id = "IDL:omg.org/CSI/AuthorizationElement:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.AuthorizationElement that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.AuthorizationElement extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
private static boolean __active = false;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
synchronized (org.omg.CORBA.TypeCode.class)
{
if (__typeCode == null)
{
if (__active)
{
return org.omg.CORBA.ORB.init().create_recursive_tc ( _id );
}
__active = true;
org.omg.CORBA.StructMember[] _members0 = new org.omg.CORBA.StructMember [2];
org.omg.CORBA.TypeCode _tcOf_members0 = null;
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulong);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.AuthorizationElementTypeHelper.id (), "AuthorizationElementType", _tcOf_members0);
_members0[0] = new org.omg.CORBA.StructMember (
"the_type",
_tcOf_members0,
null);
_tcOf_members0 = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_sequence_tc (0, _tcOf_members0);
_tcOf_members0 = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.AuthorizationElementContentsHelper.id (), "AuthorizationElementContents", _tcOf_members0);
_members0[1] = new org.omg.CORBA.StructMember (
"the_element",
_tcOf_members0,
null);
__typeCode = org.omg.CORBA.ORB.init ().create_struct_tc (org.omg.CSI.AuthorizationElementHelper.id (), "AuthorizationElement", _members0);
__active = false;
}
}
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.AuthorizationElement read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.AuthorizationElement value = new org.omg.CSI.AuthorizationElement ();
value.the_type = istream.read_ulong ();
value.the_element = org.omg.CSI.AuthorizationElementContentsHelper.read (istream);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.AuthorizationElement value)
{
ostream.write_ulong (value.the_type);
org.omg.CSI.AuthorizationElementContentsHelper.write (ostream, value.the_element);
}
}
| 3,392 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationElement.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationElement.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class AuthorizationElement implements org.omg.CORBA.portable.IDLEntity
{
public int the_type = (int)0;
public byte the_element[] = null;
public AuthorizationElement ()
{
} // ctor
public AuthorizationElement (int _the_type, byte[] _the_element)
{
the_type = _the_type;
the_element = _the_element;
} // ctor
} // class AuthorizationElement
| 3,393 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/IdentityTokenTypeHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/IdentityTokenTypeHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
abstract public class IdentityTokenTypeHelper
{
private static String _id = "IDL:omg.org/CSI/IdentityTokenType:1.0";
public static void insert (org.omg.CORBA.Any a, int that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static int extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_ulong);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.IdentityTokenTypeHelper.id (), "IdentityTokenType", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static int read (org.omg.CORBA.portable.InputStream istream)
{
int value = (int)0;
value = istream.read_ulong ();
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, int value)
{
ostream.write_ulong (value);
}
}
| 3,394 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/GSS_NT_ExportedNameHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/GSS_NT_ExportedNameHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// Exported Name Object Format," p. 84.
abstract public class GSS_NT_ExportedNameHelper
{
private static String _id = "IDL:omg.org/CSI/GSS_NT_ExportedName:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.GSS_NT_ExportedNameHelper.id (), "GSS_NT_ExportedName", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,395 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/MTContextError.java | package org.omg.CSI;
/**
* org/omg/CSI/MTContextError.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public interface MTContextError
{
public static final short value = (short)(4);
}
| 3,396 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationTokenHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationTokenHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// AuthorizationElements
abstract public class AuthorizationTokenHelper
{
private static String _id = "IDL:omg.org/CSI/AuthorizationToken:1.0";
public static void insert (org.omg.CORBA.Any a, org.omg.CSI.AuthorizationElement[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static org.omg.CSI.AuthorizationElement[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CSI.AuthorizationElementHelper.type ();
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.AuthorizationTokenHelper.id (), "AuthorizationToken", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static org.omg.CSI.AuthorizationElement[] read (org.omg.CORBA.portable.InputStream istream)
{
org.omg.CSI.AuthorizationElement value[] = null;
int _len0 = istream.read_long ();
value = new org.omg.CSI.AuthorizationElement[_len0];
for (int _o1 = 0;_o1 < value.length; ++_o1)
value[_o1] = org.omg.CSI.AuthorizationElementHelper.read (istream);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, org.omg.CSI.AuthorizationElement[] value)
{
ostream.write_long (value.length);
for (int _i0 = 0;_i0 < value.length; ++_i0)
org.omg.CSI.AuthorizationElementHelper.write (ostream, value[_i0]);
}
}
| 3,397 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/OIDHelper.java | package org.omg.CSI;
/**
* org/omg/CSI/OIDHelper.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
// ASN.1 Encoding of an OBJECT IDENTIFIER
abstract public class OIDHelper
{
private static String _id = "IDL:omg.org/CSI/OID:1.0";
public static void insert (org.omg.CORBA.Any a, byte[] that)
{
org.omg.CORBA.portable.OutputStream out = a.create_output_stream ();
a.type (type ());
write (out, that);
a.read_value (out.create_input_stream (), type ());
}
public static byte[] extract (org.omg.CORBA.Any a)
{
return read (a.create_input_stream ());
}
private static org.omg.CORBA.TypeCode __typeCode = null;
synchronized public static org.omg.CORBA.TypeCode type ()
{
if (__typeCode == null)
{
__typeCode = org.omg.CORBA.ORB.init ().get_primitive_tc (org.omg.CORBA.TCKind.tk_octet);
__typeCode = org.omg.CORBA.ORB.init ().create_sequence_tc (0, __typeCode);
__typeCode = org.omg.CORBA.ORB.init ().create_alias_tc (org.omg.CSI.OIDHelper.id (), "OID", __typeCode);
}
return __typeCode;
}
public static String id ()
{
return _id;
}
public static byte[] read (org.omg.CORBA.portable.InputStream istream)
{
byte value[] = null;
int _len0 = istream.read_long ();
value = new byte[_len0];
istream.read_octet_array (value, 0, _len0);
return value;
}
public static void write (org.omg.CORBA.portable.OutputStream ostream, byte[] value)
{
ostream.write_long (value.length);
ostream.write_octet_array (value, 0, value.length);
}
}
| 3,398 |
0 | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg | Create_ds/geronimo-yoko/yoko-spec-corba/src/main/generated-sources/idl/org/omg/CSI/AuthorizationElementContentsHolder.java | package org.omg.CSI;
/**
* org/omg/CSI/AuthorizationElementContentsHolder.java .
* Error reading Messages File.
* Error reading Messages File.
* Thursday, January 14, 2010 1:08:58 AM PST
*/
public final class AuthorizationElementContentsHolder implements org.omg.CORBA.portable.Streamable
{
public byte value[] = null;
public AuthorizationElementContentsHolder ()
{
}
public AuthorizationElementContentsHolder (byte[] initialValue)
{
value = initialValue;
}
public void _read (org.omg.CORBA.portable.InputStream i)
{
value = org.omg.CSI.AuthorizationElementContentsHelper.read (i);
}
public void _write (org.omg.CORBA.portable.OutputStream o)
{
org.omg.CSI.AuthorizationElementContentsHelper.write (o, value);
}
public org.omg.CORBA.TypeCode _type ()
{
return org.omg.CSI.AuthorizationElementContentsHelper.type ();
}
}
| 3,399 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.