Struct.java

Go to the documentation of this file.

/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.io;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
 
import javolution.context.LocalContext;
import javolution.lang.MathLib;
import javolution.lang.Realtime;
import javolution.text.TextBuilder;
 
@SuppressWarnings("unchecked")
@Realtime
public class Struct {
 
    public static final LocalContext.Parameter<Integer> MAXIMUM_ALIGNMENT = new LocalContext.Parameter<Integer>() {
        @Override
        protected Integer getDefault() {
            return 4;
        }
    };
 
    Struct _outer;
    ByteBuffer _byteBuffer;
    int _outerOffset;
    int _alignment = 1;
    int _length;
    int _index;
    int _wordSize;
    int _bitsUsed;
    boolean _resetIndex;
    byte[] _bytes;
 
    public Struct() {
        _resetIndex = isUnion();
    }
 
    public final int size() {
        return (_alignment <= 1) ? _length
                : ((_length + _alignment - 1) / _alignment) * _alignment;
    }
 
    public Struct outer() {
        return _outer;
    }
 
    public final ByteBuffer getByteBuffer() {
        if (_outer != null) return _outer.getByteBuffer();
        return (_byteBuffer != null) ? _byteBuffer : newBuffer();
    }
 
    private synchronized ByteBuffer newBuffer() {
        if (_byteBuffer != null) return _byteBuffer; // Synchronized check.
        ByteBuffer bf = ByteBuffer.allocateDirect(size());
        bf.order(byteOrder());
        setByteBuffer(bf, 0);
        return _byteBuffer;
    }
 
    public final Struct setByteBuffer(ByteBuffer byteBuffer, int position) {
        if (byteBuffer.order() != byteOrder()) throw new IllegalArgumentException(
                "The byte order of the specified byte buffer"
                        + " is different from this struct byte order");
        if (_outer != null) throw new UnsupportedOperationException(
                "Inner struct byte buffer is inherited from outer");
        _byteBuffer = byteBuffer;
        _outerOffset = position;
        return this;
    }
 
    public final Struct setByteBufferPosition(int position) {
        return setByteBuffer(this.getByteBuffer(), position);
    }
 
    public final int getByteBufferPosition() {
        return (_outer != null) ? _outer.getByteBufferPosition() + _outerOffset
                : _outerOffset;
    }
 
    public int read(InputStream in) throws IOException {
        ByteBuffer buffer = getByteBuffer();
        int size = size();
        int remaining = size - buffer.position();
        if (remaining == 0) remaining = size;// at end so move to beginning
        int alreadyRead = size - remaining; // typically 0
        if (buffer.hasArray()) {
            int offset = buffer.arrayOffset() + getByteBufferPosition();
            int bytesRead = in
                    .read(buffer.array(), offset + alreadyRead, remaining);
            buffer.position(getByteBufferPosition() + alreadyRead + bytesRead
                    - offset);
            return bytesRead;
        } else {
            synchronized (buffer) {
                if (_bytes == null) {
                    _bytes = new byte[size()];
                }
                int bytesRead = in.read(_bytes, 0, remaining);
                buffer.position(getByteBufferPosition() + alreadyRead);
                buffer.put(_bytes, 0, bytesRead);
                return bytesRead;
            }
        }
    }
 
    public void write(OutputStream out) throws IOException {
        ByteBuffer buffer = getByteBuffer();
        if (buffer.hasArray()) {
            int offset = buffer.arrayOffset() + getByteBufferPosition();
            out.write(buffer.array(), offset, size());
        } else {
            synchronized (buffer) {
                if (_bytes == null) {
                    _bytes = new byte[size()];
                }
                buffer.position(getByteBufferPosition());
                buffer.get(_bytes);
                out.write(_bytes);
            }
        }
    }
 
    public final long address() {
        ByteBuffer thisBuffer = this.getByteBuffer();
        if (thisBuffer instanceof sun.nio.ch.DirectBuffer) 
          return ((sun.nio.ch.DirectBuffer)thisBuffer).address();
        throw new UnsupportedOperationException();
    }
 
