tClass) throws IllegalStateException;
/**
* Reads a byte of data. This method will block if no input is available.
*
* @return the byte read, or -1 if the end of the stream is reached.
*/
@Override
int read();
/**
* Reads into an array of bytes. This method will block until some input is available.
*
* @param bytes the buffer into which the data is read
* @return the actual number of bytes read, -1 is returned when the end of the stream is reached.
*/
@Override
int read(@NotNull byte[] bytes);
/**
* Reads into an array of bytes. This method will block until some input is available.
*
* @param bytes the buffer into which the data is read
* @param off the start offset of the data
* @param len the maximum number of bytes read
* @return the actual number of bytes read, -1 is returned when the end of the stream is reached.
*/
@Override
int read(@NotNull byte[] bytes, int off, int len);
/**
* Read the object from start to end bytes
*
* @param object to read into
* @param start byte inclusive
* @param end byte exclusive
*/
void readObject(Object object, int start, int end);
/**
* Skips n bytes of input.
*
* @param n the number of bytes to be skipped
* @return the actual number of bytes skipped.
*/
@Override
long skip(long n);
/**
* @return remaining() or Integer.MAX_VALUE if larger.
*/
@Override
int available();
/**
* Finishes the excerpt entry if not finished()
*/
@Override
void close();
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/RandomDataOutput.java 0000775 0000000 0000000 00000111237 12267523751 0026540 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.io.ObjectOutput;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.Map;
import java.util.RandomAccess;
/**
* @author peter.lawrey
*/
public interface RandomDataOutput extends ObjectOutput, RandomAccess, BytesCommon {
/**
* Copy from one Bytes to another. Copied from the start to the current position.
*
* @param bytes to copy from
* @deprecated Use write(BytesCommon bytes, long position, long length) instead.
*/
@Deprecated
void writeStartToPosition(Bytes bytes);
/**
* Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of
* b are ignored.
*
* @param b the byte to be written.
*/
@Override
void write(int b);
/**
* Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of
* v are ignored. (This means that writeByte does exactly the same thing as
* write for an integer argument.) The byte written by this method may be read by the
* readByte method of interface DataInput, which will then return a byte
* equal to (byte)v.
*
* @param v the byte value to be written.
*/
@Override
void writeByte(int v);
/**
* Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of
* v are ignored. (This means that writeByte does exactly the same thing as
* write for an integer argument.) The byte written by this method may be read by the
* readUnsignedByte method of interface DataInput, which will then return a
* byte equal to (byte)v.
*
* @param v the byte value to be written.
*/
void writeUnsignedByte(int v);
/**
* Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of
* b are ignored.
*
* @param offset to write byte
* @param b the byte to be written.
*/
void writeByte(long offset, int b);
/**
* Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of
* v are ignored. (This means that writeByte does exactly the same thing as
* write for an integer argument.) The byte written by this method may be read by the
* readUnsignedByte method of interface DataInput, which will then return a
* byte equal to v & 0xFF.
*
* @param offset to write byte
* @param v the unsigned byte value to be written.
*/
void writeUnsignedByte(long offset, int v);
/**
* Writes to the output stream all the bytes in array bytes. If bytes is
* null, a NullPointerException is thrown. If bytes.length is zero, then no
* bytes are written. Otherwise, the byte bytes[0] is written first, then bytes[1], and so
* on; the last byte written is bytes[bytes.length-1].
*
* @param bytes the data.
*/
@Override
void write(byte[] bytes);
/**
* Writes to the output stream all the bytes in array bytes. If bytes is
* null, a NullPointerException is thrown. If bytes.length is zero, then no
* bytes are written. Otherwise, the byte bytes[0] is written first, then bytes[1], and so
* on; the last byte written is bytes[bytes.length-1].
*
* @param offset to be written
* @param bytes the data.
*/
void write(long offset, byte[] bytes);
/**
* Writes len bytes from array bytes, in order, to the output stream. If
* bytes is null, a NullPointerException is thrown. If off is
* negative, or len is negative, or off+len is greater than the length of the array
* bytes, then an IndexOutOfBoundsException is thrown. If len is zero, then
* no bytes are written. Otherwise, the byte bytes[off] is written first, then
* bytes[off+1], and so on; the last byte written is bytes[off+len-1].
*
* @param bytes the data.
* @param off the start offset in the data.
* @param len the number of bytes to write.
*/
@Override
void write(byte[] bytes, int off, int len);
/**
* Writes a boolean value to this output stream. If the argument v is true,
* the value (byte)1 is written; if v is false, the value
* (byte)0 is written. The byte written by this method may be read by the readBoolean
* method of interface DataInput, which will then return a boolean equal to
* v.
*
* @param v the boolean to be written.
*/
@Override
void writeBoolean(boolean v);
/**
* Writes a boolean value to this output stream. If the argument v is true,
* the value (byte)1 is written; if v is false, the value
* (byte)0 is written. The byte written by this method may be read by the readBoolean
* method of interface DataInput, which will then return a boolean equal to
* v.
*
* @param offset to write boolean
* @param v the boolean to be written.
*/
void writeBoolean(long offset, boolean v);
/**
* Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in
* the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readShort method of interface
* DataInput , which will then return a short equal to (short)v.
*
* @param v the short value to be written.
*/
@Override
void writeShort(int v);
/**
* Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in
* the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readShort method of interface
* DataInput , which will then return a short equal to (short)v.
*
* @param offset to be written to
* @param v the short value to be written.
*/
void writeShort(long offset, int v);
/**
* Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in
* the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readUnsignedShort method of interface
* RandomDataInput , which will then return a short equal to (short)v.
*
* @param v the unsigned short value to be written.
*/
void writeUnsignedShort(int v);
/**
* Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in
* the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readShort method of interface
* RandomDataInput , which will then return a short equal to (short)v.
*
* @param offset to be written to
* @param v the unsigned short value to be written.
*/
void writeUnsignedShort(long offset, int v);
/**
* Writes one or three bytes as follows; Short.MIN_VALUE => Byte.MIN_VALUE, Short.MAX_VALUE => Byte.MAX_VALUE,
* Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeByte(x), default => writeByte(Byte.MIN_VALUE+1;
* writeShort(x)
*
* The bytes written by this method may be read by the readCompactShort method of interface
* RandomDataInput , which will then return a short equal to (short)v.
*
* @param v the short value to be written.
*/
void writeCompactShort(int v);
/**
* Writes one or three bytes as follows; 0 to 254 => writeByte(x); otherwise writeByte(255); writeByteShort(x);
*
* The bytes written by this method may be read by the readCompactUnsignedShort method of interface
* RandomDataInput , which will then return a short equal to v & 0xFFFF.
*
* @param v the unsigned short value to be written.
*/
void writeCompactUnsignedShort(int v);
/**
* Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readChar method of interface
* DataInput , which will then return a char equal to (char)v.
*
* @param v the char value to be written.
*/
@Override
void writeChar(int v);
/**
* Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readChar method of interface
* DataInput , which will then return a char equal to (char)v.
*
* @param offset to be written to
* @param v the char value to be written.
*/
void writeChar(long offset, int v);
/**
* Writes an int value, which is comprised of three bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt24 method of interface
* RandomDataInput , which will then return an int equal to v.
*
* @param v the int value to be written.
*/
void writeInt24(int v);
/**
* Writes an int value, which is comprised of three bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt24 method of interface
* RandomDataInput , which will then return an int equal to v.
*
* @param offset to be written to
* @param v the int value to be written.
*/
void writeInt24(long offset, int v);
/**
* Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt method of interface
* DataInput , which will then return an int equal to v.
*
* @param v the int value to be written.
*/
@Override
void writeInt(int v);
/**
* Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt method of interface
* DataInput , which will then return an int equal to v.
*
* @param offset to be written to
* @param v the int value to be written.
*/
void writeInt(long offset, int v);
/**
* Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readUnsignedInt method of interface
* RandomDataInput , which will then return an long equal to v &
* 0xFFFFFFFF.
*
* @param v the int value to be written.
*/
void writeUnsignedInt(long v);
/**
* Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readUnsignedInt method of interface
* RandomDataInput , which will then return an long equal to v &
* 0xFFFFFFFF.
*
* @param offset to be written to
* @param v the int value to be written.
*/
void writeUnsignedInt(long offset, long v);
/**
* Writes two or six bytes as follows; Integer.MIN_VALUE => Short.MIN_VALUE, Integer.MAX_VALUE =>
* Short.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeShort(x), default =>
* writeShort(Short.MIN_VALUE+1; writeInt(x)
*
* The bytes written by this method may be read by the readCompactInt method of interface
* RandomDataInput , which will then return a int equal to v.
*
* @param v the int value to be written.
*/
void writeCompactInt(int v);
/**
* Writes two or six bytes as follows; 0 to (1 << 16) - 2 => writeInt(x), otherwise writeShort(-1);
* writeInt(x)
*
* The bytes written by this method may be read by the readCompactUnsignedInt method of interface
* RandomDataInput , which will then return a int equal to v &
* 0xFFFFFFFF.
*
* @param v the short value to be written.
*/
void writeCompactUnsignedInt(long v);
/**
* Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier
* if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read
* could see an old value
*
* This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the
* same time.
*
* @param v value to write
*/
void writeOrderedInt(int v);
/**
* Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier
* if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read
* could see an old value
*
* This is much faster than writeVolatileInt as the volatile write stalls the pipeline. The data is
* visible to other threads at the same time.
*
* @param offset to write to
* @param v value to write
*/
void writeOrderedInt(long offset, int v);
/**
* Perform a compare and set operation. The value is set to x provided the expected value
* is set already. This operation is atomic.
*
* @param offset to write to.
* @param expected to expect
* @param x to set if expected was found
* @return true if set, false if the value was not expected
*/
boolean compareAndSwapInt(long offset, int expected, int x);
/**
* Atomically adds the given value to the current value.
*
* @param offset of the int value to use.
* @param delta the value to add
* @return the previous value
*/
int getAndAdd(long offset, int delta);
/**
* Atomically adds the given value to the current value.
*
* @param offset of the int value to use.
* @param delta the value to add
* @return the updated value
*/
int addAndGetInt(long offset, int delta);
/**
* Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 40))
* (byte)(0xff & (v >> 32))
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt48 method of interface
* RandomDataInput , which will then return a long equal to v & ((1L << 48)
* - 1).
*
* @param v the long value to be written.
*/
void writeInt48(long v);
/**
* Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 40))
* (byte)(0xff & (v >> 32))
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readInt48 method of interface
* RandomDataInput , which will then return a long equal to v & ((1L << 48)
* - 1).
*
* @param offset to be written to
* @param v the long value to be written.
*/
void writeInt48(long offset, long v);
/**
* Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 56))
* (byte)(0xff & (v >> 48))
* (byte)(0xff & (v >> 40))
* (byte)(0xff & (v >> 32))
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readLong method of interface
* DataInput , which will then return a long equal to v.
*
* @param v the long value to be written.
*/
@Override
void writeLong(long v);
/**
* Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be
* written, in the order shown for big endian machines and the opposite for little endian, are:
*
* (byte)(0xff & (v >> 56))
* (byte)(0xff & (v >> 48))
* (byte)(0xff & (v >> 40))
* (byte)(0xff & (v >> 32))
* (byte)(0xff & (v >> 24))
* (byte)(0xff & (v >> 16))
* (byte)(0xff & (v >> 8))
* (byte)(0xff & v)
*
* The bytes written by this method may be read by the readLong method of interface
* DataInput , which will then return a long equal to v.
*
* @param offset to be written to
* @param v the long value to be written.
*/
void writeLong(long offset, long v);
/**
* Writes four or twelve bytes as follows Long.MIN_VALUE => Integer.MIN_VALUE, Long.MAX_VALUE =>
* Integer.MAX_VALUE, Integer.MIN_VALUE+2 to Integer.MAX_VALUE-1 => writeInt(x), default =>
* writeInt(Integer.MIN_VALUE+1; writeLong(x)
*
* The bytes written by this method may be read by the readCompactLong method of interface
* RandomDataInput , which will then return a long equal to v.
*
* @param v the long value to be written.
*/
void writeCompactLong(long v);
/**
* Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier
* if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read
* could see an old value
*
* This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the
* same time.
*
* @param v value to write
*/
void writeOrderedLong(long v);
/**
* Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier
* if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read
* could see an old value
*
* This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the
* same time.
*
* @param offset to be written to
* @param v value to write
*/
void writeOrderedLong(long offset, long v);
/**
* Perform a compare and set operation. The value is set to x provided the expected value
* is set already. This operation is atomic.
*
* @param offset to write to.
* @param expected to expect
* @param x to set if expected was found
* @return true if set, false if the value was not expected
*/
boolean compareAndSwapLong(long offset, long expected, long x);
/**
* Stop bit encoding numbers. This will write the same number of bytes whether you used a byte, short or int.
*/
void writeStopBit(long n);
/**
* Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it
* first converts this float value to an int in exactly the manner of the
* Float.floatToIntBits method and then writes the int value in exactly the manner of the
* writeInt method. The bytes written by this method may be read by the readFloat method
* of interface DataInput, which will then return a float equal to v.
*
* @param v the float value to be written.
*/
@Override
void writeFloat(float v);
/**
* Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it
* first converts this float value to an int in exactly the manner of the
* Float.floatToIntBits method and then writes the int value in exactly the manner of the
* writeInt method. The bytes written by this method may be read by the readFloat method
* of interface DataInput, which will then return a float equal to v.
*
* @param offset to write to
* @param v the float value to be written.
*/
void writeFloat(long offset, float v);
/**
* Same as writeFloat but include an ordered write barrier. This means all writes will be visible on a read barrier
* if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read
* could see an old value
*
* This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the
* same time.
*
* @param v value to write
*/
void writeOrderedFloat(long offset, float v);
/**
* Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if
* it first converts this double value to a long in exactly the manner of the
* Double.doubleToLongBits method and then writes the long value in exactly the manner of
* the writeLong method. The bytes written by this method may be read by the readDouble
* method of interface DataInput, which will then return a double equal to
* v.
*
* @param v the double value to be written.
*/
@Override
void writeDouble(double v);
/**
* Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if
* it first converts this double value to a long in exactly the manner of the
* Double.doubleToLongBits method and then writes the long value in exactly the manner of
* the writeLong method. The bytes written by this method may be read by the readDouble
* method of interface DataInput, which will then return a double equal to
* v.
*
* @param offset to write to
* @param v the double value to be written.
*/
void writeDouble(long offset, double v);
/**
* Writes four or twelve bytes as follow;
*
* if ((float) d == d) {
* writeFloat((float) d);
* } else {
* writeFloat(Float.NaN);
* writeDouble(d);
* }
*
* The bytes written by this method may be read by the readCompactDouble method of interface
* RandomDataInput , which will then return a double equal to v.
*
* @param v the double value to be written.
*/
void writeCompactDouble(double v);
/**
* Same as writeDouble but include an ordered write barrier. This means all writes will be visible on a read
* barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an
* immediate read could see an old value
*
* This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the
* same time.
*
* @param v value to write
*/
void writeOrderedDouble(long offset, double v);
/**
* Writes a string to the output stream. For every character in the string s, taken in order, one byte
* is written to the output stream. If s is null, a NullPointerException is
* thrown. If s.length is zero, then no bytes are written. Otherwise, the character
* s[0] is written first, then s[1], and so on; the last character written is
* s[s.length-1]. For each character, one byte is written, the low-order byte, in exactly the manner of
* the writeByte method . The high-order eight bits of each character in the string are ignored.
*
* @param s the string of bytes to be written. Cannot be null.
*/
@Override
void writeBytes(@NotNull String s);
/**
* Writes every character in the string s, to the output stream, in order, two bytes per character. If
* s is null, a NullPointerException is thrown. If s.length is
* zero, then no characters are written. Otherwise, the character s[0] is written first, then
* s[1], and so on; the last character written is s[s.length-1]. For each character, two
* bytes are actually written, high-order byte first, in exactly the manner of the writeChar method.
*
* @param s the string value to be written. Cannot be null.
*/
@Override
void writeChars(@NotNull String s);
/**
* Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string
* s. If s is null, a NullPointerException is thrown. Each
* character in the string s is converted to a group of one, two, or three bytes, depending on the
* value of the character.
If a character c is in the range \u0001 through
* \u007f, it is represented by one byte:
*
(byte)c
* If a character c is \u0000 or is in the range \u0080 through
* \u07ff, then it is represented by two bytes, to be written
* in the order shown:
* (byte)(0xc0 | (0x1f & (c >> 6)))
* (byte)(0x80 | (0x3f & c))
*
If a character
* c is in the range \u0800 through uffff, then it is represented by
* three bytes, to be written
* in the order shown:
* (byte)(0xe0 | (0x0f & (c >> 12)))
* (byte)(0x80 | (0x3f & (c >> 6)))
* (byte)(0x80 | (0x3f & c))
*
First,
* the total number of bytes needed to represent all the characters of s is calculated. If this number
* is larger than 65535, then a UTFDataFormatException is thrown. Otherwise, this length
* is written to the output stream in exactly the manner of the writeShort method; after this, the
* one-, two-, or three-byte representation of each character in the string s is written.
The bytes
* written by this method may be read by the readUTF method of interface DataInput , which
* will then return a String equal to s.
*
* @param s the string value to be written. Cannot be null
*/
@Override
void writeUTF(@NotNull String s);
/**
* Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded
* i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.
*
* @param s the string value to be written. Can be null.
*/
void writeUTFΔ(@Nullable CharSequence s);
/**
* Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded
* i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.
*
* @param offset to write to
* @param maxSize maximum number of bytes to use
* @param s the string value to be written. Can be null.
* @throws IllegalStateException if the size is too large.
*/
void writeUTFΔ(long offset, int maxSize, @Nullable CharSequence s) throws IllegalStateException;
/**
* Copies the contents of a ByteBuffer from the potision ot the limit.
*
* @param bb to copy.
*/
void write(@NotNull ByteBuffer bb);
/**
* Write the object in a form which can be uniquely recreated by readEnum. This type of "enumerable objects" has
* the following constraints; 1) each object must have a one to one mapping with a toString() representation, 2) be
* immutable, 3) ideally appears more than once, 4) Must have a constructor which takes a single String or a
* valueOf(String) method.
*
* @param e to enumerate
* @param element class
*/
void writeEnum(@Nullable E e);
/**
* Write an ordered collection of "enumerable objects" (See writeEnum). This writes the stop bit encoded length,
* followed by multiple calls to writeEnum All the elements must be of the same type.
*
* This can be read by the readList method of RandomInputStream and the reader must know
* the type of each element. You can send the class first by using writeEnum of the element class
*
* @param list to be written
*/
void writeList(@NotNull Collection list);
/**
* Write the keys and values of a Map of "enumerable objects" (See writeEnum). This writes the stop bit encoded
* length, followed by multiple calls to writeEnum for each key and value. All the keys must be of the
* same type. All values must be of the same type.
*
* @param map to write out
*/
void writeMap(@NotNull Map map);
// ObjectOutput
/**
* Write an object as either an "enumerable object" or a Serializable/Externalizable object using Java
* Serialization. Java Serialization is much slower but sometimes more convenient than using
* BytesMarshallable.
*
* @param object to write
*/
@Override
void writeObject(@Nullable Object object);
/**
* Copy data from an Object from bytes start to end.
*
* @param object to copy from
* @param start first byte inclusive
* @param end last byte exclusive.
*/
void writeObject(Object object, int start, int end);
/**
* Check the end of the stream has not overflowed. Otherwise this doesn't do anything.
*/
@Override
void flush();
/**
* The same as calling finish();
*/
@Override
void close();
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/RandomDataUpdate.java 0000664 0000000 0000000 00000012671 12267523751 0026461 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io;
/**
* This class supports updates which are a companion to RandomDataInput and RandomDataOutput
*/
public interface RandomDataUpdate {
byte addByte(long offset, byte b);
int addUnsignedByte(long offset, int i);
short addShort(long offset, short s);
int addUnsignedShort(long offset, int i);
int addInt(long offset, int i);
long addUnsignedInt(long offset, long i);
long addLong(long offset, long i);
float addFloat(long offset, float f);
double addDouble(long offset, double d);
int addAtomicInt(long offset, int i);
long addAtomicLong(long offset, long l);
float addAtomicFloat(long offset, float f);
double addAtomicDouble(long offset, double d);
/**
* Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times
* you will get an ISE
*
* @param offset of the start of the 4-byte lock
* @return did it lock or not.
*/
boolean tryLockInt(long offset);
/**
* Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times
* you will get an ISE
*
* @param offset of the start of the 4-byte lock
* @param nanos to try to lock for
* @return did it lock or not.
*/
boolean tryLockNanosInt(long offset, long nanos);
/**
* Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times
* you will get an ISE
*
* @param offset of the start of the 4-byte lock
* @throws InterruptedException if interrupted
* @throws IllegalStateException if the thread tries to lock it 255 nested time (without an unlock)
*/
void busyLockInt(long offset) throws InterruptedException, IllegalStateException;
/**
* Lock which uses 4 bytes. Unlock this It store the lower 24 bits of the Thread Id and the re-entrant count as 8
* bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter
* 255 times you will get an ISE
*
* @param offset of the start of the 4-byte lock
* @throws IllegalMonitorStateException if this thread doesn't hold the lock
*/
void unlockInt(long offset) throws IllegalMonitorStateException;
/**
* Lock across processes
*
* Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times
* you will get an ISE
*
* @param offset of the start of the 8-byte lock
* @return did it lock or not.
*/
boolean tryLockLong(long offset);
/**
* Lock across processes
*
* Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times
* you will get an ISE
*
* @param offset of the start of the 8-byte lock
* @param nanos to try to lock for
* @return did it lock or not.
*/
boolean tryLockNanosLong(long offset, long nanos);
/**
* Lock across processes
*
* Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times
* you will get an ISE
*
* @param offset of the start of the 8-byte lock
* @throws InterruptedException if interrupted
* @throws IllegalStateException if the thread tries to lock it 65535 nested time (without an unlock)
*/
void busyLockLong(long offset) throws InterruptedException, IllegalStateException;
/**
* Lock across processes
*
* Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This
* means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times
* you will get an ISE
*
* @param offset of the start of the 8-byte lock
* @throws IllegalMonitorStateException if this thread doesn't hold the lock
*/
void unlockLong(long offset) throws IllegalMonitorStateException;
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/StopCharTester.java 0000775 0000000 0000000 00000002276 12267523751 0026221 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io;
/**
* @author peter.lawrey
*/
public interface StopCharTester {
/**
* Detect which byte stops the string to be parsed
*
* This should be changed to support char instead.
*
* Note: for safety reasons, you should stop on a 0 byte or throw an IllegalStateException.
*
* @param ch to test, 0 should return true or throw an exception.
* @return if this byte is a stop character.
* @throws IllegalStateException if an invalid character like 0 was detected.
*/
boolean isStopChar(int ch) throws IllegalStateException;
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/StopCharTesters.java 0000775 0000000 0000000 00000004562 12267523751 0026404 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io;
import org.jetbrains.annotations.NotNull;
/**
* @author peter.lawrey
*/
public enum StopCharTesters implements StopCharTester {
COMMA_STOP {
@Override
public boolean isStopChar(int ch) {
return ch < ' ' || ch == ',';
}
}, CONTROL_STOP {
@Override
public boolean isStopChar(int ch) {
return ch < ' ';
}
},
SPACE_STOP {
@Override
public boolean isStopChar(int ch) {
return Character.isWhitespace(ch) || ch == 0;
}
},
XML_TEXT {
@Override
public boolean isStopChar(int ch) {
return ch == '"' || ch == '<' || ch == '>' || ch == 0;
}
},
FIX_TEXT {
@Override
public boolean isStopChar(int ch) {
return ch <= 1;
}
};
@NotNull
public static StopCharTester forChars(@NotNull CharSequence sequence) {
if (sequence.length() == 1)
return forChar(sequence.charAt(0));
return new CSCSTester(sequence);
}
@NotNull
public static StopCharTester forChar(char ch) {
return new CharCSTester(ch);
}
static class CSCSTester implements StopCharTester {
@NotNull
private final String seperators;
public CSCSTester(@NotNull CharSequence cs) {
seperators = cs.toString();
}
@Override
public boolean isStopChar(int ch) {
return seperators.indexOf(ch) >= 0;
}
}
static class CharCSTester implements StopCharTester {
private final char ch;
public CharCSTester(char ch) {
this.ch = ch;
}
@Override
public boolean isStopChar(int ch) {
return this.ch == ch;
}
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/ 0000775 0000000 0000000 00000000000 12267523751 0025307 5 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/BytesMarshallable.java 0000664 0000000 0000000 00000002307 12267523751 0031552 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization;
import net.openhft.lang.io.Bytes;
import org.jetbrains.annotations.NotNull;
/**
* Integrated marshaller for objects.
*
* @author peter.lawrey
* @see BytesMarshaller
*/
public interface BytesMarshallable {
/**
* read an object from bytes
*
* @param in to read from
* @throws IllegalStateException if the object could not be read.
*/
void readMarshallable(@NotNull Bytes in) throws IllegalStateException;
/**
* write an object to bytes
*
* @param out to write to
*/
void writeMarshallable(@NotNull Bytes out);
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/BytesMarshaller.java 0000664 0000000 0000000 00000002224 12267523751 0031253 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization;
import net.openhft.lang.io.Bytes;
import org.jetbrains.annotations.Nullable;
/**
* External marshaller for classes.
*
* @author peter.lawrey
* @see BytesMarshallable
*/
public interface BytesMarshaller {
/**
* write the object out as bytes.
*
* @param bytes to write to
* @param e to write
*/
void write(Bytes bytes, E e);
/**
* Read bytes and obtain an object
*
* @param bytes to read
* @return the object
*/
@Nullable
E read(Bytes bytes);
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/BytesMarshallerFactory.java 0000664 0000000 0000000 00000001744 12267523751 0032611 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization;
import org.jetbrains.annotations.NotNull;
/**
* @author peter.lawrey
*/
public interface BytesMarshallerFactory {
@NotNull
BytesMarshaller acquireMarshaller(@NotNull Class eClass, boolean create);
BytesMarshaller getMarshaller(byte code);
void addMarshaller(Class eClass, BytesMarshaller marshaller);
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/CompactBytesMarshaller.java 0000664 0000000 0000000 00000001521 12267523751 0032561 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization;
/**
* A BytesMarshaller with a byte code for the class.
*/
public interface CompactBytesMarshaller extends BytesMarshaller {
/**
* the code for this marshaller
*/
byte code();
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/RawCopier.java 0000664 0000000 0000000 00000006223 12267523751 0030050 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization;
import net.openhft.lang.io.Bytes;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import static net.openhft.lang.io.NativeBytes.UNSAFE;
/**
* User: peter.lawrey Date: 22/09/13 Time: 16:51
*/
public class RawCopier {
final int start, end;
private final Class tClass;
public RawCopier(Class tClass) {
this.tClass = tClass;
List fields = new ArrayList();
addAllFields(fields, tClass);
Collections.sort(fields, new Comparator() {
@Override
public int compare(Field o1, Field o2) {
long off1 = UNSAFE.objectFieldOffset(o1);
long off2 = UNSAFE.objectFieldOffset(o2);
return Double.compare(off1, off2);
}
});
start = (int) UNSAFE.objectFieldOffset(fields.get(0));
Field lastField = null;
for (Field field : fields) {
if (Modifier.isTransient(field.getModifiers()) || !field.getType().isPrimitive())
break;
lastField = field;
}
end = (int) UNSAFE.objectFieldOffset(lastField) + sizeOf(lastField.getType());
assert end > start : "end <= start, start: " + start + ", end: " + end;
}
public static RawCopier copies(Class tClass) {
return new RawCopier(tClass);
}
private static int sizeOf(Class type) {
return UNSAFE.arrayIndexScale(Array.newInstance(type, 0).getClass());
}
public int start() {
return start;
}
public int end() {
return end;
}
public void toBytes(Object obj, Bytes bytes) {
bytes.writeObject(obj, start, end);
}
public void fromBytes(Bytes bytes, Object obj) {
bytes.readObject(obj, start, end);
}
public void copy(T from, T to) {
long i;
for (i = start; i < end - 7; i += 8) {
UNSAFE.putLong(to, i, UNSAFE.getLong(from, i));
}
for (; i < end; i++) {
UNSAFE.putByte(to, i, UNSAFE.getByte(from, i));
}
}
private void addAllFields(List fields, Class tClass) {
if (tClass != null && tClass != Object.class)
addAllFields(fields, tClass.getSuperclass());
for (Field field : tClass.getDeclaredFields()) {
if (!Modifier.isStatic(field.getModifiers()))
fields.add(field);
}
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct/ 0000775 0000000 0000000 00000000000 12267523751 0026561 5 ustar 00root root 0000000 0000000 DirectSerializationFilter.java 0000664 0000000 0000000 00000001501 12267523751 0034460 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct package net.openhft.lang.io.serialization.direct;
import java.lang.reflect.Field;
import java.util.*;
import static net.openhft.lang.io.serialization.direct.FieldMetadata.*;
public final class DirectSerializationFilter {
public static List stopAtFirstIneligibleField(List fields) {
ArrayList eligibleFields = new ArrayList();
for (Field f : fields) {
if (checkEligible(f)) {
eligibleFields.add(f);
} else {
break;
}
}
return eligibleFields.isEmpty() ?
Collections.emptyList() :
eligibleFields;
}
private static boolean checkEligible(Field f) {
return isPrimitive(f) &&
!isStatic(f) &&
!isTransient(f);
}
} DirectSerializationMetadata.java 0000664 0000000 0000000 00000006065 12267523751 0034765 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct package net.openhft.lang.io.serialization.direct;
import net.openhft.lang.Jvm;
import java.lang.reflect.Field;
import java.util.List;
import static net.openhft.lang.io.NativeBytes.UNSAFE;
public class DirectSerializationMetadata {
private static final int OBJECT_ALIGNMENT = 8;
private static final int OBJECT_ALIGNMENT_MASK = OBJECT_ALIGNMENT - 1;
static final long NATIVE_WORD_SIZE = Jvm.is64Bit() ? 8 : 4;
static final long OOP_SIZE = UNSAFE.arrayIndexScale(Object[].class);
static final long OBJECT_HEADER_SIZE = NATIVE_WORD_SIZE + OOP_SIZE; // Object header has a native sized mark word + variable sized oop to klass meta object
public static final SerializationMetadata EmptyObjectMetadata = new SerializationMetadata(0, 0);
public static final class SerializationMetadata {
final long start;
final long length;
SerializationMetadata(long start, long length) {
this.start = start;
this.length = length;
}
@Override
public String toString() {
return String.format("SerializationMetadata: Start %s Length %s", start, length);
}
}
public static SerializationMetadata extractMetadata(List fields) {
if (fields.isEmpty()) return EmptyObjectMetadata;
Offsets offsets = minMaxOffsets(fields);
long totalSize = OBJECT_HEADER_SIZE + offsets.max - offsets.min + 1;
return new SerializationMetadata(offsets.min, padToObjectAlignment(totalSize) - OBJECT_HEADER_SIZE);
}
public static SerializationMetadata extractMetadataForPartialCopy(List fields) {
if (fields.isEmpty()) return EmptyObjectMetadata;
Offsets offsets = minMaxOffsets(fields);
Field lastField = fields.get(fields.size() - 1);
return new SerializationMetadata(offsets.min, offsets.max + sizeOf(lastField) - OBJECT_HEADER_SIZE);
}
private static Offsets minMaxOffsets(List fields) {
long minOffset = UNSAFE.objectFieldOffset(fields.get(0));
long maxOffset = UNSAFE.objectFieldOffset(fields.get(fields.size() - 1));
return new Offsets(minOffset, maxOffset);
}
static long padToObjectAlignment(long length) {
if ((length & OBJECT_ALIGNMENT_MASK) != 0) {
long padding = OBJECT_ALIGNMENT - (length & OBJECT_ALIGNMENT_MASK);
length += padding;
}
return length;
}
private static long sizeOf(Field field) {
if (boolean.class.equals(field.getType())) return 1;
else if (byte.class.equals(field.getType())) return 1;
else if (short.class.equals(field.getType())) return 2;
else if (char.class.equals(field.getType())) return 2;
else if (int.class.equals(field.getType())) return 4;
else if (float.class.equals(field.getType())) return 4;
else return 8;
}
private static final class Offsets {
public final long min;
public final long max;
private Offsets(long min, long max) {
this.min = min;
this.max = max;
}
}
} Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct/FieldMetadata.java 0000664 0000000 0000000 00000001133 12267523751 0032106 0 ustar 00root root 0000000 0000000 package net.openhft.lang.io.serialization.direct;
import java.lang.reflect.*;
public final class FieldMetadata {
public static boolean isPrimitive(Field f) {
return f.getType().isPrimitive();
}
public static boolean isPrimitiveArray(Field f) {
Class clazz = f.getType();
return clazz.isArray() && clazz.getComponentType().isPrimitive();
}
public static boolean isStatic(Field f) {
return Modifier.isStatic(f.getModifiers());
}
public static boolean isTransient(Field f) {
return Modifier.isTransient(f.getModifiers());
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct/Introspect.java 0000664 0000000 0000000 00000004076 12267523751 0031565 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.direct;
import net.openhft.lang.Maths;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import static net.openhft.lang.io.NativeBytes.UNSAFE;
import static net.openhft.lang.io.serialization.direct.FieldMetadata.isStatic;
public class Introspect {
public static List fields(Class clazz) {
ArrayList fields = new ArrayList();
addToFields(clazz, fields);
Collections.sort(fields, FieldOffsetComparator.Instance);
return fields;
}
private static List addToFields(Class clazz, ArrayList accumulator) {
Collections.addAll(accumulator, clazz.getDeclaredFields());
Class maybeSuper = clazz.getSuperclass();
return maybeSuper != null ?
addToFields(maybeSuper, accumulator) :
accumulator;
}
private static final class FieldOffsetComparator implements Comparator {
public static final FieldOffsetComparator Instance = new FieldOffsetComparator();
@Override
public int compare(Field first, Field second) {
return Maths.compare(offset(first), offset(second));
}
private static long offset(Field field) {
return isStatic(field) ?
UNSAFE.staticFieldOffset(field) :
UNSAFE.objectFieldOffset(field);
}
}
} Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct/ObjectMarshaller.java 0000664 0000000 0000000 00000002367 12267523751 0032655 0 ustar 00root root 0000000 0000000 package net.openhft.lang.io.serialization.direct;
import net.openhft.lang.io.Bytes;
import static net.openhft.lang.io.NativeBytes.UNSAFE;
import static net.openhft.lang.io.serialization.direct.DirectSerializationMetadata.SerializationMetadata;
public final class ObjectMarshaller {
private final SerializationMetadata metadata;
public ObjectMarshaller(SerializationMetadata metadata) {
this.metadata = metadata;
}
public void write(Bytes bytes, T tObject) {
long i = metadata.start;
long end = metadata.start + metadata.length;
while (i < end - 7) {
bytes.writeLong(UNSAFE.getLong(tObject, i));
i += 8;
}
while (i < end) {
bytes.writeByte(UNSAFE.getByte(tObject, i));
++i;
}
}
public T read(Bytes bytes, T tObject) {
long i = metadata.start;
long end = metadata.start + metadata.length;
while (i < end - 7) {
UNSAFE.putLong(tObject, i, bytes.readLong());
i += 8;
}
while (i < end) {
UNSAFE.putByte(tObject, i, bytes.readByte());
++i;
}
return tObject;
}
public long length() {
return metadata.length;
}
} Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/direct/ObjectMarshallers.java 0000664 0000000 0000000 00000005452 12267523751 0033036 0 ustar 00root root 0000000 0000000 package net.openhft.lang.io.serialization.direct;
import net.openhft.lang.io.NativeBytes;
import java.lang.reflect.Field;
import java.util.*;
import java.util.logging.Logger;
import static java.util.logging.Level.WARNING;
import static net.openhft.lang.io.serialization.direct.DirectSerializationMetadata.SerializationMetadata;
public final class ObjectMarshallers {
private static final Logger Log = Logger.getLogger(ObjectMarshallers.class.getName());
private static final Map metadata = new HashMap();
@SuppressWarnings("unchecked")
public static ObjectMarshaller forClass(Class clazz) {
ObjectMarshaller om = metadata.get(clazz);
if (om == null) {
List fields = Introspect.fields(clazz);
List eligibleFields = DirectSerializationFilter.stopAtFirstIneligibleField(fields);
SerializationMetadata serializationMetadata;
if (hasIneligibleFields(fields, eligibleFields)) {
WarnAboutIneligibleFields.apply(clazz, fields, eligibleFields);
serializationMetadata = DirectSerializationMetadata.extractMetadataForPartialCopy(eligibleFields);
} else {
serializationMetadata = DirectSerializationMetadata.extractMetadata(eligibleFields);
}
om = new ObjectMarshaller(serializationMetadata);
Log.log(WARNING, String.format("Class %s has metadata %s", clazz.getName(), serializationMetadata));
metadata.put(clazz, om);
}
return (ObjectMarshaller) om;
}
private static boolean hasIneligibleFields(List allFields, List eligibleFields) {
return allFields.size() != eligibleFields.size();
}
private static class WarnAboutIneligibleFields {
static void apply(Class clazz, List allFields, List eligibleFields) {
List ineligibleFields = allFields.subList(eligibleFields.size(), allFields.size());
Log.log(WARNING, String.format(
"The following fields in Class %s will not be copied by ObjectMarshaller:\n%s",
clazz.getName(),
commaSeparate(ineligibleFields)
));
}
private static String commaSeparate(Collection fields) {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (Field field : fields) {
if (first) {
sb.append("\t");
sb.append(field.getName());
first = false;
} else {
sb.append("\n\t");
sb.append(field.getName());
}
}
return sb.toString();
}
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/ 0000775 0000000 0000000 00000000000 12267523751 0026250 5 ustar 00root root 0000000 0000000 BytesMarshallableMarshaller.java 0000664 0000000 0000000 00000003136 12267523751 0034450 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshallable;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.NativeBytes;
import org.jetbrains.annotations.NotNull;
/**
* @author peter.lawrey
*/
public class BytesMarshallableMarshaller implements BytesMarshaller {
@NotNull
private final Class classMarshaled;
public BytesMarshallableMarshaller(@NotNull Class classMarshaled) {
this.classMarshaled = classMarshaled;
}
@Override
public void write(@NotNull Bytes bytes, @NotNull E e) {
e.writeMarshallable(bytes);
}
@Override
public E read(@NotNull Bytes bytes) {
E e;
try {
e = (E) NativeBytes.UNSAFE.allocateInstance(classMarshaled);
} catch (Exception e2) {
throw new IllegalStateException(e2);
}
e.readMarshallable(bytes);
return e;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/ClassMarshaller.java 0000664 0000000 0000000 00000006775 12267523751 0032212 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.Compare;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.CompactBytesMarshaller;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.lang.ref.WeakReference;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author peter.lawrey
*/
public class ClassMarshaller implements CompactBytesMarshaller {
private static final int CACHE_SIZE = 1019;
private static final Map SC_SHORT_NAME = new LinkedHashMap();
private static final Map CS_SHORT_NAME = new LinkedHashMap();
static {
Class[] classes = {Boolean.class, Byte.class, Character.class, Short.class, Integer.class, Long.class, Float.class, Double.class,
String.class, Class.class, BigInteger.class, BigDecimal.class, Date.class};
for (Class clazz : classes) {
String simpleName = clazz.getSimpleName();
SC_SHORT_NAME.put(simpleName, clazz);
CS_SHORT_NAME.put(clazz, simpleName);
}
}
private final ClassLoader classLoader;
private final StringBuilder className = new StringBuilder(40);
@Nullable
@SuppressWarnings("unchecked")
private WeakReference[] classWeakReference = null;
public ClassMarshaller(ClassLoader classLoader) {
this.classLoader = classLoader;
}
@Override
public void write(@NotNull Bytes bytes, @NotNull Class aClass) {
String s = CS_SHORT_NAME.get(aClass);
if (s == null)
s = aClass.getName();
bytes.writeUTFΔ(s);
}
@Nullable
@Override
public Class read(@NotNull Bytes bytes) {
className.setLength(0);
bytes.readUTFΔ(className);
return load(className);
}
@Nullable
private Class load(@NotNull CharSequence name) {
int hash = (int) (Compare.calcLongHashCode(name) & 0x7ffffff) % CACHE_SIZE;
if (classWeakReference == null)
//noinspection unchecked
classWeakReference = new WeakReference[CACHE_SIZE];
WeakReference ref = classWeakReference[hash];
if (ref != null) {
Class clazz = ref.get();
if (clazz != null && clazz.getName().equals(name))
return clazz;
}
try {
Class clazz = SC_SHORT_NAME.get(name.toString());
if (clazz != null)
return clazz;
clazz = classLoader.loadClass(name.toString());
classWeakReference[hash] = new WeakReference(clazz);
return clazz;
} catch (ClassNotFoundException e) {
throw new IllegalArgumentException(e);
}
}
@Override
public byte code() {
return 'C' & 31; // control C
}
}
CompactEnumBytesMarshaller.java 0000664 0000000 0000000 00000002407 12267523751 0034274 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.serialization.CompactBytesMarshaller;
import org.jetbrains.annotations.NotNull;
/**
* Created with IntelliJ IDEA. User: peter Date: 09/12/13 Time: 17:05 To change this template use File | Settings | File
* Templates.
*/
public class CompactEnumBytesMarshaller extends GenericEnumMarshaller implements CompactBytesMarshaller {
private final byte code;
public CompactEnumBytesMarshaller(@NotNull Class classMarshaled, int capacity, byte code) {
super(classMarshaled, capacity);
this.code = code;
}
@Override
public byte code() {
return code;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/DateMarshaller.java 0000664 0000000 0000000 00000005373 12267523751 0032013 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.CompactBytesMarshaller;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Date;
/**
* @author peter.lawrey
*/
public class DateMarshaller implements CompactBytesMarshaller {
final int size1;
private final StringBuilder sb = new StringBuilder();
@Nullable
private Date[] interner = null;
public DateMarshaller(int size) {
int size2 = 128;
while (size2 < size && size2 < (1 << 20)) size2 <<= 1;
this.size1 = size2 - 1;
}
private static long parseLong(@NotNull CharSequence sb) {
long num = 0;
boolean negative = false;
for (int i = 0; i < sb.length(); i++) {
char b = sb.charAt(i);
// if (b >= '0' && b <= '9')
if ((b - ('0' + Integer.MIN_VALUE)) <= 9 + Integer.MIN_VALUE)
num = num * 10 + b - '0';
else if (b == '-')
negative = true;
else
break;
}
return negative ? -num : num;
}
@Override
public void write(@NotNull Bytes bytes, @NotNull Date date) {
long pos = bytes.position();
bytes.writeUnsignedByte(0);
bytes.append(date.getTime());
bytes.writeUnsignedByte(pos, (int) (bytes.position() - 1 - pos));
}
@Nullable
@Override
public Date read(@NotNull Bytes bytes) {
bytes.readUTFΔ(sb);
long time = parseLong(sb);
return lookupDate(time);
}
@Nullable
private Date lookupDate(long time) {
int idx = hashFor(time);
if (interner == null)
interner = new Date[size1 + 1];
Date date = interner[idx];
if (date != null && date.getTime() == time)
return date;
return interner[idx] = new Date(time);
}
private int hashFor(long time) {
long h = time;
h ^= (h >>> 41) ^ (h >>> 20);
h ^= (h >>> 14) ^ (h >>> 7);
return (int) (h & size1);
}
@Override
public byte code() {
return 'T' & 31; // Control T.
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/EnumBytesMarshaller.java 0000664 0000000 0000000 00000005634 12267523751 0033051 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshaller;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.BitSet;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author peter.lawrey
*/
public class EnumBytesMarshaller> implements BytesMarshaller {
@NotNull
private final Class classMarshaled;
@SuppressWarnings("unchecked")
private final E[] interner = (E[]) new Enum[1024];
private final BitSet internerDup = new BitSet(1024);
private final Map map = new LinkedHashMap();
private final E defaultValue;
private final int mask;
private final StringBuilder reader = new StringBuilder();
public EnumBytesMarshaller(@NotNull Class classMarshaled, E defaultValue) {
this.classMarshaled = classMarshaled;
this.defaultValue = defaultValue;
mask = interner.length - 1;
for (E e : classMarshaled.getEnumConstants()) {
map.put(e.name(), e);
int idx = hashFor(e.name());
if (!internerDup.get(idx)) {
if (interner[idx] != null) {
//noinspection UnqualifiedFieldAccess,AssignmentToNull
interner[idx] = null;
internerDup.set(idx);
} else {
interner[idx] = e;
}
}
}
}
@Override
public void write(@NotNull Bytes bytes, @Nullable E e) {
bytes.writeUTFΔ(e == null ? "" : e.name());
}
private int hashFor(@NotNull CharSequence cs) {
int h = 0;
for (int i = 0, length = cs.length(); i < length; i++)
h = 57 * h + cs.charAt(i);
h ^= (h >>> 20) ^ (h >>> 12);
h ^= (h >>> 7) ^ (h >>> 4);
return h & mask;
}
@Override
public E read(@NotNull Bytes bytes) {
bytes.readUTFΔ(reader);
return builderToEnum();
}
private E builderToEnum() {
int num = hashFor(reader);
int idx = num & mask;
E e = interner[idx];
if (e != null) return e;
if (!internerDup.get(idx)) return defaultValue;
e = map.get(reader.toString());
return e == null ? defaultValue : e;
}
}
ExternalizableMarshaller.java 0000664 0000000 0000000 00000003257 12267523751 0034027 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.NativeBytes;
import org.jetbrains.annotations.NotNull;
import java.io.Externalizable;
import java.io.IOException;
/**
* @author peter.lawrey
*/
public class ExternalizableMarshaller implements BytesMarshaller {
@NotNull
private final Class classMarshaled;
public ExternalizableMarshaller(@NotNull Class classMarshaled) {
this.classMarshaled = classMarshaled;
}
@Override
public void write(Bytes bytes, @NotNull E e) {
try {
e.writeExternal(bytes);
} catch (IOException e2) {
throw new IllegalStateException(e2);
}
}
@Override
public E read(Bytes bytes) {
E e;
try {
e = (E) NativeBytes.UNSAFE.allocateInstance(classMarshaled);
e.readExternal(bytes);
} catch (Exception e2) {
throw new IllegalStateException(e2);
}
return e;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/GenericEnumMarshaller.java0000664 0000000 0000000 00000005760 12267523751 0033337 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshaller;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author peter.lawrey
*/
public class GenericEnumMarshaller implements BytesMarshaller {
@NotNull
private final Class classMarshaled;
@Nullable
private final Constructor constructor;
@Nullable
private final Method valueOf;
@NotNull
private final Map map;
public GenericEnumMarshaller(@NotNull Class classMarshaled, final int capacity) {
this.classMarshaled = classMarshaled;
Constructor constructor = null;
Method valueOf = null;
try {
valueOf = classMarshaled.getMethod("valueOf", String.class);
} catch (NoSuchMethodException e) {
try {
constructor = classMarshaled.getConstructor(String.class);
} catch (NoSuchMethodException e1) {
throw new IllegalArgumentException(classMarshaled + " doesn't have a valueOf(String) or a Constructor(String)");
}
}
this.constructor = constructor;
this.valueOf = valueOf;
map = new LinkedHashMap(128, 0.7f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size() > capacity;
}
};
}
@Override
public void write(@NotNull Bytes bytes, @Nullable E e) {
bytes.writeUTFΔ(e == null ? null : e.toString());
}
@Nullable
@Override
public E read(@NotNull Bytes bytes) {
String s = bytes.readUTFΔ();
return s == null ? null : valueOf(s);
}
private E valueOf(String s) {
E e = map.get(s);
if (e == null)
try {
if (constructor != null) {
map.put(s, e = constructor.newInstance(s));
} else {
@SuppressWarnings("unchecked")
E invoke = (E) valueOf.invoke(null, s);
map.put(s, e = invoke);
}
} catch (Exception t) {
throw new AssertionError(t.getCause());
}
return e;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/NoMarshaller.java 0000664 0000000 0000000 00000002256 12267523751 0031507 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshaller;
/**
* Created with IntelliJ IDEA. User: peter.lawrey Date: 19/09/13 Time: 18:26 To change this template use File | Settings | File
* Templates.
*/
public enum NoMarshaller implements BytesMarshaller {
INSTANCE;
@Override
public void write(Bytes bytes, Void aVoid) {
throw new UnsupportedOperationException();
}
@Override
public Void read(Bytes bytes) {
throw new UnsupportedOperationException();
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl/StringMarshaller.java 0000664 0000000 0000000 00000003237 12267523751 0032401 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.CompactBytesMarshaller;
import net.openhft.lang.pool.StringInterner;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
* @author peter.lawrey
*/
public class StringMarshaller implements CompactBytesMarshaller {
private final int size;
private final StringBuilder reader = new StringBuilder();
private StringInterner interner;
public StringMarshaller(int size) {
this.size = size;
}
@Override
public void write(@NotNull Bytes bytes, String s) {
bytes.writeUTFΔ(s);
}
@Nullable
@Override
public String read(@NotNull Bytes bytes) {
if (bytes.readUTFΔ(reader))
return builderToString();
return null;
}
private String builderToString() {
if (interner == null)
interner = new StringInterner(size);
return interner.intern(reader);
}
public byte code() {
return 'S' & 31;
}
}
VanillaBytesMarshallerFactory.java 0000664 0000000 0000000 00000007034 12267523751 0035000 0 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/io/serialization/impl /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.io.serialization.impl;
import net.openhft.lang.io.serialization.BytesMarshallable;
import net.openhft.lang.io.serialization.BytesMarshaller;
import net.openhft.lang.io.serialization.BytesMarshallerFactory;
import net.openhft.lang.io.serialization.CompactBytesMarshaller;
import org.jetbrains.annotations.NotNull;
import java.io.Externalizable;
import java.util.Date;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author peter.lawrey
*/
public class VanillaBytesMarshallerFactory implements BytesMarshallerFactory {
private final Map marshallerMap = new LinkedHashMap();
private final BytesMarshaller[] compactMarshallerMap = new BytesMarshaller[256];
// private final Map marshallerTextMap = new LinkedHashMap();
{
BytesMarshaller stringMarshaller = new StringMarshaller(16 * 1024);
addMarshaller(String.class, stringMarshaller);
addMarshaller(CharSequence.class, stringMarshaller);
addMarshaller(Class.class, new ClassMarshaller(Thread.currentThread().getContextClassLoader()));
addMarshaller(Date.class, new DateMarshaller(10191));
addMarshaller(Integer.class, new CompactEnumBytesMarshaller(Integer.class, 10191, (byte) ('I' & 31)));
addMarshaller(Long.class, new CompactEnumBytesMarshaller(Long.class, 10191, (byte) ('L' & 31)));
addMarshaller(Double.class, new CompactEnumBytesMarshaller(Double.class, 10191, (byte) ('D' & 31)));
}
@NotNull
@SuppressWarnings("unchecked")
@Override
public BytesMarshaller acquireMarshaller(@NotNull Class eClass, boolean create) {
BytesMarshaller em = marshallerMap.get(eClass);
if (em == null)
if (eClass.isEnum())
marshallerMap.put(eClass, em = new EnumBytesMarshaller(eClass, null));
else if (BytesMarshallable.class.isAssignableFrom(eClass))
marshallerMap.put(eClass, em = new BytesMarshallableMarshaller((Class) eClass));
else if (Externalizable.class.isAssignableFrom(eClass))
marshallerMap.put(eClass, em = new ExternalizableMarshaller((Class) eClass));
else {
try {
marshallerMap.put(eClass, em = new GenericEnumMarshaller(eClass, 1000));
} catch (Exception e) {
marshallerMap.put(eClass, em = NoMarshaller.INSTANCE);
}
}
return em;
}
@Override
public BytesMarshaller getMarshaller(byte code) {
return compactMarshallerMap[code & 0xFF];
}
public void addMarshaller(Class eClass, BytesMarshaller marshaller) {
marshallerMap.put(eClass, marshaller);
if (marshaller instanceof CompactBytesMarshaller)
compactMarshallerMap[((CompactBytesMarshaller) marshaller).code()] = marshaller;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/ 0000775 0000000 0000000 00000000000 12267523751 0023123 5 ustar 00root root 0000000 0000000 Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/Byteable.java 0000664 0000000 0000000 00000001551 12267523751 0025517 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import net.openhft.lang.io.Bytes;
/**
* User: peter.lawrey
* Date: 07/10/13
* Time: 21:38
*/
public interface Byteable {
void bytes(Bytes bytes);
void bytes(Bytes bytes, long offset);
Bytes bytes();
int maxSize();
} Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/ClassModel.java 0000664 0000000 0000000 00000001604 12267523751 0026015 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Set;
public interface ClassModel {
void setMethod(String name, MethodFilter filter, Method method);
Set getNames();
Map filterMapFor(String name);
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/CodeGenerator.java 0000664 0000000 0000000 00000001235 12267523751 0026510 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
public interface CodeGenerator {
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/Copyable.java 0000664 0000000 0000000 00000001510 12267523751 0025521 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
/**
* User: peter.lawrey
* Date: 08/10/13
* Time: 07:45
*/
public interface Copyable {
/**
* Copy from this type.
*
* @param from to copy from
*/
void copyFrom(T from);
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/DataValueGenerator.java 0000664 0000000 0000000 00000062404 12267523751 0027511 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import net.openhft.compiler.CachedCompiler;
import net.openhft.lang.Compare;
import net.openhft.lang.Maths;
import net.openhft.lang.io.Bytes;
import net.openhft.lang.io.serialization.BytesMarshallable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;
/**
* User: peter.lawrey
* Date: 06/10/13
* Time: 19:17
*/
public class DataValueGenerator {
public static final Comparator COMPARATOR = new Comparator() {
@Override
public int compare(Class o1, Class o2) {
return o1.getName().compareTo(o2.getName());
}
};
public static final Comparator> COMPARE_BY_HEAP_SIZE = new Comparator>() {
@Override
public int compare(Map.Entry o1, Map.Entry o2) {
// descending
int cmp = -Maths.compare(o1.getValue().heapSize(), o2.getValue().heapSize());
return cmp == 0 ? o1.getKey().compareTo(o2.getKey()) : cmp;
}
};
private static final Logger LOGGER = Logger.getLogger(DataValueGenerator.class.getName());
final CachedCompiler cc = new CachedCompiler(null, null);
private final Map heapClassMap = new ConcurrentHashMap();
private final Map nativeClassMap = new ConcurrentHashMap();
private boolean dumpCode = false;
private static String bytesType(Class type) {
if (type.isPrimitive())
return Character.toUpperCase(type.getName().charAt(0)) + type.getName().substring(1);
if (CharSequence.class.isAssignableFrom(type))
return "UTFΔ";
return "Object";
}
public T heapInstance(Class tClass) {
try {
return (T) acquireHeapClass(tClass).newInstance();
} catch (Exception e) {
throw new AssertionError(e);
}
}
public Class acquireHeapClass(Class tClass) throws ClassNotFoundException {
Class heapClass = heapClassMap.get(tClass);
if (heapClass != null)
return heapClass;
String actual = new DataValueGenerator().generateHeapObject(tClass);
if (dumpCode)
LOGGER.info(actual);
heapClass = cc.loadFromJava(tClass.getClassLoader(), tClass.getName() + "£heap", actual);
heapClassMap.put(tClass, heapClass);
return heapClass;
}
public String generateHeapObject(Class tClass) {
return generateHeapObject(DataValueModels.acquireModel(tClass));
}
public String generateHeapObject(DataValueModel dvmodel) {
SortedSet imported = new TreeSet(COMPARATOR);
imported.add(BytesMarshallable.class);
imported.add(Bytes.class);
imported.add(IOException.class);
imported.add(Copyable.class);
imported.add(dvmodel.type());
StringBuilder fieldDeclarations = new StringBuilder();
StringBuilder getterSetters = new StringBuilder();
StringBuilder writeMarshal = new StringBuilder();
StringBuilder readMarshal = new StringBuilder();
StringBuilder copy = new StringBuilder();
Map fieldMap = dvmodel.fieldMap();
Map.Entry[] entries = fieldMap.entrySet().toArray(new Map.Entry[fieldMap.size()]);
Arrays.sort(entries, COMPARE_BY_HEAP_SIZE);
for (Map.Entry entry : entries) {
String name = entry.getKey();
FieldModel model = entry.getValue();
Class type = model.type();
if (!type.isPrimitive() && !type.getPackage().getName().equals("java.lang"))
imported.add(type);
fieldDeclarations.append(" private ").append(type.getName()).append(" _").append(name).append(";\n");
final Method setter = model.setter();
final Method getter = model.getter();
if (setter == null) {
copy.append(" ((Copyable) ").append(getter.getName()).append("()).copyFrom(from.").append(getter.getName()).append("());\n");
} else {
copy.append(" ").append(setter.getName()).append("(from.").append(getter.getName()).append("());\n");
Class setterType = setter.getParameterTypes()[0];
getterSetters.append(" public void ").append(setter.getName()).append('(').append(setterType.getName()).append(" _) {\n");
if (type == String.class && setterType != String.class)
getterSetters.append(" _").append(name).append(" = _.toString();\n");
else
getterSetters.append(" _").append(name).append(" = _;\n");
getterSetters.append(" }\n\n");
}
getterSetters.append(" public ").append(type.getName()).append(' ').append(getter.getName()).append("() {\n");
getterSetters.append(" return _").append(name).append(";\n");
getterSetters.append(" }\n\n");
Method adder = model.adder();
if (adder != null) {
getterSetters.append(" public ").append(type.getName()).append(' ').append(adder.getName())
.append("(").append(adder.getParameterTypes()[0].getName()).append(" _) {\n")
.append(" return _").append(name).append(" += _;\n")
.append(" }");
}
Method atomicAdder = model.atomicAdder();
if (atomicAdder != null) {
getterSetters.append(" public synchronized ").append(type.getName()).append(' ').append(atomicAdder.getName())
.append("(").append(adder.getParameterTypes()[0].getName()).append(" _) {\n")
.append(" return _").append(name).append(" += _;\n")
.append(" }");
}
Method cas = model.cas();
if (cas != null) {
getterSetters.append(" public synchronized boolean ").append(cas.getName()).append("(")
.append(type.getName()).append(" _1, ")
.append(type.getName()).append(" _2) {\n")
.append(" if (_").append(name).append(" == _1) {\n")
.append(" _").append(name).append(" = _2;\n")
.append(" return true;\n")
.append(" }\n")
.append(" return false;\n")
.append(" }\n");
}
Method tryLockNanos = model.tryLockNanos();
if (tryLockNanos != null) {
getterSetters.append(" public boolean ").append(tryLockNanos.getName()).append("(long nanos) {\n")
.append(" throw new UnsupportedOperationException();\n")
.append(" }");
}
Method tryLock = model.tryLock();
if (tryLock != null) {
getterSetters.append(" public boolean ").append(tryLock.getName()).append("() {\n")
.append(" throw new UnsupportedOperationException();\n")
.append(" }");
}
Method unlock = model.unlock();
if (unlock != null) {
getterSetters.append(" public void ").append(unlock.getName()).append("() {\n")
.append(" throw new UnsupportedOperationException();\n")
.append(" }");
}
Method busyLock = model.busyLock();
if (busyLock != null) {
getterSetters.append(" public void ").append(busyLock.getName()).append("() {\n")
.append(" throw new UnsupportedOperationException();\n")
.append(" }");
}
writeMarshal.append(" out.write").append(bytesType(type)).append("(_").append(name).append(");\n");
readMarshal.append(" _").append(name).append(" = in.read").append(bytesType(type)).append("(");
if ("Object".equals(bytesType(type)))
readMarshal.append(type.getName()).append(".class");
readMarshal.append(");\n");
}
StringBuilder sb = new StringBuilder();
sb.append("package ").append(dvmodel.type().getPackage().getName()).append(";\n\n");
sb.append("import static ").append(Compare.class.getName()).append(".*;\n");
for (Class aClass : imported) {
sb.append("import ").append(aClass.getName()).append(";\n");
}
sb.append("\npublic class ").append(dvmodel.type().getSimpleName())
.append("£heap implements ").append(dvmodel.type().getSimpleName())
.append(", BytesMarshallable, Copyable<").append(dvmodel.type().getName()).append("> {\n");
sb.append(fieldDeclarations).append('\n');
sb.append(getterSetters);
sb.append(" @SuppressWarnings(\"unchecked\")\n" +
" public void copyFrom(").append(dvmodel.type().getName()).append(" from) {\n");
sb.append(copy);
sb.append(" }\n\n");
sb.append(" public void writeMarshallable(Bytes out) {\n");
sb.append(writeMarshal);
sb.append(" }\n");
sb.append(" public void readMarshallable(Bytes in) {\n");
sb.append(readMarshal);
sb.append(" }\n");
if (Byteable.class.isAssignableFrom(dvmodel.type())) {
sb.append(" public void bytes(Bytes bytes) {\n");
sb.append(" throw new UnsupportedOperationException();\n");
sb.append(" }\n");
sb.append(" public void bytes(Bytes bytes, long l) {\n");
sb.append(" throw new UnsupportedOperationException();\n");
sb.append(" }\n");
sb.append(" public Bytes bytes() {\n");
sb.append(" return null;\n");
sb.append(" }\n");
sb.append(" public int maxSize() {\n");
sb.append(" throw new UnsupportedOperationException();\n");
sb.append(" }\n");
}
generateObjectMethods(sb, dvmodel, entries);
sb.append("}\n");
// System.out.println(sb);
return sb.toString();
}
private static void generateObjectMethods(StringBuilder sb, DataValueModel dvmodel, Map.Entry[] entries) {
int count = 0;
StringBuilder hashCode = new StringBuilder();
StringBuilder equals = new StringBuilder();
StringBuilder toString = new StringBuilder();
for (Map.Entry entry : entries) {
String name = entry.getKey();
FieldModel model = entry.getValue();
Class type = model.type();
if (count > 0)
hashCode.append(") * 10191 +\n ");
String getterName = model.getter().getName();
hashCode.append("calcLongHashCode(").append(getterName).append("())");
equals.append(" if(!isEqual(").append(getterName).append("(), that.").append(getterName).append("())) return false;\n");
toString.append(" \", ").append(name).append("= \" + ").append(getterName).append("() +\n");
count++;
}
sb.append(" public int hashCode() {\n" +
" long lhc = longHashCode();\n" +
" return (int) ((lhc >>> 32) ^ lhc);\n" +
" }\n" +
"\n" +
" public long longHashCode() {\n" +
" return ");
for (int i = 1; i < count; i++)
sb.append('(');
sb.append(hashCode);
String simpleName = dvmodel.type().getSimpleName();
sb.append(";\n")
.append(" }\n")
.append("\n")
.append(" public boolean equals(Object o) {\n")
.append(" if (this == o) return true;\n")
.append(" if (!(o instanceof ").append(simpleName).append(")) return false;\n")
.append(" ").append(simpleName).append(" that = (").append(simpleName).append(") o;\n")
.append("\n")
.append(equals)
.append(" return true;\n" +
" }\n" +
"\n" +
" public String toString() {\n" +
" return \"").append(simpleName).append(" {\" +\n")
.append(toString.substring(0, toString.length() - 3)).append(";\n")
.append(" }");
}
public T nativeInstance(Class tClass) {
try {
return (T) acquireNativeClass(tClass).newInstance();
} catch (Exception e) {
throw new AssertionError(e);
}
}
public Class acquireNativeClass(Class tClass) throws ClassNotFoundException {
Class nativeClass = nativeClassMap.get(tClass);
if (nativeClass != null)
return nativeClass;
DataValueModel dvmodel = DataValueModels.acquireModel(tClass);
for (Class clazz : dvmodel.nestedModels()) {
Class clazz2 = acquireNativeClass(clazz);
}
String actual = new DataValueGenerator().generateNativeObject(dvmodel);
if (dumpCode)
LOGGER.info(actual);
nativeClass = cc.loadFromJava(tClass.getClassLoader(), tClass.getName() + "£native", actual);
nativeClassMap.put(tClass, nativeClass);
return nativeClass;
}
public String generateNativeObject(Class tClass) {
return generateNativeObject(DataValueModels.acquireModel(tClass));
}
public String generateNativeObject(DataValueModel dvmodel) {
SortedSet imported = new TreeSet(COMPARATOR);
imported.add(BytesMarshallable.class);
imported.add(ObjectOutput.class);
imported.add(ObjectInput.class);
imported.add(IOException.class);
imported.add(Copyable.class);
imported.add(Byteable.class);
imported.add(Bytes.class);
StringBuilder staticFieldDeclarations = new StringBuilder();
StringBuilder fieldDeclarations = new StringBuilder();
StringBuilder getterSetters = new StringBuilder();
StringBuilder writeMarshal = new StringBuilder();
StringBuilder readMarshal = new StringBuilder();
StringBuilder copy = new StringBuilder();
StringBuilder nestedBytes = new StringBuilder();
Map fieldMap = dvmodel.fieldMap();
Map.Entry[] entries = fieldMap.entrySet().toArray(new Map.Entry[fieldMap.size()]);
Arrays.sort(entries, COMPARE_BY_HEAP_SIZE);
int offset = 0;
for (Map.Entry entry : entries) {
String name = entry.getKey();
FieldModel model = entry.getValue();
Class type = model.type();
if (!type.isPrimitive() && !type.getPackage().getName().equals("java.lang"))
imported.add(type);
String NAME = "_offset + " + name.toUpperCase();
final Method setter = model.setter();
final Method getter = model.getter();
if (dvmodel.isScalar(type)) {
staticFieldDeclarations.append(" private static final int ").append(name.toUpperCase()).append(" = ").append(offset).append(";\n");
copy.append(" ").append(setter.getName()).append("(from.").append(getter.getName()).append("());\n");
Class setterType = setter.getParameterTypes()[0];
getterSetters.append(" public void ").append(setter.getName()).append('(').append(setterType.getName()).append(" _) {\n");
getterSetters.append(" _bytes.write").append(bytesType(type)).append("(").append(NAME).append(", ");
if (CharSequence.class.isAssignableFrom(type))
getterSetters.append(model.size().value()).append(", ");
getterSetters.append("_);\n");
getterSetters.append(" }\n\n");
getterSetters.append(" public ").append(type.getName()).append(' ').append(getter.getName()).append("() {\n");
getterSetters.append(" return _bytes.read").append(bytesType(type)).append("(").append(NAME).append(");\n");
getterSetters.append(" }\n\n");
Method adder = model.adder();
if (adder != null) {
getterSetters.append(" public ").append(type.getName()).append(' ').append(adder.getName())
.append("(").append(adder.getParameterTypes()[0].getName()).append(" _) {\n")
.append(" return _bytes.add").append(bytesType(type)).append("(").append(NAME).append(", _);\n")
.append(" }");
}
Method atomicAdder = model.atomicAdder();
if (atomicAdder != null) {
getterSetters.append(" public ").append(type.getName()).append(' ').append(atomicAdder.getName())
.append("(").append(adder.getParameterTypes()[0].getName()).append(" _) {\n")
.append(" return _bytes.addAtomic").append(bytesType(type)).append("(").append(NAME).append(", _);\n")
.append(" }");
}
Method cas = model.cas();
if (cas != null) {
getterSetters.append(" public boolean ").append(cas.getName()).append("(")
.append(type.getName()).append(" _1, ")
.append(type.getName()).append(" _2) {\n")
.append(" return _bytes.compareAndSwap").append(bytesType(type)).append('(').append(NAME).append(", _1, _2);\n")
.append(" }");
}
Method tryLockNanos = model.tryLockNanos();
if (tryLockNanos != null) {
getterSetters.append(" public boolean ").append(tryLockNanos.getName()).append("(long nanos) {\n")
.append(" return _bytes.tryLockNanos").append(bytesType(type)).append('(').append(NAME).append(", nanos);\n")
.append(" }");
}
Method tryLock = model.tryLock();
if (tryLock != null) {
getterSetters.append(" public boolean ").append(tryLock.getName()).append("() {\n")
.append(" return _bytes.tryLock").append(bytesType(type)).append('(').append(NAME).append(");\n")
.append(" }");
}
Method unlock = model.unlock();
if (unlock != null) {
getterSetters.append(" public void ").append(unlock.getName()).append("() {\n")
.append(" _bytes.unlock").append(bytesType(type)).append('(').append(NAME).append(");\n")
.append(" }");
}
Method busyLock = model.busyLock();
if (busyLock != null) {
getterSetters.append(" public void ").append(busyLock.getName()).append("() throws InterruptedException {\n")
.append(" _bytes.busyLock").append(bytesType(type)).append('(').append(NAME).append(");\n")
.append(" }");
}
writeMarshal.append(" out.write").append(bytesType(type)).append("(")
.append(getter.getName()).append("());\n");
readMarshal.append(" ").append(setter.getName()).append("(in.read").append(bytesType(type)).append("());\n");
offset += (model.nativeSize() + 7) >> 3;
} else {
staticFieldDeclarations.append(" private static final int ").append(name.toUpperCase()).append(" = ").append(offset).append(";\n");
fieldDeclarations.append(" private final ").append(type.getName()).append("£native _").append(name).append(" = new ").append(type.getName()).append("£native();\n");
if (setter == null) {
copy.append(" _").append(name).append(".copyFrom(from.").append(getter.getName()).append("());\n");
} else {
copy.append(" ").append(setter.getName()).append("(from.").append(getter.getName()).append("());\n");
Class setterType = setter.getParameterTypes()[0];
getterSetters.append(" public void ").append(setter.getName()).append('(').append(setterType.getName()).append(" _) {\n");
if (type == String.class && setterType != String.class)
getterSetters.append(" _").append(name).append(" = _.toString();\n");
else
getterSetters.append(" _").append(name).append(".copyFrom(_);\n");
getterSetters.append(" }\n\n");
}
getterSetters.append(" public ").append(type.getName()).append(' ').append(getter.getName()).append("() {\n");
getterSetters.append(" return _").append(name).append(";\n");
getterSetters.append(" }\n\n");
writeMarshal.append(" _").append(name).append(".writeMarshallable(out);\n");
readMarshal.append(" _").append(name).append(".readMarshallable(in);\n");
nestedBytes.append(" ((Byteable) _").append(name).append(").bytes(bytes, ").append(NAME).append(");\n");
DataValueModel dvmodel2 = dvmodel.nestedModel(type);
Map fieldMap2 = dvmodel2.fieldMap();
Map.Entry[] entries2 = fieldMap2.entrySet().toArray(new Map.Entry[fieldMap2.size()]);
Arrays.sort(entries2, COMPARE_BY_HEAP_SIZE);
for (Map.Entry entry2 : entries2) {
FieldModel model2 = entry2.getValue();
offset += (model2.nativeSize() + 7) >> 3;
}
}
}
fieldDeclarations.append("\n")
.append(" private Bytes _bytes;\n")
.append(" private long _offset;\n");
StringBuilder sb = new StringBuilder();
sb.append("package ").append(dvmodel.type().getPackage().getName()).append(";\n\n");
sb.append("import static ").append(Compare.class.getName()).append(".*;\n");
for (Class aClass : imported) {
sb.append("import ").append(aClass.getName()).append(";\n");
}
sb.append("\npublic class ").append(dvmodel.type().getSimpleName())
.append("£native implements ").append(dvmodel.type().getSimpleName())
.append(", BytesMarshallable, Byteable, Copyable<").append(dvmodel.type().getName()).append("> {\n");
sb.append(staticFieldDeclarations).append('\n');
sb.append(fieldDeclarations).append('\n');
sb.append(getterSetters);
sb.append(" public void copyFrom(").append(dvmodel.type().getName()).append(" from) {\n");
sb.append(copy);
sb.append(" }\n\n");
sb.append(" public void writeMarshallable(Bytes out) {\n");
sb.append(writeMarshal);
sb.append(" }\n");
sb.append(" public void readMarshallable(Bytes in) {\n");
sb.append(readMarshal);
sb.append(" }\n");
sb.append(" public void bytes(Bytes bytes) {\n");
sb.append(" bytes(bytes, 0L);\n");
sb.append(" }\n");
sb.append(" public void bytes(Bytes bytes, long offset) {\n");
sb.append(" this._bytes = bytes;\n");
sb.append(" this._offset = offset;\n");
sb.append(nestedBytes);
sb.append(" }\n");
sb.append(" public Bytes bytes() {\n");
sb.append(" return _bytes;\n");
sb.append(" }\n");
sb.append(" public int maxSize() {\n");
sb.append(" return ").append(offset).append(";\n");
sb.append(" }\n");
generateObjectMethods(sb, dvmodel, entries);
sb.append("}\n");
// System.out.println(sb);
return sb.toString();
}
public boolean isDumpCode() {
return dumpCode;
}
public void setDumpCode(boolean dumpCode) {
this.dumpCode = dumpCode;
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/DataValueMetaModel.java 0000664 0000000 0000000 00000003472 12267523751 0027432 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import net.openhft.lang.io.serialization.BytesMarshallable;
import java.io.Externalizable;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class DataValueMetaModel {
private final Set ignoredClasses = new HashSet();
private final List filters = new ArrayList();
public DataValueMetaModel() {
addIgnoredClass(Object.class);
addIgnoredClass(Externalizable.class);
addIgnoredClass(Copyable.class);
addIgnoredClass(Byteable.class);
addIgnoredClass(BytesMarshallable.class);
for (VanillaFilter vanillaFilter : VanillaFilter.values()) {
addMethodFilter(vanillaFilter);
}
}
public void addIgnoredClass(Class aClass) {
ignoredClasses.add(aClass);
}
public void addMethodFilter(MethodFilter filter) {
int pos = insertionPoint(filter);
filters.add(pos, filter);
}
private int insertionPoint(MethodFilter filter) {
for (int i = 0; i < filters.size(); i++)
if (filters.get(i).matches() < filter.matches())
return i;
return filters.size();
}
}
Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/DataValueModel.java 0000664 0000000 0000000 00000001725 12267523751 0026622 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import java.util.Map;
import java.util.Set;
/**
* User: peter.lawrey
* Date: 06/10/13
* Time: 17:06
*/
public interface DataValueModel {
Map fieldMap();
boolean isScalar(Class nClass);
Set nestedModels();
DataValueModel nestedModel(Class nClass);
Class type();
} Java-Lang-6.1.4/lang/src/main/java/net/openhft/lang/model/DataValueModelImpl.java 0000664 0000000 0000000 00000037526 12267523751 0027454 0 ustar 00root root 0000000 0000000 /*
* Copyright 2013 Peter Lawrey
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package net.openhft.lang.model;
import net.openhft.lang.io.serialization.BytesMarshallable;
import net.openhft.lang.model.constraints.Digits;
import net.openhft.lang.model.constraints.MaxSize;
import net.openhft.lang.model.constraints.Range;
import java.io.Externalizable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
/**
* User: peter.lawrey
* Date: 06/10/13
* Time: 17:23
*/
public class DataValueModelImpl implements DataValueModel {
static final Map HEAP_SIZE_MAP = new HashMap();
static {
HEAP_SIZE_MAP.put(boolean.class, 1);
HEAP_SIZE_MAP.put(byte.class, 8);
HEAP_SIZE_MAP.put(char.class, 16);
HEAP_SIZE_MAP.put(short.class, 16);
HEAP_SIZE_MAP.put(int.class, 32);
HEAP_SIZE_MAP.put(float.class, 32);
HEAP_SIZE_MAP.put(long.class, 64);
HEAP_SIZE_MAP.put(double.class, 64);
}
private final Map fieldModelMap = new TreeMap();
private final Class type;
private final Map nestedMap = new HashMap();
public DataValueModelImpl(Class type) {
this.type = type;
if (!type.isInterface())
throw new IllegalArgumentException("type must be an interface, was " + type);
Method[] methods = type.getMethods();
for (Method method : methods) {
Class declaringClass = method.getDeclaringClass();
if (declaringClass == Object.class
|| declaringClass == Externalizable.class
|| declaringClass == BytesMarshallable.class
|| declaringClass == Copyable.class
|| declaringClass == Byteable.class)
continue;
String name = method.getName();
Class[] parameterTypes = method.getParameterTypes();
final Class returnType = method.getReturnType();
switch (parameterTypes.length) {
case 0: {
String name5 = getUnlock(name);
if (name5 != null && returnType == void.class) {
FieldModelImpl fm = acquireField(name5);
fm.unlock(method);
break;
}
String name4 = getBusyLock(name);
if (name4 != null && returnType == void.class) {
FieldModelImpl fm = acquireField(name4);
fm.busyLock(method);
break;
}
String name3 = getTryLock(name);
if (name3 != null && returnType == boolean.class) {
FieldModelImpl fm = acquireField(name3);
fm.tryLock(method);
break;
}
if (returnType == void.class)
throw new IllegalArgumentException("void () not supported " + method);
String name2 = getGetter(name, returnType);
FieldModelImpl fm = acquireField(name2);
fm.getter(method);
break;
}
case 1: {
String name5 = getTryLockNanos(name);
if (name5 != null && returnType == boolean.class) {
FieldModelImpl fm = acquireField(name5);
fm.tryLockNanos(method);
break;
}
String name4 = getAtomicAdder(name);
if (name4 != null) {
FieldModelImpl fm = acquireField(name4);
fm.atomicAdder(method);
break;
}
String name3 = getAdder(name);
if (name3 != null) {
FieldModelImpl fm = acquireField(name3);
fm.adder(method);
break;
}
String name6 = getGetter(name, returnType);
if (name6 != null && parameterTypes[0] == int.class && returnType != void.class) {
FieldModelImpl fm = acquireField(name6);
fm.indexedGetter(method);
break;
}
if (returnType != void.class)
throw new IllegalArgumentException("setter must be void " + method);
String name2 = getSetter(name);
FieldModelImpl fm = acquireField(name2);
fm.setter(method);
break;
}
case 2: {
String name2 = getCAS(name);
if (name2 != null && returnType == boolean.class) {
FieldModelImpl fm = acquireField(name2);
fm.cas(method);
break;
}
String name3 = getSetter(name);
if (name3 != null && parameterTypes[0] == int.class && returnType == void.class) {
FieldModelImpl fm = acquireField(name3);
fm.indexedSetter(method);
break;
}
}
default: {
throw new IllegalArgumentException("method not supported " + method);
}
}
}
for (Map.Entry entry : fieldModelMap.entrySet()) {
FieldModelImpl model = entry.getValue();
if (model.getter() == null || (model.setter() == null && model.getter().getReturnType().isPrimitive()))
if (model.indexedGetter() == null || (model.indexedSetter() == null && model.indexedGetter().getReturnType().isPrimitive()))
throw new IllegalArgumentException("Field " + entry.getKey() + " must have a getter and setter.");
Class ftype = model.type();
if (!isScalar(ftype) && !nestedMap.containsKey(ftype))
nestedMap.put(ftype, new DataValueModelImpl(ftype));
}
}
private static String getCAS(String name) {
final int len = 14;
if (name.length() > len && name.startsWith("compareAndSwap") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private static String getAtomicAdder(String name) {
final int len = 9;
if (name.length() > len && name.startsWith("addAtomic") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private static String getAdder(String name) {
final int len = 3;
if (name.length() > len && name.startsWith("add") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private static String getSetter(String name) {
final int len = 3;
if (name.length() > len && name.startsWith("set") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return name;
}
private static String getGetter(String name, Class returnType) {
if (name.length() > 3 && name.startsWith("get") && Character.isUpperCase(name.charAt(3)))
return Character.toLowerCase(name.charAt(3)) + name.substring(4);
if ((returnType == boolean.class || returnType == Boolean.class)
&& name.length() > 2 && name.startsWith("is") && Character.isUpperCase(name.charAt(2)))
return Character.toLowerCase(name.charAt(2)) + name.substring(3);
return name;
}
private String getBusyLock(String name) {
final int len = 8;
if (name.length() > len && name.startsWith("busyLock") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private String getUnlock(String name) {
final int len = 6;
if (name.length() > len && name.startsWith("unlock") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private String getTryLockNanos(String name) {
final int len = 12;
if (name.length() > len && name.startsWith("tryLockNanos") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private String getTryLock(String name) {
final int len = 7;
if (name.length() > len && name.startsWith("tryLock") && Character.isUpperCase(name.charAt(len)))
return Character.toLowerCase(name.charAt(len)) + name.substring(len + 1);
return null;
}
private FieldModelImpl acquireField(String name) {
FieldModelImpl fieldModelImpl = fieldModelMap.get(name);
if (fieldModelImpl == null)
fieldModelMap.put(name, fieldModelImpl = new FieldModelImpl(name));
return fieldModelImpl;
}
@Override
public Map fieldMap() {
return fieldModelMap;
}
public boolean isScalar(Class type) {
return type.isPrimitive() || CharSequence.class.isAssignableFrom(type);
}
@Override
public Set nestedModels() {
return nestedMap.keySet();
}
@Override
public DataValueModel nestedModel(Class nClass) {
@SuppressWarnings("unchecked")
DataValueModel model = (DataValueModel