/**
*
* 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 org.omg.CORBA.ValueMember;
public 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) {
this.type = type;
setJavaName(name);
setIDLName(name);
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;
}
}
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 getJavaName().compareTo(desc.getJavaName());
}
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) {
return get(f.getDeclaringClass(), f.getType(), f.getName(), f);
}
static FieldDescriptor get(Class declaringClass, ObjectStreamField field) {
Field f = null;
try {
f = declaringClass.getDeclaredField(field.getName());
} catch (Exception ex) {
logger.finer("Cannot get java field \"" + field.getName()
+ "\" for class \"" + declaringClass.getName() + "\""
+ "\n" + ex);
}
return get(declaringClass, field.getType(), field.getName(), f);
}
static FieldDescriptor get(Class owner, Class type, String name,
java.lang.reflect.Field f) {
if (type.isPrimitive()) {
if (type == Boolean.TYPE) {
return new BooleanFieldDescriptor(owner, type, name, f);
} else if (type == Byte.TYPE) {
return new ByteFieldDescriptor(owner, type, name, f);
} else if (type == Short.TYPE) {
return new ShortFieldDescriptor(owner, type, name, f);
} else if (type == Character.TYPE) {
return new CharFieldDescriptor(owner, type, name, f);
} else if (type == Integer.TYPE) {
return new IntFieldDescriptor(owner, type, name, f);
} else if (type == Long.TYPE) {
return new LongFieldDescriptor(owner, type, name, f);
} else if (type == Float.TYPE) {
return new FloatFieldDescriptor(owner, type, name, f);
} else if (type == Double.TYPE) {
return new DoubleFieldDescriptor(owner, type, name, f);
} else {
throw new RuntimeException("unknown field type " + type);
}
} else {
if(org.omg.CORBA.Object.class.isAssignableFrom(type)) {
return new CorbaObjectFieldDescriptor(owner, type, name, f);
}
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);
} else if (java.rmi.Remote.class.isAssignableFrom(type)
|| java.rmi.Remote.class.equals(type))
{
return new RemoteFieldDescriptor(owner, type, name, f);
} else if (String.class.equals(type)) {
return new StringFieldDescriptor(owner, type, name, f);
} else if (java.io.Serializable.class.isAssignableFrom(type)) {
return new ValueFieldDescriptor(owner, type, name, f);
} else {
return new ObjectFieldDescriptor(owner, type, name, f);
}
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
pw.print(getJavaName());
pw.print("=");
try {
Object obj = field.get(val);
if (obj == null) {
pw.print("null");
} else {
TypeDescriptor desc = getTypeRepository().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) {
super(owner, type, name, f);
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
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 new InternalError(ex.getMessage());
}
}
});
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
/**
* @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(getJavaName(), 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(getJavaName());
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) {
super(owner, type, name, f);
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 new org.omg.CORBA.MARSHAL(ex.getMessage());
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeAny(field.get(obj));
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
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 new InternalError(ex.getMessage());
}
}
});
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
/**
* @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(getJavaName(), 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(getJavaName());
writer.writeAny(value);
}
}
class ValueFieldDescriptor extends FieldDescriptor {
ValueFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f) {
super(owner, type, name, f);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
field.set(obj, reader.readValueObject(getType()));
} catch (IllegalAccessException ex) {
throw new org.omg.CORBA.MARSHAL(ex.getMessage());
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeValueObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
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 new InternalError(ex.getMessage());
}
}
});
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
/**
* @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(getJavaName(), 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(getJavaName());
writer.writeValueObject(value);
}
}
class StringFieldDescriptor extends FieldDescriptor {
StringFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeValueObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.set(copy, field.get(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
/**
* @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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
String value = (String) map.get(getJavaName());
writer.writeValueObject(value);
}
}
class ObjectFieldDescriptor extends FieldDescriptor {
ObjectFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f) {
super(owner, type, name, f);
}
public void read(ObjectReader reader, Object obj)
throws java.io.IOException {
try {
field.set(obj, reader.readAbstractObject());
} catch (IllegalAccessException ex) {
throw new org.omg.CORBA.MARSHAL(ex.getMessage());
}
}
public void write(ObjectWriter writer, Object obj)
throws java.io.IOException {
try {
writer.writeObject(field.get(obj));
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
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 new InternalError(ex.getMessage());
}
}
});
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
/**
* @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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Object value = (Object) map.get(getJavaName());
writer.writeObject(value);
}
}
class BooleanFieldDescriptor extends FieldDescriptor {
BooleanFieldDescriptor(Class owner, Class type, String name,
java.lang.reflect.Field f) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setBoolean(copy, field.getBoolean(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Boolean value = (Boolean) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setByte(copy, field.getByte(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Byte value = (Byte) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setShort(copy, field.getShort(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Short value = (Short) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setChar(copy, field.getChar(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Character value = (Character) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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();
field.setInt(obj, value);
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setInt(copy, field.getInt(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Integer value = (Integer) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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();
field.setLong(obj, value);
} catch (IllegalAccessException ex) {
throw new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setLong(copy, field.getLong(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Long value = (Long) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setFloat(copy, field.getFloat(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Float value = (Float) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new IOException(ex.getMessage());
}
}
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 new IOException(ex.getMessage());
}
}
void copyState(Object orig, Object copy, CopyState state) {
try {
field.setDouble(copy, field.getDouble(orig));
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void print(java.io.PrintWriter pw, java.util.Map recurse, Object val) {
try {
pw.print(getJavaName());
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(getJavaName(), value);
}
/**
* @see org.apache.yoko.rmi.impl.FieldDescriptor#writeField(ObjectWriter, Map)
*/
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
Double value = (Double) map.get(getJavaName());
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) {
super(owner, type, name, f);
}
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 new InternalError(ex.getMessage());
}
}
});
} catch (IllegalAccessException ex) {
throw new InternalError(ex.getMessage());
}
}
void read(ObjectReader reader, Object obj) throws IOException {
Object value = reader.readCorbaObject(null);
try {
field.set(obj, value);
} catch (IllegalAccessException e) {
throw new IOException(e.getMessage());
}
}
void readFieldIntoMap(ObjectReader reader, Map map) throws IOException {
Object value = reader.readCorbaObject(null);
map.put(getJavaName(), value);
}
void write(ObjectWriter writer, Object obj) throws IOException {
try {
writer.writeCorbaObject(field.get(obj));
}
catch(IllegalAccessException e) {
throw new IOException(e.getMessage());
}
}
void writeFieldFromMap(ObjectWriter writer, Map map) throws IOException {
org.omg.CORBA.Object value = (org.omg.CORBA.Object) map.get(getJavaName());
writer.writeCorbaObject(value);
}
}