    public String toString() {
        TextBuilder tmp = new TextBuilder();
        final int size = size();
        final ByteBuffer buffer = getByteBuffer();
        final int start = getByteBufferPosition();
        for (int i = 0; i < size; i++) {
            int b = buffer.get(start + i) & 0xFF;
            tmp.append(HEXA[b >> 4]);
            tmp.append(HEXA[b & 0xF]);
            tmp.append(((i & 0xF) == 0xF) ? '\n' : ' ');
        }
        return tmp.toString();
    }
 
    private static final char[] HEXA = { '0', '1', '2', '3', '4', '5', '6',
            '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
    // CONFIGURATION //
 
    public boolean isUnion() {
        return false;
    }
 
    public ByteOrder byteOrder() {
        return (_outer != null) ? _outer.byteOrder() : ByteOrder.BIG_ENDIAN;
    }
 
    public boolean isPacked() {
        return false;
    }
 
    protected <S extends Struct> S inner(S struct) {
        if (struct._outer != null) throw new IllegalArgumentException(
                "struct: Already an inner struct");
        Member inner = new Member(struct.size() << 3, struct._alignment); // Update indexes.
        struct._outer = this;
        struct._outerOffset = inner.offset();
        return (S) struct;
    }
 
    protected <S extends Struct> S[] array(S[] structs) {
        Class<?> structClass = null;
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < structs.length;) {
            S struct = structs[i];
            if (struct == null) {
                try {
                    if (structClass == null) {
                        String arrayName = structs.getClass().getName();
                        String structName = arrayName.substring(2,
                                arrayName.length() - 1);
                        structClass = Class.forName(structName);
                        if (structClass == null) { throw new IllegalArgumentException(
                                "Struct class: " + structName + " not found"); }
                    }
                    struct = (S) structClass.newInstance();
                } catch (Exception e) {
                    throw new RuntimeException(e.getMessage());
                }
            }
            structs[i++] = inner(struct);
        }
        _resetIndex = resetIndexSaved;
        return (S[]) structs;
    }
 
