InputStream
*/
public int available() throws IOException
{
return 1;
}
public void close() throws IOException
{
}
public boolean readBoolean() throws IOException
{
return dis.readBoolean();
}
public byte readByte() throws IOException
{
return dis.readByte();
}
public int readUnsignedByte() throws IOException
{
return dis.readUnsignedByte();
}
public char readChar() throws IOException
{
return dis.readChar();
}
public short readShort() throws IOException
{
return dis.readShort();
}
public int readUnsignedShort() throws IOException
{
return dis.readUnsignedShort();
}
public int readInt() throws IOException
{
return dis.readInt();
}
public long readLong() throws IOException
{
return dis.readLong();
}
public float readFloat() throws IOException
{
return dis.readFloat();
}
public double readDouble() throws IOException
{
return dis.readDouble();
}
public void readFully(byte[] buf) throws IOException
{
dis.readFully(buf);
}
public void readFully(byte[] buf, int off, int len) throws IOException
{
dis.readFully(buf, off, len);
}
public int skipBytes(int len) throws IOException
{
return dis.skipBytes(len);
}
public String readLine() throws IOException
{
return dis.readLine();
}
public String readUTF() throws IOException
{
return StringUtil.readString(dis,buffer);
}
/*
* (non-Javadoc)
*
* @see java.io.ObjectInput#read(byte[])
*/
public int read(byte[] b) throws IOException
{
return dis.read(b);
}
/*
* (non-Javadoc)
*
* @see java.io.ObjectInput#skip(long)
*/
public long skip(long n) throws IOException
{
return dis.skip(n);
}
public ClassLoader getClassLoader() {
if (classLoader==null){
return Thread.currentThread().getContextClassLoader();
}
else
{
return classLoader;
}
}
public void setClassLoader(ClassLoader classLoader) {
this.classLoader = classLoader;
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/JBossObjectInputStreamSharedTree.java libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/JBossObjectInputStreamSharedTree.j0000644 0001750 0001750 00000004656 10433403266 033364 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.io;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import org.jboss.serial.objectmetamodel.DataContainer;
import org.jboss.serial.util.StringUtilBuffer;
/** This implementation will respect reset commands. */
public class JBossObjectInputStreamSharedTree extends JBossObjectInputStream
{
ObjectInput input = null;
DataContainer container = null;
public JBossObjectInputStreamSharedTree(InputStream is, ClassLoader loader, StringUtilBuffer buffer) throws IOException {
super(is, loader, buffer);
}
public JBossObjectInputStreamSharedTree(InputStream is, ClassLoader loader) throws IOException {
super(is, loader);
}
public JBossObjectInputStreamSharedTree(InputStream is, StringUtilBuffer buffer) throws IOException {
super(is, buffer);
}
public JBossObjectInputStreamSharedTree(InputStream is) throws IOException {
super(is);
}
public Object readObjectOverride() throws IOException, ClassNotFoundException {
if (input==null)
{
container = new DataContainer(classLoader,false,buffer);
container.setClassResolver(resolver);
input = container.getDirectInput(dis);
}
return input.readObject();
}
public ClassLoader getClassLoader() {
return super.getClassLoader();
}
public void setClassLoader(ClassLoader classLoader) {
if (container!=null)
{
container.getCache().setLoader(classLoader);
}
super.setClassLoader(classLoader);
}
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/JBossObjectOutputStream.java 0000644 0001750 0001750 00000024113 10470273274 032301 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.io;
import org.jboss.serial.objectmetamodel.DataContainer;
import org.jboss.serial.objectmetamodel.DataContainerConstants;
import org.jboss.serial.objectmetamodel.ObjectSubstitutionInterface;
import org.jboss.serial.objectmetamodel.safecloning.SafeCloningRepository;
import org.jboss.serial.exception.SerializationException;
import org.jboss.serial.util.StringUtilBuffer;
import org.jboss.serial.util.StringUtil;
import java.io.*;
import java.lang.reflect.Field;
/**
* @author Clebert Suconic
*/
public class JBossObjectOutputStream extends ObjectOutputStream implements DataContainerConstants
{
OutputStream output;
DataOutputStream dataOutput;
boolean checkSerializableClass=false;
static Field fieldEnableReplace;
/** one of the optimizations we do is to reuse byte arrays on writeUTF operations, look at {@link org.jboss.serial.util.StringUtil}.
* StringUtil has also the capability of creating Buffers on ThreadLocal over demand, but having these buffers pre-created
* is more efficient */
StringUtilBuffer buffer;
static
{
try {
fieldEnableReplace = ObjectOutputStream.class.getDeclaredField("enableReplace");
fieldEnableReplace.setAccessible(true);
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
protected ObjectSubstitutionInterface getSubstitutionInterface() throws IOException
{
try
{
if (fieldEnableReplace.getBoolean(this))
{
return new ObjectSubstitutionInterface()
{
public Object replaceObject(Object obj) throws IOException {
return JBossObjectOutputStream.this.replaceObject(obj);
}
};
} else
{
return null;
}
}
catch (IllegalAccessException ex)
{
throw new SerializationException(ex.getMessage(),ex);
}
}
protected boolean enableReplaceObject(boolean enable)
{
try
{
if (enable == fieldEnableReplace.getBoolean(this)) {
return enable;
}
fieldEnableReplace.setBoolean(this,enable);
return !fieldEnableReplace.getBoolean(this);
}
catch (Exception e)
{
e.printStackTrace();
// trying the super method
return super.enableReplaceObject(enable);
}
}
/**Creates an OutputStream, that by default doesn't require */
public JBossObjectOutputStream(OutputStream output) throws IOException
{
this(output,false);
}
/**Creates an OutputStream, that by default doesn't require */
public JBossObjectOutputStream(OutputStream output,StringUtilBuffer buffer) throws IOException
{
this(output,false,buffer);
}
public JBossObjectOutputStream(OutputStream output, boolean checkSerializableClass) throws IOException
{
this(output,checkSerializableClass,null);
}
public JBossObjectOutputStream(OutputStream output, boolean checkSerializableClass,StringUtilBuffer buffer) throws IOException
{
super();
if (output!=null)
{
output.write(openSign);
}
this.buffer=buffer;
this.output=output;
this.checkSerializableClass=checkSerializableClass;
if (output instanceof DataOutputStream)
{
dataOutput = (DataOutputStream) output;
}
else
{
dataOutput = new DataOutputStream(output);
}
}
public void writeObjectUsingDataContainer(Object obj) throws IOException {
DataContainer dataContainer = new DataContainer(null,this.getSubstitutionInterface(),checkSerializableClass,buffer);
if (output instanceof DataOutputStream)
{
dataOutput = (DataOutputStream) output;
}
else
{
dataOutput = new DataOutputStream(output);
}
ObjectOutput objectOutput = dataContainer.getOutput();
objectOutput.writeObject(obj);
//objectOutput.flush();
dataContainer.saveData(dataOutput);
//this.flush();
}
protected void writeObjectOverride(Object obj) throws IOException {
DataContainer dataContainer = new DataContainer(null,this.getSubstitutionInterface(),checkSerializableClass,buffer);
if (output instanceof DataOutputStream)
{
dataOutput = (DataOutputStream) output;
}
else
{
dataOutput = new DataOutputStream(output);
}
dataContainer.setStringBuffer(buffer);
ObjectOutput objectOutput = dataContainer.getDirectOutput(this.dataOutput);
objectOutput.writeObject(obj);
//objectOutput.flush();
//dataContainer.saveData(dataOutput);
//this.flush();
}
public void writeUnshared(Object obj) throws IOException {
writeObjectOverride(obj);
}
public void defaultWriteObject() throws IOException {
}
public void writeFields() throws IOException {
}
public void reset() throws IOException {
}
protected void writeStreamHeader() throws IOException {
}
protected void writeClassDescriptor(ObjectStreamClass desc)
throws IOException
{
}
/**
* Writes a byte. This method will block until the byte is actually
* written.
*
* @param val the byte to be written to the stream
* @throws IOException If an I/O error has occurred.
*/
public void write(int val) throws IOException {
dataOutput.write(val);
}
/**
* Writes an array of bytes. This method will block until the bytes are
* actually written.
*
* @param buf the data to be written
* @throws IOException If an I/O error has occurred.
*/
public void write(byte[] buf) throws IOException {
dataOutput.write(buf);
}
public void write(byte[] buf, int off, int len) throws IOException {
if (buf == null) {
throw new SerializationException("buf parameter can't be null");
}
dataOutput.write(buf, off, len);
}
/**
* Flushes the stream. This will write any buffered output bytes and flush
* through to the underlying stream.
*
* @throws IOException If an I/O error has occurred.
*/
public void flush() throws IOException {
if (dataOutput!=null)
{
dataOutput.flush();
}
else
{
output.flush();
}
}
protected void drain() throws IOException {
//bout.drain();
}
public void close() throws IOException {
flush();
dataOutput.close();
}
public void writeBoolean(boolean val) throws IOException {
dataOutput.writeBoolean(val);
}
public void writeByte(int val) throws IOException {
dataOutput.writeByte(val);
}
public void writeShort(int val) throws IOException {
dataOutput.writeShort(val);
}
public void writeChar(int val) throws IOException {
dataOutput.writeChar(val);
}
public void writeInt(int val) throws IOException {
dataOutput.writeInt(val);
}
public void writeLong(long val) throws IOException {
dataOutput.writeLong(val);
}
public void writeFloat(float val) throws IOException {
dataOutput.writeFloat(val);
}
public void writeDouble(double val) throws IOException {
dataOutput.writeDouble(val);
}
public void writeBytes(String str) throws IOException {
dataOutput.writeBytes(str);
}
public void writeChars(String str) throws IOException {
dataOutput.writeChars(str);
}
public void writeUTF(String str) throws IOException {
StringUtil.saveString(dataOutput,str,buffer);
}
/** Reuses every primitive value to recreate another object. */
public Object smartClone(Object obj) throws IOException
{
return smartClone(obj,null,Thread.currentThread().getContextClassLoader());
}
/** Reuses every primitive value to recreate another object. */
public Object smartClone(Object obj, SafeCloningRepository safeToReuse) throws IOException
{
return smartClone(obj,safeToReuse,Thread.currentThread().getContextClassLoader());
}
/** Reuses every primitive value to recreate another object.
* and if safeToReuse!=null, it can reuse the entire object */
public Object smartClone(Object obj, SafeCloningRepository safeToReuse, ClassLoader loader) throws IOException
{
DataContainer container = new DataContainer(loader,this.getSubstitutionInterface(),safeToReuse,checkSerializableClass,buffer);
ObjectOutput output = container.getOutput();
output.writeObject(obj);
output.flush();
ObjectInput input = container.getInput();
try
{
return input.readObject();
}
catch (ClassNotFoundException e)
{
throw new SerializationException (e.getMessage(),e);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/JBossObjectOutputStreamSharedTree.java libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/JBossObjectOutputStreamSharedTree.0000644 0001750 0001750 00000005565 10433403266 033413 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.io;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.OutputStream;
import org.jboss.serial.objectmetamodel.DataContainer;
import org.jboss.serial.objectmetamodel.DataContainerConstants;
import org.jboss.serial.util.ClassMetaConsts;
import org.jboss.serial.util.StringUtilBuffer;
/** This implementation will respect reset commands. */
public class JBossObjectOutputStreamSharedTree extends JBossObjectOutputStream
{
ObjectOutput objectOutput;
DataContainer dataContainer;
public JBossObjectOutputStreamSharedTree(OutputStream output, boolean checkSerializableClass, StringUtilBuffer buffer) throws IOException {
super(output, checkSerializableClass, buffer);
}
public JBossObjectOutputStreamSharedTree(OutputStream output, boolean checkSerializableClass) throws IOException {
super(output, checkSerializableClass);
}
public JBossObjectOutputStreamSharedTree(OutputStream output, StringUtilBuffer buffer) throws IOException {
super(output, buffer);
}
public JBossObjectOutputStreamSharedTree(OutputStream output) throws IOException {
super(output);
}
protected void writeObjectOverride(Object obj) throws IOException {
checkOutput();
objectOutput.writeObject(obj);
}
public void reset() throws IOException {
checkOutput();
objectOutput.writeByte(DataContainerConstants.RESET);
dataContainer.getCache().reset();
}
private void checkOutput() throws IOException {
if (objectOutput==null)
{
dataContainer = new DataContainer(null,this.getSubstitutionInterface(),checkSerializableClass,buffer);
if (output instanceof DataOutputStream)
{
dataOutput = (DataOutputStream) output;
}
else
{
dataOutput = new DataOutputStream(output);
}
objectOutput = dataContainer.getDirectOutput(this.dataOutput);
}
}
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/MarshalledObject.java 0000644 0001750 0001750 00000005243 10334433312 030731 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.Arrays;
/**
* Turns content into a byte array that is delayed in unmarshalling. JBoss Serialization
* equivalent to java.rmi.MarshalledObject
*
* @author Bill Burke
* @version $Revision: 1.1 $
*/
public class MarshalledObject implements Serializable
{
private byte[] bytes;
private int hash;
static final long serialVersionUID = -1433248532959364465L;
public MarshalledObject() {}
public MarshalledObject(Object obj) throws java.io.IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
JBossObjectOutputStream mvos = new JBossObjectOutputStream(baos);
mvos.writeObject(obj);
mvos.flush();
bytes = baos.toByteArray();
mvos.close();
hash = 0;
for (int i = 0; i < bytes.length; i++)
{
hash += bytes[i];
}
}
public Object get() throws IOException, ClassNotFoundException
{
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
JBossObjectInputStream ois = new JBossObjectInputStream(bais);
try
{
return ois.readObject();
}
finally
{
ois.close();
bais.close();
}
}
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
final MarshalledObject that = (MarshalledObject) o;
if (!Arrays.equals(bytes, that.bytes)) return false;
return true;
}
public int hashCode()
{
return hash;
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/MarshalledObjectForLocalCalls.java libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/io/MarshalledObjectForLocalCalls.java0000644 0001750 0001750 00000004601 10433403266 033334 0 ustar twerner twerner package org.jboss.serial.io;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import org.apache.log4j.Logger;
import org.jboss.serial.classmetamodel.ClassMetaData;
import org.jboss.serial.objectmetamodel.DataContainer;
import org.jboss.serial.objectmetamodel.safecloning.SafeCloningRepository;
import org.jboss.serial.util.StringUtil;
/**
* This is the equivalent for MarshalledObject on RMI, but this is optimized for local calls.
* Instead of converting every single field into Bytes, this will use a DataContainer.
* @author Clebert Suconic
*/
public class MarshalledObjectForLocalCalls implements Externalizable
{
private static final long serialVersionUID = 785809358605094514L;
private static final Logger log = Logger.getLogger(ClassMetaData.class);
private static final boolean isDebug = log.isDebugEnabled();
DataContainer container;
public MarshalledObjectForLocalCalls()
{
}
public MarshalledObjectForLocalCalls(Object obj) throws IOException
{
container = new DataContainer(false);
ObjectOutput output = container.getOutput();
output.writeObject(obj);
output.flush();
container.flush();
}
public MarshalledObjectForLocalCalls(Object obj, SafeCloningRepository safeToReuse) throws IOException
{
container = new DataContainer(null, null, safeToReuse, false,null);
ObjectOutput output = container.getOutput();
output.writeObject(obj);
output.flush();
container.flush();
}
/**
* The object has to be unserialized only when the first get is executed.
*/
public Object get() throws IOException, ClassNotFoundException
{
try
{
container.getCache().setLoader(Thread.currentThread().getContextClassLoader());
return container.getInput().readObject();
}
catch(RuntimeException e)
{
log.error(e, e);
throw e;
}
}
public void writeExternal(ObjectOutput out) throws IOException
{
if (isDebug)
{
log.debug("writeExternal");
}
container.saveData(out);
}
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
if (isDebug)
{
log.debug("readExternal");
}
container = new DataContainer(false);
container.loadData(in);
}
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/ 0000755 0001750 0001750 00000000000 10477615512 027422 5 ustar twerner twerner libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/safecloning/ 0000755 0001750 0001750 00000000000 10477615512 031712 5 ustar twerner twerner ././@LongLink 0000000 0000000 0000000 00000000152 00000000000 011563 L ustar root root libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/safecloning/SafeClone.java libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/safecloning/SafeClone0000644 0001750 0001750 00000002263 10377605426 033501 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.objectmetamodel.safecloning;
/**
* @author Tom Elrod
*/
public interface SafeClone {
public boolean isSafeToReuse(Object obj);
}
././@LongLink 0000000 0000000 0000000 00000000166 00000000000 011570 L ustar root root libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/safecloning/SafeCloningRepository.java libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/safecloning/SafeCloni0000644 0001750 0001750 00000005616 10425471520 033500 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.objectmetamodel.safecloning;
import gnu.trove.TObjectIntHashMap;
import java.util.ArrayList;
import org.apache.log4j.Logger;
import org.jboss.serial.util.ClassMetaConsts;
/**
* $Id: SafeCloningRepository.java,v 1.6 2006/05/02 04:45:03 csuconic Exp $
*
* Some objects may be completely reused during cloning operations. (For instance InvocationContext)
*
* @author Clebert Suconic
*/
public class SafeCloningRepository implements ClassMetaConsts {
private static final Logger log = Logger.getLogger(SafeCloningRepository.class);
private static final boolean isDebug = log.isDebugEnabled();
public SafeCloningRepository(SafeClone safeClone)
{
this.safeClone = safeClone;
}
private SafeClone safeClone;
TObjectIntHashMap safeToReuse = new TObjectIntHashMap(identityHashStrategy);
ArrayList reuse = new ArrayList();
public void clear()
{
reuse.clear();
safeToReuse.clear();
}
public int storeSafe(Object obj)
{
if (safeClone.isSafeToReuse(obj))
{
int description=safeToReuse.get(obj);
if (description==0)
{
safeToReuse.put(obj,safeToReuse.size()+1);
description = safeToReuse.size();
if (isDebug)
{
log.debug("storeSafe::Created a new storeSafe Reference=" + description + " obj=" + obj.getClass().getName());
}
reuse.add(obj);
}
return description;
} else
{
return 0;
}
}
public Object findReference(int reference)
{
Object retobject = reuse.get(reference-1);
if (isDebug)
{
if (retobject!=null)
{
log.debug("findReference::found reference " + reference + " on an object=" + retobject.getClass().getName());
}
}
return retobject;
}
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/objectmetamodel/DataContainer.java 0000644 0001750 0001750 00000131210 10474543366 033003 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.objectmetamodel;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.Iterator;
import org.jboss.serial.classmetamodel.ClassMetamodelFactory;
import org.jboss.serial.classmetamodel.ClassResolver;
import org.jboss.serial.exception.SerializationException;
import org.jboss.serial.finalcontainers.BooleanContainer;
import org.jboss.serial.finalcontainers.ByteContainer;
import org.jboss.serial.finalcontainers.CharacterContainer;
import org.jboss.serial.finalcontainers.DoubleContainer;
import org.jboss.serial.finalcontainers.FloatContainer;
import org.jboss.serial.finalcontainers.IntegerContainer;
import org.jboss.serial.finalcontainers.LongContainer;
import org.jboss.serial.finalcontainers.ShortContainer;
import org.jboss.serial.objectmetamodel.safecloning.SafeCloningRepository;
import org.jboss.serial.util.StringUtil;
import org.jboss.serial.util.StringUtilBuffer;
/**
* DataContainer is a Container of Immutables and Object References.
* It emmulates the repository as it would be a DataOutputStream and DataInputStream
*
* $Id: DataContainer.java,v 1.44 2006/08/28 18:35:34 csuconic Exp $
*
* @author clebert suconic
*/
public class DataContainer extends DataExport implements DataContainerConstants, Externalizable
{
/** These are the bytes used during streaming of Datacontainer. They are used to control and they are mixed within content.
* So, they should be read in the same order they were written */
byte[] controlStreaming;
DataContainerOutput currentOutput = null;
ArrayList content = new ArrayList();
/** I used the transient tag as a documentation feature.
* this contains the root objectCache being used.
* It would be possible to use ThreadLocals for this.
* But I didn't want to take the risk of having problems when the application was running
* in ThreadPools generating leaks.*/
transient ObjectsCache cache;
public DataContainer cloneContainer()
{
DataContainer newContainer = new DataContainer();
newContainer.content = this.content;
newContainer.controlStreaming = this.controlStreaming;
newContainer.cache = this.cache.cloneCache();
return newContainer;
}
private DataContainer()
{
}
public DataContainer(boolean checkSerializable)
{
this ((ClassLoader)null, checkSerializable,null);
}
public DataContainer(boolean checkSerializable, StringUtilBuffer buffer)
{
this ((ClassLoader)null, checkSerializable,buffer);
}
public DataContainer(ClassLoader loader, boolean checkSerializable, StringUtilBuffer buffer)
{
this(loader,null,checkSerializable,buffer);
}
public DataContainer(ClassLoader loader, boolean checkSerializable, StringUtilBuffer buffer,ClassResolver resolver)
{
this(loader,null,checkSerializable,buffer);
}
public DataContainer(ClassLoader loader, ObjectSubstitutionInterface substitution, boolean checkSerializable)
{
this(loader,substitution,null,checkSerializable,null);
}
public DataContainer(ClassLoader loader, ObjectSubstitutionInterface substitution, boolean checkSerializable, StringUtilBuffer buffer)
{
this(loader,substitution,null,checkSerializable,buffer);
}
public DataContainer(ClassLoader loader, ObjectSubstitutionInterface substitution, SafeCloningRepository safeToReuse, boolean checkSerializable)
{
this();
this.cache=new ObjectsCache(substitution,loader,safeToReuse,checkSerializable,null);
}
public DataContainer(ClassLoader loader, ObjectSubstitutionInterface substitution, SafeCloningRepository safeToReuse, boolean checkSerializable, StringUtilBuffer buffer)
{
this();
this.cache=new ObjectsCache(substitution,loader,safeToReuse,checkSerializable,buffer);
}
public DataContainer(ObjectsCache cache)
{
this.cache=cache;
}
public int getSize()
{
return content.size();
}
public ObjectInput getInput()
{
return new DataContainerInput();
}
public ObjectOutput getOutput()
{
if (currentOutput==null)
{
currentOutput = new DataContainerOutput();
}
return currentOutput;
}
public ObjectOutput getDirectOutput(DataOutputStream dataOut)
{
return new DataContainerDirectOutput(dataOut);
}
public ObjectInput getDirectInput(DataInputStream dataInput)
{
return new DataContainerDirectInput(dataInput);
}
public void flush() throws IOException
{
if (currentOutput!=null)
{
currentOutput.flushByteArray();
}
}
class DataContainerDirectOutput implements ObjectsCache.JBossSeralizationOutputInterface
{
DataOutputStream dataOut;
public void addObjectReference(int reference) throws IOException {
this.writeInt(reference);
}
public void openObjectDefinition() throws IOException {
}
public void closeObjectDefinition() throws IOException {
}
public void writeByteDirectly(byte parameter) throws IOException {
this.write(parameter);
}
public boolean isCheckSerializableClass() {
return DataContainer.this.getCache().isCheckSerializableClass();
}
public void writeObject(Object obj) throws IOException {
DataContainer.this.cache.setOutput(this);
if (cache.getSubstitution()!=null)
{
obj = cache.getSubstitution().replaceObject(obj);
}
ObjectDescriptorFactory.describeObject(DataContainer.this.cache,obj);
}
public void write(byte b[]) throws IOException {
dataOut.write(b);
}
public void close() throws IOException {
dataOut.close();
}
public DataContainerDirectOutput(DataOutputStream dataOut) {
this.dataOut = dataOut;
}
public void write(int b) throws IOException {
dataOut.write(b);
}
public void write(byte[] b, int off, int len) throws IOException {
dataOut.write(b, off, len);
}
public void flush() throws IOException {
dataOut.flush();
}
public void writeBoolean(boolean v) throws IOException {
dataOut.writeBoolean(v);
}
public void writeByte(int v) throws IOException {
dataOut.writeByte(v);
}
public void writeShort(int v) throws IOException {
dataOut.writeShort(v);
}
public void writeChar(int v) throws IOException {
dataOut.writeChar(v);
}
public void writeInt(int v) throws IOException {
dataOut.writeInt(v);
}
public void writeLong(long v) throws IOException {
dataOut.writeLong(v);
}
public void writeFloat(float v) throws IOException {
dataOut.writeFloat(v);
}
public void writeDouble(double v) throws IOException {
dataOut.writeDouble(v);
}
public void writeBytes(String s) throws IOException {
dataOut.writeBytes(s);
}
public void writeChars(String s) throws IOException {
dataOut.writeChars(s);
}
public void writeUTF(String str) throws IOException {
StringUtil.saveString(dataOut,str,cache.getStringBuffer());
}
public int size() {
return dataOut.size();
}
public void saveImmutable(ObjectsCache cache, Object obj) throws IOException {
int id=cache.findIdInCacheWrite(obj);
if (id!=0)
{
this.writeByte(DataContainerConstants.IMMUTABLE_OBJREF);
this.addObjectReference(id);
return;
}
id=cache.putObjectInCacheWrite(obj);
if (obj instanceof String)
{
this.writeByte(DataContainerConstants.STRING);
this.addObjectReference(id);
StringUtil.saveString(this,(String)obj,cache.getStringBuffer());
} else
if (obj instanceof Byte)
{
this.writeByte(DataContainerConstants.BYTE);
this.addObjectReference(id);
this.writeByte(((Byte)obj).byteValue());
} else
if (obj instanceof Character)
{
this.writeByte(DataContainerConstants.CHARACTER);
this.addObjectReference(id);
this.writeChar(((Character)obj).charValue());
} else
if (obj instanceof Short)
{
this.writeByte(DataContainerConstants.SHORT);
this.addObjectReference(id);
this.writeShort(((Short)obj).shortValue());
} else
if (obj instanceof Integer)
{
this.writeByte(DataContainerConstants.INTEGER);
this.addObjectReference(id);
this.writeInt(((Integer)obj).intValue());
} else
if (obj instanceof Long)
{
this.writeByte(DataContainerConstants.LONG);
this.addObjectReference(id);
this.writeLong(((Long)obj).longValue());
} else
if (obj instanceof Double)
{
this.writeByte(DataContainerConstants.DOUBLE);
this.addObjectReference(id);
this.writeDouble(((Double)obj).doubleValue());
} else
if (obj instanceof Float)
{
this.writeByte(DataContainerConstants.FLOAT);
this.addObjectReference(id);
this.writeFloat(((Float)obj).floatValue());
} else
if (obj instanceof BooleanContainer || obj instanceof Boolean)
{
this.writeByte(DataContainerConstants.BOOLEAN);
this.addObjectReference(id);
this.writeBoolean(((Boolean)obj).booleanValue());
} else
{
throw new SerializationException("I don't know how to write type " + obj.getClass().getName() + " yet");
}
}
}
class DataContainerOutput implements ObjectsCache.JBossSeralizationOutputInterface
{
/** outByte is used to hold writeByte operations until we start doing a different operation */
ByteArrayOutputStream outByte=new ByteArrayOutputStream();
//DataOutputStream dataOutput = null;
private void flushByteArray()
{
if (outByte!=null)
{
byte controlStreaming[] = outByte.toByteArray();
DataContainer.this.setControlStreaming(controlStreaming);
}
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#writeObject(java.lang.Object)
*/
public void writeObject(Object obj) throws IOException
{
if (obj==null)
{
this.writeByte(DataContainerConstants.NULLREF);
}
else
{
if (ClassMetamodelFactory.isImmutable(obj.getClass()))
{
if (cache.getSubstitution()!=null)
{
obj = cache.getSubstitution().replaceObject(obj);
}
}
DataContainer.this.cache.setOutput(this);
ObjectDescriptorFactory.describeObject(DataContainer.this.cache,obj);
}
}
public void addObjectReference(int reference) throws IOException
{
this.writeInt(reference);
}
public void saveImmutable(ObjectsCache cache, Object obj) throws IOException {
if (obj instanceof String)
{
this.writeByte(DataContainerConstants.STRING);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Byte)
{
this.writeByte(DataContainerConstants.BYTE);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Character)
{
this.writeByte(DataContainerConstants.CHARACTER);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Short)
{
this.writeByte(DataContainerConstants.SHORT);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Integer)
{
this.writeByte(DataContainerConstants.INTEGER);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Long)
{
this.writeByte(DataContainerConstants.LONG);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Double)
{
this.writeByte(DataContainerConstants.DOUBLE);
DataContainer.this.content.add(obj);
} else
if (obj instanceof Float)
{
this.writeByte(DataContainerConstants.FLOAT);
DataContainer.this.content.add(obj);
} else
if (obj instanceof BooleanContainer || obj instanceof Boolean)
{
this.writeByte(DataContainerConstants.BOOLEAN);
DataContainer.this.content.add(obj);
} else
{
throw new SerializationException("I don't know how to write type " + obj.getClass().getName() + " yet");
}
}
public void writeByteDirectly(byte parameter) throws IOException {
writeByte(parameter);
}
public void openObjectDefinition() throws IOException {
//TODO: -TME Implement
}
public void closeObjectDefinition() throws IOException {
//TODO: -TME Implement
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#write(int)
*/
public void write(int b) throws IOException
{
outByte.write(b);
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#write(byte[])
*/
public void write(byte[] b) throws IOException
{
outByte.write(b);
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#write(byte[], int, int)
*/
public void write(byte[] b, int off, int len) throws IOException
{
outByte.write(b,off,len);
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#flush()
*/
public void flush() throws IOException
{
flushByteArray();
}
/* (non-Javadoc)
* @see java.io.ObjectOutput#close()
*/
public void close() throws IOException
{
flush();
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeBoolean(boolean)
*/
public void writeBoolean(boolean v) throws IOException
{
content.add(BooleanContainer.valueOf(v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeByte(int)
*/
public void writeByte(int v) throws IOException
{
//createByteArray();
outByte.write(v);
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeShort(int)
*/
public void writeShort(int v) throws IOException
{
//DataContainer.this.content.add(Short.valueOf((short)v));
DataContainer.this.content.add(new ShortContainer((short)v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeChar(int)
*/
public void writeChar(int v) throws IOException
{
//flush();
DataContainer.this.content.add(new CharacterContainer((char)v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeInt(int)
*/
public void writeInt(int v) throws IOException
{
//flush();
//DataContainer.this.content.add(Integer.valueOf(v));
DataContainer.this.content.add(new IntegerContainer(v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeLong(long)
*/
public void writeLong(long v) throws IOException
{
//flush();
//DataContainer.this.content.add(Long.valueOf(v));
DataContainer.this.content.add(new LongContainer(v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeFloat(float)
*/
public void writeFloat(float v) throws IOException
{
//flush();
//DataContainer.this.content.add(Float.valueOf(v));
DataContainer.this.content.add(new FloatContainer(v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeDouble(double)
*/
public void writeDouble(double v) throws IOException
{
//flush();
//DataContainer.this.content.add(Double.valueOf(v));
DataContainer.this.content.add(new DoubleContainer(v));
}
/* (non-Javadoc)
* @see java.io.DataOutput#writeBytes(java.lang.String)
*/
public void writeBytes(String s) throws IOException
{
//createByteArray();
char[] chars = s.toCharArray();
for (int i=0;iA customized implementation of java.util.HashMap designed
* to operate in a multithreaded environment where the large majority of
* method calls are read-only, instead of structural changes.
* Read calls are non-synchronized and write calls perform the
* following steps:
NOTE: If you are creating and accessing a
* HashMap only within a single thread, you should use
* java.util.HashMap directly (with no synchronization), for
* maximum performance.
FastHashMap instance.
* The keys and values themselves are not copied.
*/
public Object clone() {
return new FastHashMap(map);
}
/**
* Return true if this map contains a mapping for the
* specified key.
*
* @param key Key to be searched for
*/
public boolean containsKey(Object key) {
return map.containsKey(key);
}
/**
* Return true if this map contains one or more keys mapping
* to the specified value.
*
* @param value Value to be searched for
*/
public boolean containsValue(Object value) {
return map.containsValue(value);
}
/**
* Return a collection view of the mappings contained in this map. Each
* element in the returned collection is a Map.Entry.
*/
public Set entrySet() {
return map.entrySet();
}
/**
* Compare the specified object with this list for equality. This
* implementation uses exactly the code that is used to define the
* list equals function in the documentation for the
* Map.equals method.
*
* @param o Object to be compared to this list
*/
public boolean equals(Object o) {
// Simple tests that require no synchronization
if (o == this)
return true;
else if ( !(o instanceof Map) )
return false;
Map mo = (Map) o;
// Compare the two maps for equality
if ( mo.size() != map.size() )
return false;
java.util.Iterator i = map.entrySet().iterator();
while ( i.hasNext() ) {
Map.Entry e = (Map.Entry) i.next();
Object key = e.getKey();
Object value = e.getValue();
if (value == null) {
if ( !( mo.get(key) == null && mo.containsKey(key) ) )
return false;
}
else {
if ( !value.equals( mo.get(key) ) )
return false;
}
}
return true;
}
/**
* Return the value to which this map maps the specified key. Returns
* null if the map contains no mapping for this key, or if
* there is a mapping with a value of null. Use the
* containsKey() method to disambiguate these cases.
*
* @param key Key whose value is to be returned
*/
public Object get(Object key) {
return map.get(key);
}
/**
* Return the hash code value for this map. This implementation uses
* exactly the code that is used to define the list hash function in the
* documentation for the Map.hashCode method.
*/
public int hashCode() {
int h = 0;
java.util.Iterator i = map.entrySet().iterator();
while ( i.hasNext() )
h += i.next().hashCode();
return h;
}
/**
* Return true if this map contains no mappings.
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* Return a set view of the keys contained in this map.
*/
public Set keySet() {
return map.keySet();
}
/**
* Associate the specified value with the specified key in this map.
* If the map previously contained a mapping for this key, the old
* value is replaced and returned.
*
* @param key The key with which the value is to be associated
* @param value The value to be associated with this key
*/
public Object put(Object key, Object value) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
Object result = temp.put(key, value);
map = temp;
return (result);
}
}
/**
* Copy all of the mappings from the specified map to this one, replacing
* any mappings with the same keys.
*
* @param in Map whose mappings are to be copied
*/
public void putAll(Map in) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
temp.putAll(in);
map = temp;
}
}
/**
* Remove any mapping for this key, and return any previously
* mapped value.
*
* @param key Key whose mapping is to be removed
*/
public Object remove(Object key) {
synchronized (this) {
HashMap temp = (HashMap) map.clone();
Object result = temp.remove(key);
map = temp;
return (result);
}
}
/**
* Return the number of key-value mappings in this map.
*/
public int size() {
return map.size();
}
/**
* Return a collection view of the values contained in this map.
*/
public Collection values() {
return map.values();
}
public String toString() { return map.toString(); }
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/util/HashStringUtil.java 0000644 0001750 0001750 00000004502 10423171624 031005 0 ustar twerner twerner /*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.serial.util;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.security.DigestOutputStream;
import java.security.MessageDigest;
import org.apache.log4j.Logger;
/**
*
* This code was extracted from MarshalledInvocation. It converts any string to a unique HashCode
* @author Clebert Suconic
*
*/
public class HashStringUtil {
private static final Logger log = Logger.getLogger(HashStringUtil.class);
private static final boolean isDebug = log.isDebugEnabled();
public static long hashName(String name)
{
try
{
long hash=0;
ByteArrayOutputStream bytearrayoutputstream = new ByteArrayOutputStream(512);
MessageDigest messagedigest = MessageDigest.getInstance("SHA");
DataOutputStream dataoutputstream = new DataOutputStream(new DigestOutputStream(bytearrayoutputstream, messagedigest));
dataoutputstream.writeUTF(name);
dataoutputstream.flush();
byte abyte0[] = messagedigest.digest();
for (int j = 0; j < Math.min(8, abyte0.length); j++)
hash += (long) (abyte0[j] & 0xff) << j * 8;
if (isDebug)
{
log.debug("hash on field " + name + " = " + hash);
}
return hash;
}
catch (Exception e)
{
RuntimeException rte = new RuntimeException(e);
throw rte;
}
}
}
libjboss-serialization-java-1.0.3.GA.orig/src/org/jboss/serial/util/PartitionedWeakHashMap.java 0000644 0001750 0001750 00000005464 10421112674 032437 0 ustar twerner twerner package org.jboss.serial.util;
import java.util.*;
/** This is a WeakHashMap divided into partitions, using a simple algorithm of using the hashCode of a Key % numberOfPartitions to determine what partition to use.
* This is intended to minimize synchroniozation affects
* @author Clebert Suconic*/
public class PartitionedWeakHashMap extends AbstractMap {
boolean issynchronized;
Map[] partitionMaps;
public PartitionedWeakHashMap()
{
this(false);
}
public PartitionedWeakHashMap(boolean issynchronized)
{
super();
this.issynchronized=issynchronized;
partitionMaps = new Map[PARTITION_SIZE];
for (int i=0;i