//-----------------------------------------------------------------------
/**
* Write the map out using a custom routine.
* @param out the output stream
* @throws IOException
*/
protected virtual void doWriteObject(java.io.ObjectOutputStream outJ)
{//throws IOException {
outJ.writeInt(map.size());
for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();)
{
java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next();
outJ.writeObject(entry.getKey());
outJ.writeInt(((MutableInteger)entry.getValue()).value);
}
}
//-----------------------------------------------------------------------
/**
* Replaces the superclass method to store the state of this class.
* <p>
* Serialization is not one of the JDK's nicest topics. Normal serialization will
* initialise the superclass before the subclass. Sometimes however, this isn't
* what you want, as in this case the <code>put()</code> method on read can be
* affected by subclass state.
* <p>
* The solution adopted here is to serialize the state data of this class in
* this protected method. This method must be called by the
* <code>writeObject()</code> of the first java.io.Serializable subclass.
* <p>
* Subclasses may override if they have a specific field that must be present
* on read before this implementation will work. Generally, the read determines
* what must be serialized here, if anything.
*
* @param out the output stream
*/
protected void dowriteObject(java.io.ObjectOutputStream outJ)
{//throws IOException {
outJ.writeInt(keyType);
outJ.writeInt(valueType);
outJ.writeBoolean(purgeValues);
outJ.writeFloat(loadFactor);
outJ.writeInt(data.Length);
for (MapIterator it = mapIterator(); it.hasNext();)
{
outJ.writeObject(it.next());
outJ.writeObject(it.getValue());
}
outJ.writeObject(null); // null terminate map
// do not call base.doWriteObject() as code there doesn't work for reference map
}
//-----------------------------------------------------------------------
/**
* Write the buffer out using a custom routine.
*
* @param out the output stream
* @throws IOException
*/
private void writeObject(java.io.ObjectOutputStream outJ)
{//throws IOException {
outJ.defaultWriteObject();
outJ.writeInt(size());
for (java.util.Iterator <Object> it = iterator(); it.hasNext();)
{
outJ.writeObject(it.next());
}
}
//-----------------------------------------------------------------------
/**
* Serializes the data held in this object to the stream specified.
* <p>
* The first java.io.Serializable subclass must call this method from
* <code>writeObject</code>.
*/
protected virtual void doWriteObject(java.io.ObjectOutputStream outputStream)
{//throws IOException {
// Write the size so we know how many nodes to read back
outputStream.writeInt(size());
for (java.util.Iterator <Object> itr = iterator(); itr.hasNext();)
{
outputStream.writeObject(itr.next());
}
}
/*
* Customized serialization.
*/
private void writeObject(java.io.ObjectOutputStream outJ)// throws IOException {
{
outJ.defaultWriteObject();
outJ.writeByte(MAJOR);
outJ.writeByte(MINOR);
if (null == parameters)
{
outJ.writeInt(-1);
}
else
{
outJ.writeInt(parameters.Length);
foreach (Object element in parameters)
{
outJ.writeObject(null == element ? null : element.toString());
}
}
}
private void writeObject(java.io.ObjectOutputStream stream)
{//throws IOException {
stream.defaultWriteObject();
stream.writeObject(backingMap.comparator());
int size = backingMap.size();
stream.writeInt(size);
if (size > 0)
{
Iterator <E> it = backingMap.keySet().iterator();
while (it.hasNext())
{
stream.writeObject(it.next());
}
}
}
/*
* Writes the state of this object to the stream passed.
*
* @param out
* the stream to write the state to.
* @throws IOException
* if the stream throws it during the write.
* @serialData {@code int} - the length of this object. {@code char[]} - the
* buffer from this object, which may be larger than the length
* field.
*/
private void writeObject(java.io.ObjectOutputStream outJ) // throws IOException {
{
outJ.defaultWriteObject();
outJ.writeInt(length());
outJ.writeObject(getValue());
}
/**
* Writes the data necessary for <code>put()</code> to work in deserialization.
*/
protected virtual void dowriteObject(java.io.ObjectOutputStream outJ)
{//throws IOException {
outJ.writeInt(maxSizeJ);
base.doWriteObject(outJ);
}
