Java Code Examples for java.io.ObjectOutputStream#writeInt()

private void writeObject(ObjectOutputStream oos) throws IOException {
	oos.writeUTF(methodName);

	oos.writeInt(parameterTypes.length);

	for (Class<?> parameterType : parameterTypes) {
		oos.writeObject(parameterType);
	}

	if (args != null) {
		oos.writeBoolean(true);

		for (int i = 0; i < args.length; i++) {
			try {
				oos.writeObject(args[i]);
			} catch (IOException e) {
				throw new IOException("Could not serialize " + i + "th argument of method " +
					methodName + ". This indicates that the argument type " +
					args.getClass().getName() + " is not serializable. Arguments have to " +
					"be serializable for remote rpc calls.", e);
			}
		}
	} else {
		oos.writeBoolean(false);
	}
}
 

/**
 * Provides serialization support.
 *
 * @param stream  the output stream.
 *
 * @throws IOException  if there is an I/O error.
 */
private void writeObject(ObjectOutputStream stream) throws IOException {

    stream.defaultWriteObject();
    int count = size();
    stream.writeInt(count);
    for (int i = 0; i < count; i++) {
        Shape shape = getShape(i);
        if (shape != null) {
            stream.writeInt(i);
            SerialUtilities.writeShape(shape, stream);
        }
        else {
            stream.writeInt(-1);
        }
    }

}
 

/**
 * Provides serialization support.
 *
 * @param stream  the output stream.
 *
 * @throws IOException  if there is an I/O error.
 */
private void writeObject(final ObjectOutputStream stream) 
    throws IOException {

    stream.defaultWriteObject();
    final int count = size();
    stream.writeInt(count);
    for (int i = 0; i < count; i++) {
        final Object object = get(i);
        if (object != null && object instanceof Serializable) {
            stream.writeInt(i);
            stream.writeObject(object);
        }
        else {
            stream.writeInt(-1);
        }
    }

}
 

private void writeObject(ObjectOutputStream s)
    throws IOException
{
    s.defaultWriteObject();

    int w = getIconWidth();
    int h = getIconHeight();
    int[] pixels = image != null? new int[w * h] : null;

    if (image != null) {
        try {
            PixelGrabber pg = new PixelGrabber(image, 0, 0, w, h, pixels, 0, w);
            pg.grabPixels();
            if ((pg.getStatus() & ImageObserver.ABORT) != 0) {
                throw new IOException("failed to load image contents");
            }
        }
        catch (InterruptedException e) {
            throw new IOException("image load interrupted");
        }
    }

    s.writeInt(w);
    s.writeInt(h);
    s.writeObject(pixels);
}
 

/**
 * Serialize {@link #context}.
 *
 * @param out Stream.
 * @throws IOException This should never happen.
 */
private void serializeContext(ObjectOutputStream out)
    throws IOException {
    // Step 1.
    final int len = context.keySet().size();
    out.writeInt(len);
    for (String key : context.keySet()) {
        // Step 2.
        out.writeObject(key);
        final Object value = context.get(key);
        if (value instanceof Serializable) {
            // Step 3a.
            out.writeObject(value);
        } else {
            // Step 3b.
            out.writeObject(nonSerializableReplacement(value));
        }
    }
}
 

private void saveGameStatistics(ObjectOutputStream objectOutputStream) throws IOException {
	WorldObject playerCharacter = getPlayerCharacter();
	
	objectOutputStream.writeObject(playerCharacter.getProperty(Constants.NAME));
	objectOutputStream.writeInt(playerCharacter.getProperty(Constants.LEVEL));
	objectOutputStream.writeInt(currentTurn.getValue());
	objectOutputStream.writeObject(playerCharacter.getProperty(Constants.IMAGE_ID));
}
 

private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeInt(elementData.length);
    stream.writeInt(elementCount);
    Iterator<?> iterator = entrySet().iterator();
    while (iterator.hasNext()) {
        Entry<?, ?> entry = (Entry<?, ?>) iterator.next();
        stream.writeObject(entry.key);
        stream.writeObject(entry.value);
        entry = entry.next;
    }
}
 

public void saveState(ObjectOutputStream objectOutputStream)
		throws IOException {
	if (!mInstanceable) {
		// TODO ensure size == 1
		objectOutputStream.writeBoolean(mDataSourceInstances != null
				&& mDataSourceInstances.get(0).isChecked());
		mDataSourceInstances.get(0).saveState(objectOutputStream);
	} else {
		objectOutputStream.writeInt(mDataSourceInstances.size());
		for (DataSourceInstanceHolder dataSourceInstance : mDataSourceInstances) {
			dataSourceInstance.saveState(objectOutputStream);
		}
	}
}
 