    protected <S extends Struct> S[][] array(S[][] structs) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < structs.length; i++) {
            array(structs[i]);
        }
        _resetIndex = resetIndexSaved;
        return (S[][]) structs;
    }
 
    protected <S extends Struct> S[][][] array(S[][][] structs) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < structs.length; i++) {
            array(structs[i]);
        }
        _resetIndex = resetIndexSaved;
        return (S[][][]) structs;
    }
 
    protected <M extends Member> M[] array(M[] arrayMember) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        if (BOOL.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Bool();
            }
        } else if (SIGNED_8.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Signed8();
            }
        } else if (UNSIGNED_8.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Unsigned8();
            }
        } else if (SIGNED_16.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Signed16();
            }
        } else if (UNSIGNED_16.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Unsigned16();
            }
        } else if (SIGNED_32.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Signed32();
            }
        } else if (UNSIGNED_32.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Unsigned32();
            }
        } else if (SIGNED_64.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Signed64();
            }
        } else if (FLOAT_32.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Float32();
            }
        } else if (FLOAT_64.isInstance(arrayMember)) {
            for (int i = 0; i < arrayMember.length;) {
                arrayMember[i++] = (M) this.new Float64();
            }
        } else {
            throw new UnsupportedOperationException(
                    "Cannot create member elements, the arrayMember should "
                            + "contain the member instances instead of null");
        }
        _resetIndex = resetIndexSaved;
        return (M[]) arrayMember;
    }
 
    private static final Class<? extends Bool[]> BOOL = new Bool[0].getClass();
    private static final Class<? extends Signed8[]> SIGNED_8 = new Signed8[0]
            .getClass();
    private static final Class<? extends Unsigned8[]> UNSIGNED_8 = new Unsigned8[0]
            .getClass();
    private static final Class<? extends Signed16[]> SIGNED_16 = new Signed16[0]
            .getClass();
    private static final Class<? extends Unsigned16[]> UNSIGNED_16 = new Unsigned16[0]
            .getClass();
    private static final Class<? extends Signed32[]> SIGNED_32 = new Signed32[0]
            .getClass();
    private static final Class<? extends Unsigned32[]> UNSIGNED_32 = new Unsigned32[0]
            .getClass();
    private static final Class<? extends Signed64[]> SIGNED_64 = new Signed64[0]
            .getClass();
    private static final Class<? extends Float32[]> FLOAT_32 = new Float32[0]
            .getClass();
    private static final Class<? extends Float64[]> FLOAT_64 = new Float64[0]
            .getClass();
 
    protected <M extends Member> M[][] array(M[][] arrayMember) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < arrayMember.length; i++) {
            array(arrayMember[i]);
        }
        _resetIndex = resetIndexSaved;
        return (M[][]) arrayMember;
    }
 
    protected <M extends Member> M[][][] array(M[][][] arrayMember) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < arrayMember.length; i++) {
            array(arrayMember[i]);
        }
        _resetIndex = resetIndexSaved;
        return (M[][][]) arrayMember;
    }
 
    protected UTF8String[] array(UTF8String[] array, int stringLength) {
        boolean resetIndexSaved = _resetIndex;
        if (_resetIndex) {
            _index = 0;
            _resetIndex = false; // Ensures the array elements are sequential.
        }
        for (int i = 0; i < array.length; i++) {
            array[i] = new UTF8String(stringLength);
        }
        _resetIndex = resetIndexSaved;
        return array;
    }
 
    public long readBits(int bitOffset, int bitSize) {
        if ((bitOffset + bitSize - 1) >> 3 >= this.size()) throw new IllegalArgumentException(
                "Attempt to read outside the Struct");
        int offset = bitOffset >> 3;
        int bitStart = bitOffset - (offset << 3);
        bitStart = (byteOrder() == ByteOrder.BIG_ENDIAN) ? bitStart : 64
                - bitSize - bitStart;
        int index = getByteBufferPosition() + offset;
        long value = readByteBufferLong(index);
        value <<= bitStart; // Clears preceding bits.
        value >>= (64 - bitSize); // Signed shift.
        return value;
    }
 
    private long readByteBufferLong(int index) {
        ByteBuffer byteBuffer = getByteBuffer();
        if (index + 8 < byteBuffer.limit()) return byteBuffer.getLong(index);
        // Else possible buffer overflow.
        if (byteBuffer.order() == ByteOrder.LITTLE_ENDIAN) {
            return (readByte(index, byteBuffer) & 0xff)
                    + ((readByte(++index, byteBuffer) & 0xff) << 8)
                    + ((readByte(++index, byteBuffer) & 0xff) << 16)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 24)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 32)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 40)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 48)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 56);
        } else {
            return (((long) readByte(index, byteBuffer)) << 56)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 48)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 40)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 32)
                    + ((readByte(++index, byteBuffer) & 0xffL) << 24)
                    + ((readByte(++index, byteBuffer) & 0xff) << 16)
                    + ((readByte(++index, byteBuffer) & 0xff) << 8)
                    + (readByte(++index, byteBuffer) & 0xffL);
        }
    }
 
    private static byte readByte(int index, ByteBuffer byteBuffer) {
        return (index < byteBuffer.limit()) ? byteBuffer.get(index) : 0;
    }
 
    public void writeBits(long value, int bitOffset, int bitSize) {
        if ((bitOffset + bitSize - 1) >> 3 >= this.size()) throw new IllegalArgumentException(
                "Attempt to write outside the Struct");
        int offset = bitOffset >> 3;
        int bitStart = (byteOrder() == ByteOrder.BIG_ENDIAN) ? bitOffset
                - (offset << 3) : 64 - bitSize - (bitOffset - (offset << 3));
        long mask = -1L;
        mask <<= bitStart; // Clears preceding bits
        mask >>>= (64 - bitSize); // Unsigned shift.
        mask <<= 64 - bitSize - bitStart;
        value <<= (64 - bitSize - bitStart);
        value &= mask; // Protects against out of range values.
        int index = getByteBufferPosition() + offset;
        long oldValue = readByteBufferLong(index);
        long resetValue = oldValue & (~mask);
        long newValue = resetValue | value;
        writeByteBufferLong(index, newValue);
    }
 
    private void writeByteBufferLong(int index, long value) {
        ByteBuffer byteBuffer = getByteBuffer();
        if (index + 8 < byteBuffer.limit()) {
            byteBuffer.putLong(index, value);
            return;
        }
        // Else possible buffer overflow.
        if (byteBuffer.order() == ByteOrder.LITTLE_ENDIAN) {
            writeByte(index, byteBuffer, (byte) value);
            writeByte(++index, byteBuffer, (byte) (value >> 8));
            writeByte(++index, byteBuffer, (byte) (value >> 16));
            writeByte(++index, byteBuffer, (byte) (value >> 24));
            writeByte(++index, byteBuffer, (byte) (value >> 32));
            writeByte(++index, byteBuffer, (byte) (value >> 40));
            writeByte(++index, byteBuffer, (byte) (value >> 48));
            writeByte(++index, byteBuffer, (byte) (value >> 56));
        } else {
            writeByte(index, byteBuffer, (byte) (value >> 56));
            writeByte(++index, byteBuffer, (byte) (value >> 48));
            writeByte(++index, byteBuffer, (byte) (value >> 40));
            writeByte(++index, byteBuffer, (byte) (value >> 32));
            writeByte(++index, byteBuffer, (byte) (value >> 24));
            writeByte(++index, byteBuffer, (byte) (value >> 16));
            writeByte(++index, byteBuffer, (byte) (value >> 8));
            writeByte(++index, byteBuffer, (byte) value);
        }
    }
 
    private static void writeByte(int index, ByteBuffer byteBuffer, byte value) {
        if (index < byteBuffer.limit()) {
            byteBuffer.put(index, value);
        }
    }
 
    // MEMBERS //
 
    protected class Member {
 
        private final int _offset;
        private final int _bitIndex;
        private final int _bitLength;
 
        protected Member(int bitLength, int wordSize) {
            _bitLength = bitLength;
 
            // Resets index if union.
            if (_resetIndex) {
                _index = 0;
            }
 
            // Check if we can merge bitfields (always true if no word boundary).
            if ((wordSize == 0)
                    || ((bitLength != 0) && (wordSize == _wordSize) && ((_bitsUsed + bitLength) <= (wordSize << 3)))) {
 
                _offset = _index - _wordSize;
                _bitIndex = _bitsUsed;
                _bitsUsed += bitLength;
 
                // Straddling word boundary only possible if (wordSize == 0)
                while (_bitsUsed > (_wordSize << 3)) {
                    _index++;
                    _wordSize++;
                    _length = MathLib.max(_length, _index);
                }
                return; // Bit field merge done.
            }
 
            // Check alignment.
            if (!isPacked()) {
 
                // Updates struct's alignment constraint, based on largest word size.
                if ((_alignment < wordSize)) {
                    _alignment = wordSize;
                }
 
                // Adds padding if misaligned.
                int misaligned = _index % wordSize;
                if (misaligned != 0) {
                    _index += wordSize - misaligned;
                }
            }
 
            // Sets member indices.
            _offset = _index;
            _bitIndex = 0;
 
            // Update struct indices.
            _index += MathLib.max(wordSize, (bitLength + 7) >> 3);
            _wordSize = wordSize;
            _bitsUsed = bitLength;
            _length = MathLib.max(_length, _index);
            // size and index may differ because of {@link Union}
        }
 
        public final Struct struct() {
            return Struct.this;
        }
 
        public final int offset() {
            return _offset;
        }
 
        public final int bitIndex() {
            return _bitIndex;
        }
 
        public final int bitLength() {
            return _bitLength;
        }
 
        // Returns the member int value.
        final int get(int wordSize, int word) {
            final int shift = (byteOrder() == ByteOrder.BIG_ENDIAN) ? (wordSize << 3)
                    - bitIndex() - bitLength()
                    : bitIndex();
            word >>= shift;
            int mask = 0xFFFFFFFF >>> (32 - bitLength());
            return word & mask;
        }
 
        // Sets the member int value.
        final int set(int value, int wordSize, int word) {
            final int shift = (byteOrder() == ByteOrder.BIG_ENDIAN) ? (wordSize << 3)
                    - bitIndex() - bitLength()
                    : bitIndex();
            int mask = 0xFFFFFFFF >>> (32 - bitLength());
            mask <<= shift;
            value <<= shift;
            return (word & ~mask) | (value & mask);
        }
 
        // Returns the member long value.
        final long get(int wordSize, long word) {
            final int shift = (byteOrder() == ByteOrder.BIG_ENDIAN) ? (wordSize << 3)
                    - bitIndex() - bitLength()
                    : bitIndex();
            word >>= shift;
            long mask = 0xFFFFFFFFFFFFFFFFL >>> (64 - bitLength());
            return word & mask;
        }
 
        // Sets the member long value.
        final long set(long value, int wordSize, long word) {
            final int shift = (byteOrder() == ByteOrder.BIG_ENDIAN) ? (wordSize << 3)
                    - bitIndex() - bitLength()
                    : bitIndex();
            long mask = 0xFFFFFFFFFFFFFFFFL >>> (64 - bitLength());
            mask <<= shift;
            value <<= shift;
            return (word & ~mask) | (value & mask);
        }
    }
 
    // PREDEFINED FIELDS //
 
    public class UTF8String extends Member {
 
        private final UTF8ByteBufferWriter _writer = new UTF8ByteBufferWriter();
        private final UTF8ByteBufferReader _reader = new UTF8ByteBufferReader();
        private final int _length;
 
        public UTF8String(int length) {
            super(length << 3, 1);
            _length = length; // Takes into account 0 terminator.
        }
 
        public void set(String string) {
            final ByteBuffer buffer = getByteBuffer();
            synchronized (buffer) {
                try {
                    int index = getByteBufferPosition() + offset();
                    buffer.position(index);
                    _writer.setOutput(buffer);
                    if (string.length() < _length) {
                        _writer.write(string);
                        _writer.write(0); // Marks end of string.
                    } else if (string.length() > _length) { // Truncates.
                        _writer.write(string.substring(0, _length));
                    } else { // Exact same length.
                        _writer.write(string);
                    }
                } catch (IOException e) { // Should never happen.
                    throw new Error(e.getMessage());
                } finally {
                    _writer.reset();
                }
            }
        }
 
        public String get() {
            final ByteBuffer buffer = getByteBuffer();
            synchronized (buffer) {
                TextBuilder tmp = new TextBuilder();
                try {
                    int index = getByteBufferPosition() + offset();
                    buffer.position(index);
                    _reader.setInput(buffer);
                    for (int i = 0; i < _length; i++) {
                        char c = (char) _reader.read();
                        if (c == 0) { // Null terminator.
                            return tmp.toString();
                        } else {
                            tmp.append(c);
                        }
                    }
                    return tmp.toString();
                } catch (IOException e) { // Should never happen.
                    throw new Error(e.getMessage());
                } finally {
                    _reader.reset();
                }
            }
        }
 
        public String toString() {
            return this.get();
        }
    }
 
    public class Bool extends Member {
 
        public Bool() {
            super(8, 1);
        }
 
        public Bool(int nbrOfBits) {
            super(nbrOfBits, 1);
        }
 
        public boolean get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().get(index);
            word = (bitLength() == 8) ? word : get(1, word);
            return word != 0;
        }
 
        public void set(boolean value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 8) {
                getByteBuffer().put(index, (byte) (value ? -1 : 0));
            } else {
                getByteBuffer().put(
                        index,
                        (byte) set(value ? -1 : 0, 1, getByteBuffer()
                                .get(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Signed8 extends Member {
 
        public Signed8() {
            super(8, 1);
        }
 
        public Signed8(int nbrOfBits) {
            super(nbrOfBits, 1);
        }
 
        public byte get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().get(index);
            return (byte) ((bitLength() == 8) ? word : get(1, word));
        }
 
        public void set(byte value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 8) {
                getByteBuffer().put(index, value);
            } else {
                getByteBuffer().put(index,
                        (byte) set(value, 1, getByteBuffer().get(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Unsigned8 extends Member {
 
        public Unsigned8() {
            super(8, 1);
        }
 
        public Unsigned8(int nbrOfBits) {
            super(nbrOfBits, 1);
        }
 
        public short get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().get(index);
            return (short) (0xFF & ((bitLength() == 8) ? word : get(1, word)));
        }
 
        public void set(short value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 8) {
                getByteBuffer().put(index, (byte) value);
            } else {
                getByteBuffer().put(index,
                        (byte) set(value, 1, getByteBuffer().get(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Signed16 extends Member {
 
        public Signed16() {
            super(16, 2);
        }
 
        public Signed16(int nbrOfBits) {
            super(nbrOfBits, 2);
        }
 
        public short get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getShort(index);
            return (short) ((bitLength() == 16) ? word : get(2, word));
        }
 
        public void set(short value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 16) {
                getByteBuffer().putShort(index, value);
            } else {
                getByteBuffer().putShort(index,
                        (short) set(value, 2, getByteBuffer().getShort(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Unsigned16 extends Member {
 
        public Unsigned16() {
            super(16, 2);
        }
 
        public Unsigned16(int nbrOfBits) {
            super(nbrOfBits, 2);
        }
 
        public int get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getShort(index);
            return 0xFFFF & ((bitLength() == 16) ? word : get(2, word));
        }
 
        public void set(int value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 16) {
                getByteBuffer().putShort(index, (short) value);
            } else {
                getByteBuffer().putShort(index,
                        (short) set(value, 2, getByteBuffer().getShort(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Signed32 extends Member {
 
        public Signed32() {
            super(32, 4);
        }
 
        public Signed32(int nbrOfBits) {
            super(nbrOfBits, 4);
        }
 
        public int get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getInt(index);
            return (bitLength() == 32) ? word : get(4, word);
        }
 
        public void set(int value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 32) {
                getByteBuffer().putInt(index, value);
            } else {
                getByteBuffer().putInt(index,
                        set(value, 4, getByteBuffer().getInt(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Unsigned32 extends Member {
 
        public Unsigned32() {
            super(32, 4);
        }
 
        public Unsigned32(int nbrOfBits) {
            super(nbrOfBits, 4);
        }
 
        public long get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getInt(index);
            return 0xFFFFFFFFL & ((bitLength() == 32) ? word : get(4, word));
        }
 
        public void set(long value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 32) {
                getByteBuffer().putInt(index, (int) value);
            } else {
                getByteBuffer().putInt(index,
                        set((int) value, 4, getByteBuffer().getInt(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Signed64 extends Member {
 
        public Signed64() {
            super(64, 8);
        }
 
        public Signed64(int nbrOfBits) {
            super(nbrOfBits, 8);
        }
 
        public long get() {
            final int index = getByteBufferPosition() + offset();
            long word = getByteBuffer().getLong(index);
            return (bitLength() == 64) ? word : get(8, word);
        }
 
        public void set(long value) {
            final int index = getByteBufferPosition() + offset();
            if (bitLength() == 64) {
                getByteBuffer().putLong(index, value);
            } else {
                getByteBuffer().putLong(index,
                        set(value, 8, getByteBuffer().getLong(index)));
            }
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class BitField extends Member {
 
        public BitField(int nbrOfBits) {
            super(nbrOfBits, 0);
        }
 
        public long longValue() {
            long signedValue = readBits(bitIndex() + (offset() << 3),
                    bitLength());
            return ~(-1L << bitLength()) & signedValue;
        }
 
        public int intValue() {
            return (int) longValue();
        }
 
        public short shortValue() {
            return (short) longValue();
        }
 
        public byte byteValue() {
            return (byte) longValue();
        }
 
        public void set(long value) {
            writeBits(value, bitIndex() + (offset() << 3), bitLength());
        }
 
        public String toString() {
            return String.valueOf(longValue());
        }
    }
 
    public class Float32 extends Member {
 
        public Float32() {
            super(32, 4);
        }
 
        public float get() {
            final int index = getByteBufferPosition() + offset();
            return getByteBuffer().getFloat(index);
        }
 
        public void set(float value) {
            final int index = getByteBufferPosition() + offset();
            getByteBuffer().putFloat(index, value);
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Float64 extends Member {
 
        public Float64() {
            super(64, 8);
        }
 
        public double get() {
            final int index = getByteBufferPosition() + offset();
            return getByteBuffer().getDouble(index);
        }
 
        public void set(double value) {
            final int index = getByteBufferPosition() + offset();
            getByteBuffer().putDouble(index, value);
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Reference32<S extends Struct> extends Member {
 
        private S _struct;
 
        public Reference32() {
            super(32, 4);
        }
 
        public void set(S struct) {
            final int index = getByteBufferPosition() + offset();
            if (struct != null) {
                getByteBuffer().putInt(index, (int) struct.address());
            } else {
                getByteBuffer().putInt(index, 0);
            }
            _struct = struct;
        }
 
        public S get() {
            return _struct;
        }
 
        public int value() {
            final int index = getByteBufferPosition() + offset();
            return getByteBuffer().getInt(index);
        }
 
        public boolean isUpToDate() {
            final int index = getByteBufferPosition() + offset();
            if (_struct != null) {
                return getByteBuffer().getInt(index) == (int) _struct.address();
            } else {
                return getByteBuffer().getInt(index) == 0;
            }
        }
    }
 
    public class Reference64<S extends Struct> extends Member {
 
        private S _struct;
 
        public Reference64() {
            super(64, 8);
        }
 
        public void set(S struct) {
            final int index = getByteBufferPosition() + offset();
            if (struct != null) {
                getByteBuffer().putLong(index, struct.address());
            } else if (struct == null) {
                getByteBuffer().putLong(index, 0L);
            }
            _struct = struct;
        }
 
        public S get() {
            return _struct;
        }
 
        public long value() {
            final int index = getByteBufferPosition() + offset();
            return getByteBuffer().getLong(index);
        }
 
        public boolean isUpToDate() {
            final int index = getByteBufferPosition() + offset();
            if (_struct != null) {
                return getByteBuffer().getLong(index) == _struct.address();
            } else {
                return getByteBuffer().getLong(index) == 0L;
            }
        }
    }
 
    public class Enum8<T extends Enum<T>> extends Member {
 
        private final T[] _values;
 
        public Enum8(T[] values) {
            super(8, 1);
            _values = values;
        }
 
        public Enum8(T[] values, int nbrOfBits) {
            super(nbrOfBits, 1);
            _values = values;
        }
 
        public T get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().get(index);
            return _values[0xFF & get(1, word)];
        }
 
        public void set(T e) {
            int value = e.ordinal();
            if (_values[value] != e) throw new IllegalArgumentException(
                    "enum: "
                            + e
                            + ", ordinal value does not reflect enum values position");
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().get(index);
            getByteBuffer().put(index, (byte) set(value, 1, word));
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Enum16<T extends Enum<T>> extends Member {
 
        private final T[] _values;
 
        public Enum16(T[] values) {
            super(16, 2);
            _values = values;
        }
 
        public Enum16(T[] values, int nbrOfBits) {
            super(nbrOfBits, 2);
            _values = values;
        }
 
        public T get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getShort(index);
            return _values[0xFFFF & get(2, word)];
        }
 
        public void set(T e) {
            int value = e.ordinal();
            if (_values[value] != e) throw new IllegalArgumentException(
                    "enum: "
                            + e
                            + ", ordinal value does not reflect enum values position");
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getShort(index);
            getByteBuffer().putShort(index, (short) set(value, 2, word));
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Enum32<T extends Enum<T>> extends Member {
 
        private final T[] _values;
 
        public Enum32(T[] values) {
            super(32, 4);
            _values = values;
        }
 
        public Enum32(T[] values, int nbrOfBits) {
            super(nbrOfBits, 4);
            _values = values;
        }
 
        public T get() {
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getInt(index);
            return _values[get(4, word)];
        }
 
        public void set(T e) {
            int value = e.ordinal();
            if (_values[value] != e) throw new IllegalArgumentException(
                    "enum: "
                            + e
                            + ", ordinal value does not reflect enum values position");
            final int index = getByteBufferPosition() + offset();
            int word = getByteBuffer().getInt(index);
            getByteBuffer().putInt(index, set(value, 4, word));
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
 
    public class Enum64<T extends Enum<T>> extends Member {
 
        private final T[] _values;
 
        public Enum64(T[] values) {
            super(64, 8);
            _values = values;
        }
 
        public Enum64(T[] values, int nbrOfBits) {
            super(nbrOfBits, 8);
            _values = values;
        }
 
        public T get() {
            final int index = getByteBufferPosition() + offset();
            long word = getByteBuffer().getLong(index);
            return _values[(int) get(8, word)];
        }
 
        public void set(T e) {
            long value = e.ordinal();
            if (_values[(int) value] != e) throw new IllegalArgumentException(
                    "enum: "
                            + e
                            + ", ordinal value does not reflect enum values position");
            final int index = getByteBufferPosition() + offset();
            long word = getByteBuffer().getLong(index);
            getByteBuffer().putLong(index, set(value, 8, word));
        }
 
        public String toString() {
            return String.valueOf(this.get());
        }
    }
}