org.jboss.marshalling.river.RiverObjectOutputStream Maven / Gradle / Ivy
Go to download
This artifact provides a single jar that contains all classes required to use remote EJB and JMS, including
all dependencies. It is intended for use by those not using maven, maven users should just import the EJB and
JMS BOM's instead (shaded JAR's cause lots of problems with maven, as it is very easy to inadvertently end up
with different versions on classes on the class path).
/*
* JBoss, Home of Professional Open Source.
* Copyright 2014 Red Hat, Inc., and individual contributors
* as indicated by the @author tags.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jboss.marshalling.river;
import org.jboss.marshalling.MarshallerObjectOutputStream;
import org.jboss.marshalling.Marshaller;
import org.jboss.marshalling.util.BooleanFieldPutter;
import org.jboss.marshalling.util.ByteFieldPutter;
import org.jboss.marshalling.util.CharFieldPutter;
import org.jboss.marshalling.util.DoubleFieldPutter;
import org.jboss.marshalling.util.FloatFieldPutter;
import org.jboss.marshalling.util.IntFieldPutter;
import org.jboss.marshalling.util.LongFieldPutter;
import org.jboss.marshalling.util.ShortFieldPutter;
import org.jboss.marshalling.util.ObjectFieldPutter;
import org.jboss.marshalling.util.FieldPutter;
import org.jboss.marshalling.reflect.SerializableField;
import org.jboss.marshalling.reflect.SerializableClass;
import java.io.IOException;
import java.io.NotActiveException;
/**
*
*/
class RiverObjectOutputStream extends MarshallerObjectOutputStream {
private static final int OFF = 0;
private static final int UNWRITTEN_FIELDS = 1;
private static final int ON = 2;
private final RiverMarshaller marshaller;
private int state;
private RiverPutField putField;
private SerializableClass serializableClass;
private Object current;
protected RiverObjectOutputStream(final Marshaller delegateMarshaller, final RiverMarshaller marshaller) throws IOException, SecurityException {
super(delegateMarshaller);
this.marshaller = marshaller;
}
private boolean compareAndSetState(int expect, int set) {
if (state == expect) {
state = set;
return true;
}
return false;
}
private int getAndSetState(int set) {
try {
return state;
} finally {
state = set;
}
}
public void writeFields() throws IOException {
final RiverPutField putField = this.putField;
if (putField == null) {
throw new NotActiveException("no current PutField object");
}
if (! compareAndSetState(UNWRITTEN_FIELDS, ON)) {
throw new NotActiveException("writeFields() may only be called when the fields have not yet been written");
}
this.putField = null;
putField.write(marshaller);
}
public PutField putFields() throws IOException {
if (state == OFF) {
throw new NotActiveException("No object is currently being serialized");
}
if (putField == null) {
final SerializableField[] serializableFields = serializableClass.getFields();
final FieldPutter[] fields;
final String[] names;
final int cnt = serializableFields.length;
fields = new FieldPutter[cnt];
names = new String[cnt];
for (int i = 0; i < cnt; i ++) {
final SerializableField field = serializableFields[i];
names[i] = field.getName();
switch (field.getKind()) {
case BOOLEAN: {
fields[i] = new BooleanFieldPutter();
break;
}
case BYTE: {
fields[i] = new ByteFieldPutter();
break;
}
case CHAR: {
fields[i] = new CharFieldPutter();
break;
}
case DOUBLE: {
fields[i] = new DoubleFieldPutter();
break;
}
case FLOAT: {
fields[i] = new FloatFieldPutter();
break;
}
case INT: {
fields[i] = new IntFieldPutter();
break;
}
case LONG: {
fields[i] = new LongFieldPutter();
break;
}
case OBJECT: {
fields[i] = new ObjectFieldPutter(field.isUnshared());
break;
}
case SHORT: {
fields[i] = new ShortFieldPutter();
break;
}
}
}
putField = new RiverPutField(fields, names);
}
return putField;
}
protected SerializableClass swapClass(SerializableClass newSerializableClass) {
try {
return serializableClass;
} finally {
serializableClass = newSerializableClass;
}
}
protected Object swapCurrent(Object current) {
try {
return this.current;
} finally {
this.current = current;
}
}
public void defaultWriteObject() throws IOException {
if (! compareAndSetState(UNWRITTEN_FIELDS, ON)) {
throw new NotActiveException("writeFields() may only be called when the fields have not yet been written");
}
try {
marshaller.doWriteFields(serializableClass, current);
} finally {
putField = null;
serializableClass = null;
current = null;
}
}
protected int start() throws IOException {
return getAndSetState(UNWRITTEN_FIELDS);
}
protected void writeObjectOverride(final Object obj) throws IOException {
checkState();
super.writeObjectOverride(obj);
}
public void writeUnshared(final Object obj) throws IOException {
checkState();
super.writeUnshared(obj);
}
public void write(final int val) throws IOException {
checkState();
super.write(val);
}
public void write(final byte[] buf) throws IOException {
checkState();
super.write(buf);
}
public void write(final byte[] buf, final int off, final int len) throws IOException {
checkState();
super.write(buf, off, len);
}
public void writeBoolean(final boolean val) throws IOException {
checkState();
super.writeBoolean(val);
}
public void writeByte(final int val) throws IOException {
checkState();
super.writeByte(val);
}
public void writeShort(final int val) throws IOException {
checkState();
super.writeShort(val);
}
public void writeChar(final int val) throws IOException {
checkState();
super.writeChar(val);
}
public void writeInt(final int val) throws IOException {
checkState();
super.writeInt(val);
}
public void writeLong(final long val) throws IOException {
checkState();
super.writeLong(val);
}
public void writeFloat(final float val) throws IOException {
checkState();
super.writeFloat(val);
}
public void writeDouble(final double val) throws IOException {
checkState();
super.writeDouble(val);
}
public void writeBytes(final String str) throws IOException {
checkState();
super.writeBytes(str);
}
public void writeChars(final String str) throws IOException {
checkState();
super.writeChars(str);
}
public void writeUTF(final String str) throws IOException {
checkState();
super.writeUTF(str);
}
protected void finish(int restoreState) throws IOException {
try {
if (state == UNWRITTEN_FIELDS) {
marshaller.doWriteEmptyFields(serializableClass);
}
} finally {
state = restoreState;
}
}
private void checkState() throws IOException {
int state = this.state;
if (state == ON) {
return;
} else if (state == OFF) {
throw new NotActiveException("Object stream not active");
} else if (state == UNWRITTEN_FIELDS) {
this.state = ON;
marshaller.doWriteEmptyFields(serializableClass);
return;
} else {
throw new IllegalStateException("Unknown state");
}
}
protected void fullReset() {
state = OFF;
putField = null;
serializableClass = null;
current = null;
}
}