private void writeObject(ObjectOutputStream stream)
    throws IOException {
    stream.defaultWriteObject();

    // number of entries
    stream.writeInt(_size);

    SerializationProcedure writeProcedure = new SerializationProcedure(stream);
    if (! forEachEntry(writeProcedure)) {
        throw writeProcedure.exception;
    }
}
 

public  void doWrite( ObjectOutputStream stream )
    throws IOException
{
    // write the IOR to the ObjectOutputStream
    stream.writeInt(typeData.length);
    stream.write(typeData);
    stream.writeInt(profileTags.length);
    for (int i = 0; i < profileTags.length; i++) {
        stream.writeInt(profileTags[i]);
        stream.writeInt(profileData[i].length);
        stream.write(profileData[i]);
    }
}
 

private void writeObject(
    ObjectOutputStream  out)
    throws IOException
{
    out.defaultWriteObject();

    out.writeObject(dhSpec.getP());
    out.writeObject(dhSpec.getG());
    out.writeInt(dhSpec.getL());
}
 

/** Custom serialization */
private void writeObject(ObjectOutputStream os) throws IOException {
    os.writeInt(values.length);
    for (int value : values) {
        os.writeInt(value);
    }
}
 

public void write(DataOutputStream out) throws IOException {
	ObjectOutputStream oos = new ObjectOutputStream(out);
	synchronized (this) {
		oos.writeInt(infos.size());
		Iterator<SparseVector> iterator = infos.iterator();
		while (iterator.hasNext()) {
			SparseVector sv = iterator.next();
			oos.writeObject(sv.index);
			oos.writeObject(sv.value);
		}
	}
	oos.close();
}
 

/**
 * Serialize DbAppenderConfiguration.
 * @param s serialization stream.
 * @throws IOException if exception during serialization.
 */
private void writeObject(
                          final ObjectOutputStream s ) throws IOException {

    s.defaultWriteObject();
    if (loggingThreshold == null) {
        // should be set in RemoteLoggingConfiguration
        throw new IllegalStateException("Logging level should not be null");
    }
    s.writeInt(loggingThreshold.toInt());
}
 

private void writeObject(ObjectOutputStream oos) throws IOException {
	oos.writeInt(size);

	T curr = head.next;
	for (int i = 0; i < size; i++) {
		oos.writeObject(curr);
		curr = curr.next;
	}
}
 

void writeObject(ObjectOutputStream out) throws IOException {
    out.writeInt(mode);
    for (int i = 0; i < generalNumbers.length; i++) {
        out.writeLong(generalNumbers[i]);
    }

    if (mode == CommonConstants.MODE_THREADS_SAMPLING) {
        out.writeInt(nThreads);
        out.writeInt(nThreadStates);
        for (int i = 0; i < nThreads; i++) {
            out.writeInt(threadIds[i]);
        }
        for (int i = 0; i < nThreadStates; i++) {
            out.writeLong(stateTimestamps[i]);
        }
        int len = nThreads * nThreadStates;
        out.write(threadStates, 0, len);
    } else if (mode == CommonConstants.MODE_THREADS_EXACT) {
        out.writeInt(exactThreadStates.length);
        for (int i = 0; i < exactThreadIds.length; i++) {
            out.writeInt(exactThreadIds[i]);
            out.writeByte(exactThreadStates[i]);
            out.writeLong(exactTimeStamps[i]);
        }
    }

    if (nNewThreads == 0) {
        out.writeInt(0);
    } else {
        out.writeInt(nNewThreads);

        for (int i = 0; i < nNewThreads; i++) {
            out.writeInt(newThreadIds[i]);
            out.writeUTF(newThreadNames[i]);
            out.writeUTF(newThreadClassNames[i]);
        }
    }

    out.writeInt(gcStarts.length);

    for (int i = 0; i < gcStarts.length; i++) {
        out.writeLong(gcStarts[i]);
    }

    out.writeInt(gcFinishs.length);

    for (int i = 0; i < gcFinishs.length; i++) {
        out.writeLong(gcFinishs[i]);
    }

    out.writeInt(serverState);
    out.writeInt(serverProgress);
}
 

void writeObject(ObjectOutputStream out) throws IOException {
    out.writeUTF(className);
    out.writeInt(classLoaderId);
}
 

