@SuppressWarnings("deprecation")
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
String factoryName = vf.getClass().getName();
out.write("factory".getBytes());
out.write(':');
out.writeInt(factoryName.length());
out.write(':');
out.write(factoryName.getBytes("UTF8"));
out.write(':');
new BinaryValueWriter().write(value, out);
}
/**
* Serializes this object to a stream. @serialdata The object is first written in the old JDK 1.1
* format, so that it can be read by by the old classes. This means, that the <code>
* start/endDay(OfWeek)</code>-Fields are written in the DOW_IN_MONTH_MODE rule, since this was
* the only supported rule in 1.1.
*
* <p>In the optional section, we write first the length of an byte array as int and afterwards
* the byte array itself. The byte array contains in this release four elements, namely the real
* startDay, startDayOfWeek endDay, endDayOfWeek in that Order. These fields are needed, because
* for compatibility reasons only approximative values are written to the required section, as
* described above.
*/
private void writeObject(java.io.ObjectOutputStream output) throws java.io.IOException {
byte[] byteArray =
new byte[] {(byte) startDay, (byte) startDayOfWeek, (byte) endDay, (byte) endDayOfWeek};
/* calculate the approximation for JDK 1.1 */
switch (startMode) {
case DOM_MODE:
startDayOfWeek = Calendar.SUNDAY; // random day of week
// fall through
case DOW_GE_DOM_MODE:
case DOW_LE_DOM_MODE:
startDay = (startDay + 6) / 7;
}
switch (endMode) {
case DOM_MODE:
endDayOfWeek = Calendar.SUNDAY;
// fall through
case DOW_GE_DOM_MODE:
case DOW_LE_DOM_MODE:
endDay = (endDay + 6) / 7;
}
// the required part:
output.defaultWriteObject();
// the optional part:
output.writeInt(byteArray.length);
output.write(byteArray, 0, byteArray.length);
}
public void saveCache(
JMXInstrumentedCache<K, V> cache, File savedCachePath, Function<K, byte[]> converter)
throws IOException {
long start = System.currentTimeMillis();
String msgSuffix = " " + savedCachePath.getName() + " for " + cfname + " of " + ksname;
logger.debug("saving" + msgSuffix);
int count = 0;
File tmpFile =
File.createTempFile(savedCachePath.getName(), null, savedCachePath.getParentFile());
FileOutputStream fout = new FileOutputStream(tmpFile);
ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(fout));
FileDescriptor fd = fout.getFD();
for (K key : cache.getKeySet()) {
byte[] bytes = converter.apply(key);
out.writeInt(bytes.length);
out.write(bytes);
++count;
}
out.flush();
fd.sync();
out.close();
if (!tmpFile.renameTo(savedCachePath))
throw new IOException("Unable to rename cache to " + savedCachePath);
if (logger.isDebugEnabled())
logger.debug(
"saved "
+ count
+ " keys in "
+ (System.currentTimeMillis() - start)
+ " ms from"
+ msgSuffix);
}
/**
* Serializes an {@link MBeanFeatureInfo} to an {@link ObjectOutputStream}.
*
* @serialData For compatibility reasons, an object of this class is serialized as follows.
* <ul>
* The method {@link ObjectOutputStream#defaultWriteObject defaultWriteObject()} is called
* first to serialize the object except the field {@code descriptor} which is declared as
* transient. The field {@code descriptor} is serialized as follows:
* <ul>
* <li>If {@code descriptor} is an instance of the class {@link ImmutableDescriptor}, the
* method {@link ObjectOutputStream#write write(int val)} is called to write a byte
* with the value {@code 1}, then the method {@link ObjectOutputStream#writeObject
* writeObject(Object obj)} is called twice to serialize the field names and the field
* values of the {@code descriptor}, respectively as a {@code String[]} and an {@code
* Object[]};
* <li>Otherwise, the method {@link ObjectOutputStream#write write(int val)} is called to
* write a byte with the value {@code 0}, then the method {@link
* ObjectOutputStream#writeObject writeObject(Object obj)} is called to serialize
* directly the field {@code descriptor}.
* </ul>
* </ul>
*
* @since 1.6
*/
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (descriptor != null && descriptor.getClass() == ImmutableDescriptor.class) {
out.write(1);
final String[] names = descriptor.getFieldNames();
out.writeObject(names);
out.writeObject(descriptor.getFieldValues(names));
} else {
out.write(0);
out.writeObject(descriptor);
}
}
private void writeObject(final ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeInt(_length);
out.writeDouble(_p);
out.writeInt(_genes.length);
out.write(_genes);
}
/** java.io.ObjectOutputStream#write(int) */
public void test_writeI() throws Exception {
// Test for method void java.io.ObjectOutputStream.write(int)
oos.write('T');
oos.close();
ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
assertEquals("Read incorrect byte", 'T', ois.read());
ois.close();
}
public Game(boolean host) {
try {
if (host) {
System.out.println("Hosting...");
server = new ServerSocket(port, 4, InetAddress.getByName(serverIP));
System.out.println("Ready!\nAwaiting client...");
client = server.accept();
System.out.println("Client connected!\nBuffering...");
out = new ObjectOutputStream(client.getOutputStream());
in = new ObjectInputStream(client.getInputStream());
System.out.println("Buffered!\nPinging for 256 bytes...");
long start = System.currentTimeMillis();
byte[] ping = new byte[256];
in.read(ping);
System.out.println("Latency: " + (System.currentTimeMillis() - start));
out.writeLong(start);
out.flush();
System.out.println("Starting threads...");
new ThreadSend(world, out);
new ThreadReceive(world, in);
System.out.println("Started!\nCreating game world...");
} else {
System.out.println("Connecting...");
socket = new Socket(connectIP, port);
System.out.println("Connected!\nBuffering...");
in = new ObjectInputStream(socket.getInputStream());
out = new ObjectOutputStream(socket.getOutputStream());
byte[] ping = new byte[256];
new Random().nextBytes(ping);
System.out.println("Buffered\nPinging for 256 bytes...");
out.write(ping);
out.flush();
long latency = in.readLong();
System.out.println("Latency: " + (System.currentTimeMillis() - latency));
System.out.println("Starting threads...");
new ThreadReceive(world, in);
new ThreadSend(world, out);
System.out.println("Started!\nCreating game world...");
}
} catch (Exception e) {
e.printStackTrace();
}
try {
Display.setDisplayMode(new DisplayMode(width, height));
Display.create();
} catch (Exception e) {
e.printStackTrace();
}
world.init();
while (!Display.isCloseRequested()) {
if (ended) break;
world.update();
}
Display.destroy();
}
/** java.io.ObjectOutputStream#write(byte[]) */
public void test_write$B() throws Exception {
// Test for method void java.io.ObjectOutputStream.write(byte [])
byte[] buf = new byte[10];
oos.write("HelloWorld".getBytes());
oos.close();
ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
ois.read(buf, 0, 10);
ois.close();
assertEquals("Read incorrect bytes", "HelloWorld", new String(buf, 0, 10));
}
/* Fixed versions of this are below with ObjectInputStream tests */
public void objectOutputStreamClosedNestedBad() throws IOException {
ObjectOutputStream oin = null;
try {
oin = new ObjectOutputStream(new FileOutputStream("file.txt"));
oin.write(3);
} catch (IOException e) {
} finally {
if (oin != null) oin.close();
}
}
public void objectOutputStreamNotClosedAfterWrite() {
byte[] arr = {1, 2, 3, 4, 5};
ObjectOutputStream oout;
try {
oout = new ObjectOutputStream(new FileOutputStream("file.txt"));
oout.write(arr);
oout.close();
} catch (IOException e) {
}
}
private void writeObject(ObjectOutputStream out) throws IOException {
if (image != null) {
final ByteArrayOutputStream stream = new ByteArrayOutputStream();
image.compress(Bitmap.CompressFormat.PNG, 100, stream);
final byte[] imageByteArray = stream.toByteArray();
out.writeInt(imageByteArray.length);
out.write(imageByteArray);
} else {
out.writeInt(NO_IMAGE);
}
}
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
if (userDefinedSchema != null) {
byte[] json = userDefinedSchema.toString().getBytes();
out.writeInt(json.length);
out.write(json);
} else {
out.writeInt(0);
}
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.writeUTF(localPath.getName());
out.writeLong(localPath.length());
byte[] xfer = new byte[4096];
FileInputStream fis = new FileInputStream(localPath);
try {
for (int read = fis.read(xfer); read >= 0; read = fis.read(xfer)) out.write(xfer, 0, read);
} finally {
fis.close();
}
}
/**
* Get the signature data generated
*
* @return Signature data
* @throws OpenStegoException
*/
public byte[] getSigData() throws OpenStegoException {
ByteArrayOutputStream baos = null;
ObjectOutputStream oos = null;
try {
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.write(this.sig);
oos.writeInt(this.watermarkLength);
oos.writeDouble(this.embeddingStrength);
oos.writeInt(this.waveletFilterMethod);
oos.writeInt(this.filterID);
oos.writeInt(this.embeddingLevel);
oos.write(this.watermark);
oos.flush();
oos.close();
return baos.toByteArray();
} catch (IOException ioEx) {
throw new OpenStegoException(ioEx);
}
}
@Override
public void run() {
while (true) {
try {
// New client appears:
clientSocket = serverSocket.accept();
out = new ObjectOutputStream(clientSocket.getOutputStream());
in = new BufferedInputStream(clientSocket.getInputStream());
} catch (IOException ex) {
Logger.getLogger(FileDistributor.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println(
"Accepted connection from address: "
+ clientSocket.getInetAddress()
+ ":"
+ clientSocket.getPort());
byte[] msg = new byte[25];
try {
// Read the name of the file to Distribute:
in.read(msg, 0, msg.length);
fileName = new String(msg).replaceAll("\\s", "");
// Create a new file and directory if that does not exist:
File myFile = new File(shared_folder + "\\" + fileName);
// Initialize variables:
long fileSize = myFile.length();
long completed = 0;
int step = 100000;
// Start a fileInputStream to read bytes from the requested file.
FileInputStream fis = new FileInputStream(myFile);
// Start sending the requested file.
System.out.println("Start sending file: " + fileName);
byte[] buffer = new byte[step];
while (completed <= fileSize) {
fis.read(buffer);
out.write(buffer);
completed += step;
}
out.flush();
System.out.println("Sending file " + fileName + " completed successfully!");
} catch (IOException ex) {
Logger.getLogger(FileDistributor.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
public void enviar(byte[] buffer) {
try {
// streamDeSaida.write(buffer);
ObjectOutputStream oos = new ObjectOutputStream(streamDeSaida);
oos.write(buffer);
oos.flush();
this.handle
.obtainMessage(ManipuladorProtocolo.ENVIAR_MENSAGEM, buffer.length, -1, buffer)
.sendToTarget();
} catch (IOException e) {
this.handle
.obtainMessage(ManipuladorProtocolo.RECEBER_MENSAGEM, buffer.length, -1, buffer)
.sendToTarget();
Log.e(TAG, "Exception during write", e);
}
}
@Override
public byte[] encode(Object value) {
try {
String className = value.getClass().getName();
// TODO 这里最好能动态预测长度
ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);
ObjectOutputStream oos = new ObjectOutputStream(bos);
byte[] classNameInBytes = className.getBytes(Encoding.DEFAULT);
oos.writeInt(classNameInBytes.length);
oos.write(classNameInBytes);
mapper.writeValue(oos, value);
return bos.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* Saves the hashTable in the file specified by the <i>destination</i>. *
*
* @pre destination ≠ null AND location in file system where file is to be created exists AND
* the file location is writable AND every object in the ObjectDB is serializable.
* @post the hashTable has been saved to the file named <i>destination</i> along with the size of
* the hashTable.
*/
public void save(String destination) {
String fileLocation = DEFAULT_FILE_LOCATION;
if (FILE_LOCATION != null) {
fileLocation = FILE_LOCATION;
}
if (destination != null) {
fileLocation = destination;
}
try {
ObjectOutputStream oos =
new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(fileLocation)));
oos.write(LocalObjectId.getNextId());
oos.writeObject(hashTable);
oos.flush();
oos.close();
} catch (Exception e) {
System.err.println("In communicator.ObjectDB::save(String) -- ERROR could not save ObjectDB");
}
}
public static void safeSerialize(ObjectOutputStream out, Serializable data) throws IOException {
if (data == null) {
out.writeBoolean(false);
return;
} else {
out.writeBoolean(true);
}
byte[] serialData;
if (data instanceof SerializedData) {
SerializedData dummyData = (SerializedData) data;
serialData = dummyData.serialData;
} else {
serialData = serialize(data);
;
}
out.writeInt(serialData.length);
out.write(serialData);
}
/* */ private void writeObject(ObjectOutputStream paramObjectOutputStream)
/* */ throws IOException
/* */ {
/* 524 */ paramObjectOutputStream.defaultWriteObject();
/* */
/* 526 */ if ((this.certs == null) || (this.certs.length == 0)) {
/* 527 */ paramObjectOutputStream.writeInt(0);
/* */ }
/* */ else {
/* 530 */ paramObjectOutputStream.writeInt(this.certs.length);
/* */
/* 532 */ for (int i = 0; i < this.certs.length; i++) {
/* 533 */ Certificate localCertificate = this.certs[i];
/* */ try {
/* 535 */ paramObjectOutputStream.writeUTF(localCertificate.getType());
/* 536 */ byte[] arrayOfByte = localCertificate.getEncoded();
/* 537 */ paramObjectOutputStream.writeInt(arrayOfByte.length);
/* 538 */ paramObjectOutputStream.write(arrayOfByte);
/* */ } catch (CertificateEncodingException localCertificateEncodingException) {
/* 540 */ throw new IOException(localCertificateEncodingException.getMessage());
/* */ }
/* */ }
/* */ }
/* */ }
public void serializeTo(ObjectOutputStream out) throws IOException {
out.write(root.array());
out.writeUTF(auxInfoFilename);
out.writeObject(auxInfoGuids);
out.writeInt(storage.getStorageTypeId());
}
private void doDownloadFile() throws IOException {
try {
final String base = (String) in.readObject(); // 第一次接收信息
if (base == null) {
out.write(FileBaseInfo.ANSWER_NO); // 第一次发送信息(取消)
out.flush();
return;
}
out.write(FileBaseInfo.ANSWER_YES); // 第一次发送信息(继续)
out.flush();
final long totalLength = in.readLong(); // 第二次接收信息(总长度)
log.debug("totalLength : " + totalLength);
getDisplay()
.syncExec(
new Runnable() {
public void run() {
setMaximum(totalLength);
lblMsg.setText("Downloading file...");
}
});
while (in.read() == FileBaseInfo.GOON) { // 连续接收信息
byte fileOrFolder = (byte) in.read();
String name = (String) in.readObject();
final File f = new File(base + File.separatorChar + name);
log.debug("download file: " + f);
if (fileOrFolder == FileBaseInfo.FOLDER) {
f.mkdir();
} else {
final long length = in.readLong();
getDisplay()
.syncExec(
new Runnable() {
public void run() {
lblFile.setText(
"File：\""
+ f.getPath()
+ "\" Size："
+ Util.byteCountToDisplaySize(length));
}
});
RandomAccessFile raout = null;
try {
raout = new RandomAccessFile(f, "rw");
StreamUtil2.copy(in, raout, length, FileDownloadShell.this);
} catch (Exception e) {
if (running) log.error("establish file error", e);
f.delete();
throw e;
} finally {
Util.closeQuietly(raout, log);
}
}
}
getDisplay()
.syncExec(
new Runnable() {
public void run() {
lblMsg.setText("Download finished");
lblFile.setText("");
openFile(base);
FileDownloadShell.this.dispose();
}
});
} catch (final Exception e) {
if (running) {
log.error("download file error", e);
getDisplay()
.syncExec(
new Runnable() {
public void run() {
MessageDialog.openError(FileDownloadShell.this, "Error", e.getMessage());
FileDownloadShell.this.dispose();
}
});
}
}
}
/**
* Send screenshot
*
* @param fileName File name
* @param mSeed World seed
* @throws IOException
*/
public void sendScreenShot(String fileName, long mSeed) throws IOException {
synchronized (out) {
sendMessage(
NetworkProtocolHelper.COMMAND_SCREENSHOT_SEND
+ NetworkProtocolHelper.SEPARATOR_COMMAND
+ String.valueOf(mSeed));
// File to send
File myFile =
new File(
Minecraft.getMinecraft().mcDataDir.getCanonicalPath()
+ File.separator
+ "screenshots"
+ File.separator,
fileName);
int fSize = (int) myFile.length();
if (fSize < myFile.length()) {
System.out.println("File is too big");
sendMessage(NetworkProtocolHelper.COMMAND_SCREENSHOT_ERROR);
return;
}
// Send the file's size
byte[] bSize = new byte[4];
bSize[0] = (byte) ((fSize & 0xff000000) >> 24);
bSize[1] = (byte) ((fSize & 0x00ff0000) >> 16);
bSize[2] = (byte) ((fSize & 0x0000ff00) >> 8);
bSize[3] = (byte) (fSize & 0x000000ff);
// 4 bytes containing the file size
try {
out.write(bSize, 0, 4);
} catch (IOException e) {
e.printStackTrace();
sendMessage(NetworkProtocolHelper.COMMAND_SCREENSHOT_ERROR);
return;
}
boolean noMemoryLimitation = false;
FileInputStream fis = null;
BufferedInputStream bis = null;
try {
fis = new FileInputStream(myFile);
bis = new BufferedInputStream(fis);
if (noMemoryLimitation) {
byte[] outBuffer = new byte[fSize];
int bRead = bis.read(outBuffer, 0, outBuffer.length);
out.write(outBuffer, 0, bRead);
} else {
int bRead = 0;
byte[] outBuffer = new byte[8 * 1024];
while ((bRead = bis.read(outBuffer, 0, outBuffer.length)) > 0) {
out.write(outBuffer, 0, bRead);
}
}
out.flush();
} catch (IOException e) {
e.printStackTrace();
sendMessage(NetworkProtocolHelper.COMMAND_SCREENSHOT_ERROR);
return;
} finally {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
} catch (NullPointerException e) {
e.printStackTrace();
}
sendMessage(
NetworkProtocolHelper.COMMAND_SCREENSHOT_FINISHED
+ NetworkProtocolHelper.SEPARATOR_COMMAND
+ String.valueOf(mSeed));
}
}
}
// Sends the message stored in prefix+message to the server
public synchronized void sendMessage(byte prefix, byte[] message) throws IOException {
if (handlers[prefix].shouldSendToSelf()) sendToSelf(prefix, message);
oos.write(prefix);
oos.write(message);
oos.flush();
}
@Override
public void write(byte[] buf, int off, int len) throws IOException {
out.write(buf, off, len);
}
@Override
public void write(byte[] buf) throws IOException {
out.write(buf);
}
@Override
public void write(int val) throws IOException {
out.write(val);
}