/** * Serializes the given real. Reals will always be serialized in one peice. * * @see openllet.aterm.ATermFwdVoid#voidVisitReal(ATermReal) */ @Override public void voidVisitReal(final ATermReal arg) { _currentBuffer.put(getHeader(arg)); writeDouble(arg.getReal()); }
int totalBytesWritten = 0; final BinaryWriter binaryWriter = new BinaryWriter(aTerm); do binaryWriter.serialize(byteBuffer); } while (!binaryWriter.isFinished());
public void write(final ATerm input, final byte[] expectedResult) throws Exception { final ByteBuffer buffer = ByteBuffer.allocate(expectedResult.length + 10); final BinaryWriter bw = new BinaryWriter(input); bw.serialize(buffer); final byte[] result = new byte[buffer.limit()]; buffer.get(result); final int expectedResultLength = expectedResult.length; final int resultLength = result.length; if (expectedResultLength != resultLength) { log("The number of written bytes didn't match the number of _expected bytes. Was: " + resultLength + ", _expected: " + expectedResultLength); return; } for (int i = 0; i < resultLength; i++) if (result[i] != expectedResult[i]) { log("Written data didn't match the _expected data. Index: " + i + ", was " + result[i] + ", _expected " + expectedResult[i]); return; } log("Writing OK for: " + input); }
writeInt(id.intValue()); visit(_currentTerm); _currentTerm = getNextTerm();
/** * Serializes the given placeholder. Placeholders will always be serialized in one piece. * * @see openllet.aterm.ATermFwdVoid#voidVisitPlaceholder(ATermPlaceholder) */ @Override public void voidVisitPlaceholder(final ATermPlaceholder arg) { _currentBuffer.put(getHeader(arg)); // Do nothing, serializing its header is enough. }
/** * Splits the given double in separate bytes and writes it to the buffer. Doubles will always * occupy 8 bytes, since the convertion of a floating point number to a long will always cause * the high order bits to be occupied. * * @param value * The integer that needs to be split and written. */ private void writeDouble(final double value) { final long longValue = Double.doubleToLongBits(value); writeLong(longValue); }
final BinaryWriter binaryWriter = new BinaryWriter(aTerm); binaryWriter.serialize(byteBuffer); } while (!binaryWriter.isFinished());
@Test public void testChunkification() throws VisitFailure { final ATerm in = makeBigDummyTerm(2500); final ByteBuffer buffer = ByteBuffer.allocate(1000); final BinaryWriter bw = new BinaryWriter(in); final BinaryReader binaryReader = new BinaryReader(_pureFactory); while (!binaryReader.isDone()) { buffer.clear(); bw.serialize(buffer); binaryReader.deserialize(buffer); } final ATerm result = binaryReader.getRoot(); if (result == in) log("Chunkification OK"); else log("Chunkification FAILED"); }
/** * Serializes the given list. List information will always be serialized in one piece. * * @see openllet.aterm.ATermFwdVoid#voidVisitList(ATermList) */ @Override public void voidVisitList(final ATermList arg) { final byte header = getHeader(arg); _currentBuffer.put(header); writeInt(arg.getLength()); }
/** * Serializes the given blob. A blob can be serialized in chunks. * * @see openllet.aterm.ATermFwdVoid#voidVisitBlob(ATermBlob) */ @Override public void voidVisitBlob(final ATermBlob arg) { final int size = arg.getBlobSize(); if (_indexInTerm == 0) { _currentBuffer.put(getHeader(arg)); writeInt(size); } final byte[] blobBytes = arg.getBlobData(); int bytesToWrite = size - _indexInTerm; final int remaining = _currentBuffer.remaining(); if (remaining < bytesToWrite) bytesToWrite = remaining; _currentBuffer.put(blobBytes, _indexInTerm, bytesToWrite); _indexInTerm += bytesToWrite; if (_indexInTerm == size) _indexInTerm = 0; }