void writeObject(ObjectOutputStream out) throws IOException {
    if (instrMethodClasses == null) {
        out.writeInt(0);

        return;
    }

    out.writeInt(nClasses);

    for (int i = 0; i < nClasses; i++) {
        out.writeUTF(instrMethodClasses[i]);
        out.writeInt(instrMethodClassLoaderIds[i]);
    }

    out.writeInt(nMethods);

    if (instrMethodLeaf != null) {
        out.write(1);

        for (int i = 0; i < nMethods; i++) {
            out.writeBoolean(instrMethodLeaf[i]);
        }
    } else {
        out.write(0);
    }

    out.writeInt(addInfo);

    for (int i = 0; i < nClasses; i++) {
        if (replacementClassFileBytes[i] == null) {
            out.writeInt(0);
        } else {
            out.writeInt(replacementClassFileBytes[i].length);
            out.write(replacementClassFileBytes[i]);
        }
    }

    instrMethodClasses = null;
    instrMethodClassLoaderIds = null;
    instrMethodLeaf = null;
    replacementClassFileBytes = null;
}
 

/** Serialize a {@link RealMatrix}.
 * <p>
 * This method is intended to be called from within a private
 * <code>writeObject</code> method (after a call to
 * <code>oos.defaultWriteObject()</code>) in a class that has a
 * {@link RealMatrix} field, which should be declared <code>transient</code>.
 * This way, the default handling does not serialize the matrix (the {@link
 * RealMatrix} interface is not serializable by default) but this method does
 * serialize it specifically.
 * </p>
 * <p>
 * The following example shows how a simple class with a name and a real matrix
 * should be written:
 * <pre><code>
 * public class NamedMatrix implements Serializable {
 *
 *     private final String name;
 *     private final transient RealMatrix coefficients;
 *
 *     // omitted constructors, getters ...
 *
 *     private void writeObject(ObjectOutputStream oos) throws IOException {
 *         oos.defaultWriteObject();  // takes care of name field
 *         MatrixUtils.serializeRealMatrix(coefficients, oos);
 *     }
 *
 *     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
 *         ois.defaultReadObject();  // takes care of name field
 *         MatrixUtils.deserializeRealMatrix(this, "coefficients", ois);
 *     }
 *
 * }
 * </code></pre>
 * </p>
 *
 * @param matrix real matrix to serialize
 * @param oos stream where the real matrix should be written
 * @exception IOException if object cannot be written to stream
 * @see #deserializeRealMatrix(Object, String, ObjectInputStream)
 */
public static void serializeRealMatrix(final RealMatrix matrix,
                                       final ObjectOutputStream oos)
    throws IOException {
    final int n = matrix.getRowDimension();
    final int m = matrix.getColumnDimension();
    oos.writeInt(n);
    oos.writeInt(m);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            oos.writeDouble(matrix.getEntry(i, j));
        }
    }
}
 

/** Serialize a {@link RealMatrix}.
 * <p>
 * This method is intended to be called from within a private
 * <code>writeObject</code> method (after a call to
 * <code>oos.defaultWriteObject()</code>) in a class that has a
 * {@link RealMatrix} field, which should be declared <code>transient</code>.
 * This way, the default handling does not serialize the matrix (the {@link
 * RealMatrix} interface is not serializable by default) but this method does
 * serialize it specifically.
 * </p>
 * <p>
 * The following example shows how a simple class with a name and a real matrix
 * should be written:
 * <pre><code>
 * public class NamedMatrix implements Serializable {
 *
 *     private final String name;
 *     private final transient RealMatrix coefficients;
 *
 *     // omitted constructors, getters ...
 *
 *     private void writeObject(ObjectOutputStream oos) throws IOException {
 *         oos.defaultWriteObject();  // takes care of name field
 *         MatrixUtils.serializeRealMatrix(coefficients, oos);
 *     }
 *
 *     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
 *         ois.defaultReadObject();  // takes care of name field
 *         MatrixUtils.deserializeRealMatrix(this, "coefficients", ois);
 *     }
 *
 * }
 * </code></pre>
 * </p>
 *
 * @param matrix real matrix to serialize
 * @param oos stream where the real matrix should be written
 * @exception IOException if object cannot be written to stream
 * @see #deserializeRealMatrix(Object, String, ObjectInputStream)
 */
public static void serializeRealMatrix(final RealMatrix matrix,
                                       final ObjectOutputStream oos)
    throws IOException {
    final int n = matrix.getRowDimension();
    final int m = matrix.getColumnDimension();
    oos.writeInt(n);
    oos.writeInt(m);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            oos.writeDouble(matrix.getEntry(i, j));
        }
    }
}