| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.apache.ignite.internal.binary; |
| |
| import java.io.EOFException; |
| import java.io.IOException; |
| import java.io.ObjectInput; |
| import java.math.BigDecimal; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.UUID; |
| import org.apache.ignite.binary.BinaryCollectionFactory; |
| import org.apache.ignite.binary.BinaryInvalidTypeException; |
| import org.apache.ignite.binary.BinaryMapFactory; |
| import org.apache.ignite.binary.BinaryObject; |
| import org.apache.ignite.binary.BinaryObjectException; |
| import org.apache.ignite.binary.BinaryRawReader; |
| import org.apache.ignite.binary.BinaryReader; |
| import org.apache.ignite.internal.binary.streams.BinaryInputStream; |
| import org.apache.ignite.internal.util.IgniteUtils; |
| import org.apache.ignite.internal.util.typedef.internal.S; |
| import org.apache.ignite.internal.util.typedef.internal.SB; |
| import org.jetbrains.annotations.NotNull; |
| import org.jetbrains.annotations.Nullable; |
| |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BINARY_ENUM; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BINARY_OBJ; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BOOLEAN; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BOOLEAN_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BYTE; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.BYTE_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.CHAR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.CHAR_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.CLASS; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.COL; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DATE; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DATE_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DECIMAL; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DECIMAL_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DFLT_HDR_LEN; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DOUBLE; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.DOUBLE_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.ENUM; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.ENUM_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.FLOAT; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.FLOAT_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.HANDLE; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.INT; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.INT_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.LONG; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.LONG_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.MAP; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.NULL; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.OBJ; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.OBJ_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.OPTM_MARSH; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.PROXY; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.SHORT; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.SHORT_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.STRING; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.STRING_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.TIME; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.TIMESTAMP; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.TIMESTAMP_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.TIME_ARR; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.UNREGISTERED_TYPE_ID; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.UUID; |
| import static org.apache.ignite.internal.binary.GridBinaryMarshaller.UUID_ARR; |
| |
| /** |
| * Binary reader implementation. |
| */ |
| @SuppressWarnings("unchecked") |
| public class BinaryReaderExImpl implements BinaryReader, BinaryRawReaderEx, BinaryReaderHandlesHolder, ObjectInput { |
| /** Binary context. */ |
| private final BinaryContext ctx; |
| |
| /** Input stream. */ |
| private final BinaryInputStream in; |
| |
| /** Class loaded. */ |
| private final ClassLoader ldr; |
| |
| /** Reader context which is constantly passed between objects. */ |
| private BinaryReaderHandles hnds; |
| |
| /** */ |
| private final int start; |
| |
| /** Start of actual data. Positioned right after the header. */ |
| private final int dataStart; |
| |
| /** Type ID. */ |
| private final int typeId; |
| |
| /** Raw offset. */ |
| private final int rawOff; |
| |
| /** Footer start. */ |
| private final int footerStart; |
| |
| /** Footer end. */ |
| private final int footerLen; |
| |
| /** Class descriptor. */ |
| private BinaryClassDescriptor desc; |
| |
| /** Mapper. */ |
| private final BinaryInternalMapper mapper; |
| |
| /** Schema Id. */ |
| private final int schemaId; |
| |
| /** Whether this is user type or not. */ |
| private final boolean userType; |
| |
| /** Whether field IDs exist. */ |
| private final int fieldIdLen; |
| |
| /** Offset size in bytes. */ |
| private final int fieldOffLen; |
| |
| /** Object schema. */ |
| private final BinarySchema schema; |
| |
| /** Whether passed IDs matches schema order. Reset to false as soon as a single mismatch detected. */ |
| private boolean matching = true; |
| |
| /** Order of a field whose match is expected. */ |
| private int matchingOrder; |
| |
| /** Whether stream is in raw mode. */ |
| private boolean raw; |
| |
| /** |
| * Constructor. |
| * |
| * @param ctx Context. |
| * @param in Input stream. |
| * @param ldr Class loader. |
| * @param forUnmarshal {@code True} if reader is needed to unmarshal object. |
| */ |
| public BinaryReaderExImpl(BinaryContext ctx, BinaryInputStream in, ClassLoader ldr, boolean forUnmarshal) { |
| this(ctx, |
| in, |
| ldr, |
| null, |
| forUnmarshal); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param ctx Context. |
| * @param in Input stream. |
| * @param ldr Class loader. |
| * @param hnds Context. |
| * @param forUnmarshal {@code True} if reader is need to unmarshal object. |
| */ |
| public BinaryReaderExImpl(BinaryContext ctx, |
| BinaryInputStream in, |
| ClassLoader ldr, |
| @Nullable BinaryReaderHandles hnds, |
| boolean forUnmarshal) { |
| this(ctx, |
| in, |
| ldr, |
| hnds, |
| false, |
| forUnmarshal); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param ctx Context. |
| * @param in Input stream. |
| * @param ldr Class loader. |
| * @param hnds Context. |
| * @param skipHdrCheck Whether to skip header check. |
| * @param forUnmarshal {@code True} if reader is need to unmarshal object. |
| */ |
| public BinaryReaderExImpl(BinaryContext ctx, |
| BinaryInputStream in, |
| ClassLoader ldr, |
| @Nullable BinaryReaderHandles hnds, |
| boolean skipHdrCheck, |
| boolean forUnmarshal) { |
| // Initialize base members. |
| this.ctx = ctx; |
| this.in = in; |
| this.ldr = ldr; |
| this.hnds = hnds; |
| |
| start = in.position(); |
| |
| // Perform full header parsing in case of binary object. |
| if (!skipHdrCheck && (in.readByte() == GridBinaryMarshaller.OBJ)) { |
| // Ensure protocol is fine. |
| BinaryUtils.checkProtocolVersion(in.readByte()); |
| |
| // Read header content. |
| short flags = in.readShort(); |
| int typeId0 = in.readInt(); |
| |
| in.readInt(); // Skip hash code. |
| |
| int len = in.readInt(); |
| schemaId = in.readInt(); |
| int offset = in.readInt(); |
| |
| // Get trivial flag values. |
| userType = BinaryUtils.isUserType(flags); |
| fieldIdLen = BinaryUtils.fieldIdLength(flags); |
| fieldOffLen = BinaryUtils.fieldOffsetLength(flags); |
| |
| // Calculate footer borders and raw offset. |
| if (BinaryUtils.hasSchema(flags)) { |
| // Schema exists. |
| footerStart = start + offset; |
| |
| if (BinaryUtils.hasRaw(flags)) { |
| footerLen = len - offset; |
| rawOff = start + in.readIntPositioned(start + len - 4); |
| } |
| else { |
| footerLen = len - offset; |
| rawOff = start + len; |
| } |
| } |
| else { |
| // No schema. |
| footerStart = start + len; |
| footerLen = 0; |
| |
| if (BinaryUtils.hasRaw(flags)) |
| rawOff = start + offset; |
| else |
| rawOff = start + len; |
| } |
| |
| // Finally, we have to resolve real type ID. |
| if (typeId0 == UNREGISTERED_TYPE_ID) { |
| int off = in.position(); |
| |
| if (forUnmarshal) { |
| // Registers class by type ID, at least locally if the cache is not ready yet. |
| desc = ctx.descriptorForClass(BinaryUtils.doReadClass(in, ctx, ldr, typeId0), false, false); |
| |
| typeId = desc.typeId(); |
| } |
| else |
| typeId = ctx.typeId(BinaryUtils.doReadClassName(in)); |
| |
| int clsNameLen = in.position() - off; |
| |
| dataStart = start + DFLT_HDR_LEN + clsNameLen; |
| } |
| else { |
| typeId = typeId0; |
| |
| dataStart = start + DFLT_HDR_LEN; |
| } |
| |
| mapper = userType ? ctx.userTypeMapper(typeId) : BinaryContext.defaultMapper(); |
| schema = BinaryUtils.hasSchema(flags) ? getOrCreateSchema() : null; |
| } |
| else { |
| dataStart = 0; |
| typeId = 0; |
| rawOff = 0; |
| footerStart = 0; |
| footerLen = 0; |
| mapper = null; |
| schemaId = 0; |
| userType = false; |
| fieldIdLen = 0; |
| fieldOffLen = 0; |
| schema = null; |
| } |
| |
| streamPosition(start); |
| } |
| |
| /** |
| * @return Input stream. |
| */ |
| public BinaryInputStream in() { |
| return in; |
| } |
| |
| /** |
| * @return Descriptor. |
| */ |
| BinaryClassDescriptor descriptor() { |
| if (desc == null) |
| desc = ctx.descriptorForTypeId(userType, typeId, ldr, true); |
| |
| return desc; |
| } |
| |
| /** |
| * @param offset Offset in the array. |
| * @return Unmarshalled value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| public Object unmarshal(int offset) throws BinaryObjectException { |
| streamPosition(offset); |
| |
| return in.position() >= 0 ? BinaryUtils.unmarshal(in, ctx, ldr, this) : null; |
| } |
| |
| /** |
| * @param fieldName Field name. |
| * @return Unmarshalled value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Object unmarshalField(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? BinaryUtils.unmarshal(in, ctx, ldr, this) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Unmarshalled value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Object unmarshalField(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? BinaryUtils.unmarshal(in, ctx, ldr, this) : null; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Binary object. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable BinaryObject readBinaryObject(int fieldId) throws BinaryObjectException { |
| if (findFieldById(fieldId)) { |
| if (checkFlag(BINARY_OBJ) == Flag.NULL) |
| return null; |
| |
| return new BinaryObjectImpl(ctx, BinaryUtils.doReadByteArray(in), in.readInt()); |
| } |
| else |
| return null; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Field class. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Class<?> readClass(int fieldId) throws BinaryObjectException { |
| if (findFieldById(fieldId)) { |
| if (checkFlag(CLASS) == Flag.NULL) |
| return null; |
| |
| return BinaryUtils.doReadClass(in, ctx, ldr); |
| } |
| |
| return null; |
| } |
| |
| /** |
| * @param obj Object. |
| */ |
| void setHandle(Object obj) { |
| setHandle(obj, start); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void setHandle(Object obj, int pos) { |
| handles().put(pos, obj); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public Object getHandle(int pos) { |
| return hnds != null ? hnds.get(pos) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public BinaryReaderHandles handles() { |
| if (hnds == null) |
| hnds = new BinaryReaderHandles(); |
| |
| return hnds; |
| } |
| |
| /** |
| * Recreating field value from a handle. |
| * |
| * @param <T> Field type. |
| * @return Field. |
| */ |
| private <T> T readHandleField() { |
| int handlePos = BinaryUtils.positionForHandle(in) - in.readInt(); |
| |
| Object obj = getHandle(handlePos); |
| |
| if (obj == null) { |
| int retPos = in.position(); |
| |
| streamPosition(handlePos); |
| |
| obj = BinaryUtils.doReadObject(in, ctx, ldr, this); |
| |
| streamPosition(retPos); |
| } |
| |
| return (T)obj; |
| } |
| |
| /** |
| * Wraps an exception by adding the fieldName |
| * |
| * @param fieldName the name of the field, causes failure |
| * @param e the cause of the deserialization failure |
| * @return wrapping exception |
| */ |
| private BinaryObjectException wrapFieldException(String fieldName, Exception e) { |
| if (S.INCLUDE_SENSITIVE) |
| return new BinaryObjectException("Failed to read field: " + fieldName, e); |
| else |
| return new BinaryObjectException("Failed to read field.", e); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public byte readByte(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(BYTE) == Flag.NORMAL ? in.readByte() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| byte readByte(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(BYTE) == Flag.NORMAL ? in.readByte() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Byte readByteNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(BYTE) == Flag.NORMAL ? in.readByte() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public byte readByte() throws BinaryObjectException { |
| return in.readByte(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public byte[] readByteArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readByteArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable byte[] readByteArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readByteArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public byte[] readByteArray() throws BinaryObjectException { |
| switch (checkFlag(BYTE_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadByteArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean readBoolean(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(BOOLEAN) == Flag.NORMAL && in.readBoolean(); |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| boolean readBoolean(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(BOOLEAN) == Flag.NORMAL && in.readBoolean(); |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Boolean readBooleanNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(BOOLEAN) == Flag.NORMAL ? in.readBoolean() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public boolean readBoolean() throws BinaryObjectException { |
| return in.readBoolean(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public boolean[] readBooleanArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readBooleanArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable boolean[] readBooleanArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readBooleanArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public boolean[] readBooleanArray() throws BinaryObjectException { |
| switch (checkFlag(BOOLEAN_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadBooleanArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public short readShort(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(SHORT) == Flag.NORMAL ? in.readShort() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| short readShort(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(SHORT) == Flag.NORMAL ? in.readShort() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Short readShortNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(SHORT) == Flag.NORMAL ? in.readShort() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public short readShort() throws BinaryObjectException { |
| return in.readShort(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public short[] readShortArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readShortArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable short[] readShortArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readShortArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public short[] readShortArray() throws BinaryObjectException { |
| switch (checkFlag(SHORT_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadShortArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public char readChar(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(CHAR) == Flag.NORMAL ? in.readChar() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| char readChar(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(CHAR) == Flag.NORMAL ? in.readChar() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Character readCharNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(CHAR) == Flag.NORMAL ? in.readChar() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public char readChar() throws BinaryObjectException { |
| return in.readChar(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public char[] readCharArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readCharArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable char[] readCharArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readCharArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public char[] readCharArray() throws BinaryObjectException { |
| switch (checkFlag(CHAR_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadCharArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int readInt(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(INT) == Flag.NORMAL ? in.readInt() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| int readInt(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(INT) == Flag.NORMAL ? in.readInt() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Integer readIntNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(INT) == Flag.NORMAL ? in.readInt() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int readInt() throws BinaryObjectException { |
| return in.readInt(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public int[] readIntArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readIntArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable int[] readIntArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readIntArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public int[] readIntArray() throws BinaryObjectException { |
| switch (checkFlag(INT_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadIntArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public long readLong(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(LONG) == Flag.NORMAL ? in.readLong() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| long readLong(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(LONG) == Flag.NORMAL ? in.readLong() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Long readLongNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(LONG) == Flag.NORMAL ? in.readLong() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public long readLong() throws BinaryObjectException { |
| return in.readLong(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public long[] readLongArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readLongArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable long[] readLongArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readLongArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public long[] readLongArray() throws BinaryObjectException { |
| switch (checkFlag(LONG_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadLongArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public float readFloat(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(FLOAT) == Flag.NORMAL ? in.readFloat() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| float readFloat(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(FLOAT) == Flag.NORMAL ? in.readFloat() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Float readFloatNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(FLOAT) == Flag.NORMAL ? in.readFloat() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public float readFloat() throws BinaryObjectException { |
| return in.readFloat(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public float[] readFloatArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readFloatArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable float[] readFloatArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readFloatArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public float[] readFloatArray() throws BinaryObjectException { |
| switch (checkFlag(FLOAT_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadFloatArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public double readDouble(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) && checkFlagNoHandles(DOUBLE) == Flag.NORMAL ? in.readDouble() : 0; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| double readDouble(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(DOUBLE) == Flag.NORMAL ? in.readDouble() : 0; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Double readDoubleNullable(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) && checkFlagNoHandles(DOUBLE) == Flag.NORMAL ? in.readDouble() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public double readDouble() throws BinaryObjectException { |
| return in.readDouble(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public double[] readDoubleArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readDoubleArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable double[] readDoubleArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readDoubleArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public double[] readDoubleArray() throws BinaryObjectException { |
| switch (checkFlag(DOUBLE_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadDoubleArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public BigDecimal readDecimal(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readDecimal() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable BigDecimal readDecimal(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readDecimal() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public BigDecimal readDecimal() throws BinaryObjectException { |
| return checkFlagNoHandles(DECIMAL) == Flag.NORMAL ? BinaryUtils.doReadDecimal(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public BigDecimal[] readDecimalArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readDecimalArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable BigDecimal[] readDecimalArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readDecimalArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public BigDecimal[] readDecimalArray() throws BinaryObjectException { |
| switch (checkFlag(DECIMAL_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadDecimalArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public String readString(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readString() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable String readString(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readString() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public String readString() throws BinaryObjectException { |
| return checkFlagNoHandles(STRING) == Flag.NORMAL ? BinaryUtils.doReadString(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public String[] readStringArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readStringArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable String[] readStringArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readStringArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public String[] readStringArray() throws BinaryObjectException { |
| switch (checkFlag(STRING_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadStringArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public UUID readUuid(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readUuid() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable UUID readUuid(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readUuid() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public UUID readUuid() throws BinaryObjectException { |
| return checkFlagNoHandles(UUID) == Flag.NORMAL ? BinaryUtils.doReadUuid(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public UUID[] readUuidArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readUuidArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable UUID[] readUuidArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readUuidArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public UUID[] readUuidArray() throws BinaryObjectException { |
| switch (checkFlag(UUID_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadUuidArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Date readDate(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readDate() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Date readDate(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readDate() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Date readDate() throws BinaryObjectException { |
| return checkFlagNoHandles(DATE) == Flag.NORMAL ? BinaryUtils.doReadDate(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Date[] readDateArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readDateArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Date[] readDateArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readDateArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Date[] readDateArray() throws BinaryObjectException { |
| switch (checkFlag(DATE_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadDateArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Timestamp readTimestamp(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readTimestamp() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Timestamp readTimestamp(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readTimestamp() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Timestamp readTimestamp() throws BinaryObjectException { |
| return checkFlagNoHandles(TIMESTAMP) == Flag.NORMAL ? BinaryUtils.doReadTimestamp(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Timestamp[] readTimestampArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readTimestampArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Timestamp[] readTimestampArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readTimestampArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Timestamp[] readTimestampArray() throws BinaryObjectException { |
| switch (checkFlag(TIMESTAMP_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadTimestampArray(in); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Time readTime(String fieldName) throws BinaryObjectException { |
| return findFieldByName(fieldName) ? this.readTime() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Time readTime() throws BinaryObjectException { |
| return checkFlagNoHandles(TIME) == Flag.NORMAL ? BinaryUtils.doReadTime(in) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Time[] readTimeArray(String fieldName) throws BinaryObjectException { |
| return findFieldByName(fieldName) ? this.readTimeArray() : null; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Time readTime(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readTime() : null; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Time[] readTimeArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readTimeArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override @Nullable public Time[] readTimeArray() throws BinaryObjectException { |
| switch (checkFlag(TIME_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadTimeArray(in); |
| case HANDLE: |
| return readHandleField(); |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @SuppressWarnings("unchecked") |
| @Nullable @Override public <T> T readObject(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? (T)BinaryUtils.doReadObject(in, ctx, ldr, this) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Object readObject(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? BinaryUtils.doReadObject(in, ctx, ldr, this) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public Object readObject() throws BinaryObjectException { |
| return BinaryUtils.doReadObject(in, ctx, ldr, this); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public Object readObjectDetached() throws BinaryObjectException { |
| return BinaryUtils.unmarshal(in, ctx, ldr, this, true); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public Object[] readObjectArray(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? this.readObjectArray() : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Object[] readObjectArray(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? this.readObjectArray() : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public Object[] readObjectArray() throws BinaryObjectException { |
| switch (checkFlag(OBJ_ARR)) { |
| case NORMAL: |
| return BinaryUtils.doReadObjectArray(in, ctx, ldr, this, true); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T extends Enum<?>> T readEnum(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? (T)readEnum0(null) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @param cls Class. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Enum<?> readEnum(int fieldId, @Nullable Class<?> cls) throws BinaryObjectException { |
| return findFieldById(fieldId) ? readEnum0(cls) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T extends Enum<?>> T readEnum() throws BinaryObjectException { |
| return (T)readEnum0(null); |
| } |
| |
| /** |
| * Internal routine to read enum for named field. |
| * |
| * @param cls Class. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| private Enum<?> readEnum0(@Nullable Class<?> cls) throws BinaryObjectException { |
| if (checkFlagNoHandles(ENUM) == Flag.NORMAL) { |
| // Read class even if we know it in advance to set correct stream position. |
| Class<?> cls0 = BinaryUtils.doReadClass(in, ctx, ldr); |
| |
| if (cls == null) |
| cls = cls0; |
| |
| return BinaryUtils.doReadEnum(in, cls); |
| } |
| else |
| return null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T extends Enum<?>> T[] readEnumArray(String fieldName) |
| throws BinaryObjectException { |
| |
| try { |
| return findFieldByName(fieldName) ? (T[])readEnumArray0(null) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Binary Enum |
| * @throws BinaryObjectException If failed. |
| */ |
| @Nullable BinaryEnumObjectImpl readBinaryEnum(int fieldId) throws BinaryObjectException { |
| return findFieldById(fieldId) ? BinaryUtils.doReadBinaryEnum(in, ctx) : null; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @param cls Class. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Object[] readEnumArray(int fieldId, @Nullable Class<?> cls) throws BinaryObjectException { |
| return findFieldById(fieldId) ? readEnumArray0(cls) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T extends Enum<?>> T[] readEnumArray() throws BinaryObjectException { |
| return (T[])readEnumArray0(null); |
| } |
| |
| /** |
| * Internal routine to read enum for named field. |
| * |
| * @param cls Class. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| private Object[] readEnumArray0(@Nullable Class<?> cls) throws BinaryObjectException { |
| switch (checkFlag(ENUM_ARR)) { |
| case NORMAL: |
| // Read class even if we know it in advance to set correct stream position. |
| Class<?> cls0 = BinaryUtils.doReadClass(in, ctx, ldr); |
| |
| if (cls == null) |
| cls = cls0; |
| |
| return BinaryUtils.doReadEnumArray(in, ctx, ldr, cls); |
| |
| case HANDLE: |
| return readHandleField(); |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T> Collection<T> readCollection(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? (Collection<T>)readCollection0(null) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T> Collection<T> readCollection(String fieldName, BinaryCollectionFactory<T> factory) |
| throws BinaryObjectException { |
| |
| try { |
| return findFieldByName(fieldName) ? readCollection0(factory) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @param factory Collection factory. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable <T> Collection<T> readCollection(int fieldId, @Nullable BinaryCollectionFactory<T> factory) |
| throws BinaryObjectException { |
| return findFieldById(fieldId) ? (Collection<T>)readCollection0(factory) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T> Collection<T> readCollection() throws BinaryObjectException { |
| return readCollection0(null); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <T> Collection<T> readCollection(BinaryCollectionFactory<T> factory) |
| throws BinaryObjectException { |
| return readCollection0(factory); |
| } |
| |
| /** |
| * Internal read collection routine. |
| * |
| * @param factory Collection factory. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| private Collection readCollection0(@Nullable BinaryCollectionFactory factory) |
| throws BinaryObjectException { |
| switch (checkFlag(COL)) { |
| case NORMAL: |
| return (Collection)BinaryUtils.doReadCollection(in, ctx, ldr, this, true, factory); |
| |
| case HANDLE: { |
| int handlePos = BinaryUtils.positionForHandle(in) - in.readInt(); |
| |
| Object obj = getHandle(handlePos); |
| |
| if (obj == null) { |
| int retPos = in.position(); |
| |
| streamPosition(handlePos); |
| |
| obj = readCollection0(factory); |
| |
| streamPosition(retPos); |
| } |
| |
| return (Collection)obj; |
| } |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <K, V> Map<K, V> readMap(String fieldName) throws BinaryObjectException { |
| try { |
| return findFieldByName(fieldName) ? (Map<K, V>)readMap0(null) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <K, V> Map<K, V> readMap(String fieldName, BinaryMapFactory<K, V> factory) |
| throws BinaryObjectException { |
| |
| try { |
| return findFieldByName(fieldName) ? readMap0(factory) : null; |
| } |
| catch (Exception ex) { |
| throw wrapFieldException(fieldName, ex); |
| } |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @param factory Factory. |
| * @return Value. |
| * @throws BinaryObjectException In case of error. |
| */ |
| @Nullable Map<?, ?> readMap(int fieldId, @Nullable BinaryMapFactory factory) throws BinaryObjectException { |
| return findFieldById(fieldId) ? readMap0(factory) : null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <K, V> Map<K, V> readMap() throws BinaryObjectException { |
| return readMap0(null); |
| } |
| |
| /** {@inheritDoc} */ |
| @Nullable @Override public <K, V> Map<K, V> readMap(BinaryMapFactory<K, V> factory) |
| throws BinaryObjectException { |
| return readMap0(factory); |
| } |
| |
| /** |
| * Internal read map routine. |
| * |
| * @param factory Factory. |
| * @return Value. |
| * @throws BinaryObjectException If failed. |
| */ |
| private Map readMap0(@Nullable BinaryMapFactory factory) throws BinaryObjectException { |
| switch (checkFlag(MAP)) { |
| case NORMAL: |
| return (Map)BinaryUtils.doReadMap(in, ctx, ldr, this, true, factory); |
| |
| case HANDLE: { |
| int handlePos = BinaryUtils.positionForHandle(in) - in.readInt(); |
| |
| Object obj = getHandle(handlePos); |
| |
| if (obj == null) { |
| int retPos = in.position(); |
| |
| streamPosition(handlePos); |
| |
| obj = readMap0(factory); |
| |
| streamPosition(retPos); |
| } |
| |
| return (Map)obj; |
| } |
| |
| default: |
| return null; |
| } |
| } |
| |
| /** |
| * Ensure that type flag is either null, handle or contains expected value. |
| * |
| * @param expFlag Expected value. |
| * @return Flag mode. |
| * @throws BinaryObjectException If flag is neither null, nor handle or expected. |
| */ |
| private Flag checkFlag(byte expFlag) { |
| byte flag = in.readByte(); |
| |
| if (flag == expFlag) |
| return Flag.NORMAL; |
| else if (flag == NULL) |
| return Flag.NULL; |
| else if (flag == HANDLE) |
| return Flag.HANDLE; |
| |
| int pos = BinaryUtils.positionForHandle(in); |
| |
| throw new BinaryObjectException("Unexpected field type [pos=" + pos + ", expected=" + fieldFlagName(expFlag) + |
| ", actual=" + fieldFlagName(flag) + ']'); |
| } |
| |
| /** |
| * Ensure that type flag is either null or contains expected value. |
| * |
| * @param expFlag Expected value. |
| * @return Flag mode. |
| * @throws BinaryObjectException If flag is neither null, nor expected. |
| */ |
| private Flag checkFlagNoHandles(byte expFlag) { |
| byte flag = in.readByte(); |
| |
| if (flag == expFlag) |
| return Flag.NORMAL; |
| else if (flag == NULL) |
| return Flag.NULL; |
| |
| int pos = BinaryUtils.positionForHandle(in); |
| |
| throw new BinaryObjectException("Unexpected field type [pos=" + pos + ", expected=" + fieldFlagName(expFlag) + |
| ", actual=" + fieldFlagName(flag) + ']'); |
| } |
| |
| /** |
| * Gets a flag name |
| * |
| * @param flag a flag value |
| * @return string representation of the flag (type name, handle, else number) |
| */ |
| private String fieldFlagName(byte flag) { |
| String typeName = BinaryUtils.fieldTypeName(flag); |
| |
| return typeName == null ? String.valueOf(flag) : typeName; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public BinaryRawReader rawReader() { |
| if (!raw) { |
| streamPositionRandom(rawOff); |
| |
| raw = true; |
| |
| return this; |
| } |
| else |
| throw new BinaryObjectException("Method \"rawReader\" can be called only once."); |
| } |
| |
| /** |
| * @return Deserialized object. |
| * @throws BinaryObjectException If failed. |
| */ |
| @Nullable Object deserialize() throws BinaryObjectException { |
| String newName = ctx.configuration().getIgniteInstanceName(); |
| String oldName = IgniteUtils.setCurrentIgniteName(newName); |
| |
| try { |
| return deserialize0(); |
| } |
| finally { |
| IgniteUtils.restoreOldIgniteName(oldName, newName); |
| } |
| } |
| |
| /** |
| * @return Deserialized object. |
| * @throws BinaryObjectException If failed. |
| */ |
| @Nullable private Object deserialize0() throws BinaryObjectException { |
| Object obj; |
| |
| byte flag = in.readByte(); |
| |
| switch (flag) { |
| case NULL: |
| obj = null; |
| |
| break; |
| |
| case HANDLE: |
| int handlePos = start - in.readInt(); |
| |
| obj = getHandle(handlePos); |
| |
| if (obj == null) { |
| int retPos = in.position(); |
| |
| streamPosition(handlePos); |
| |
| obj = BinaryUtils.doReadObject(in, ctx, ldr, this); |
| |
| streamPosition(retPos); |
| } |
| |
| break; |
| |
| case OBJ: |
| if (desc == null) |
| desc = ctx.descriptorForTypeId(userType, typeId, ldr, true); |
| |
| streamPosition(dataStart); |
| |
| if (desc == null) |
| throw new BinaryInvalidTypeException("Unknown type ID: " + typeId); |
| |
| obj = desc.read(this); |
| |
| streamPosition(footerStart + footerLen); |
| |
| break; |
| |
| case BYTE: |
| obj = in.readByte(); |
| |
| break; |
| |
| case SHORT: |
| obj = in.readShort(); |
| |
| break; |
| |
| case INT: |
| obj = in.readInt(); |
| |
| break; |
| |
| case LONG: |
| obj = in.readLong(); |
| |
| break; |
| |
| case FLOAT: |
| obj = in.readFloat(); |
| |
| break; |
| |
| case DOUBLE: |
| obj = in.readDouble(); |
| |
| break; |
| |
| case CHAR: |
| obj = in.readChar(); |
| |
| break; |
| |
| case BOOLEAN: |
| obj = in.readBoolean(); |
| |
| break; |
| |
| case DECIMAL: |
| obj = BinaryUtils.doReadDecimal(in); |
| |
| break; |
| |
| case STRING: |
| obj = BinaryUtils.doReadString(in); |
| |
| break; |
| |
| case UUID: |
| obj = BinaryUtils.doReadUuid(in); |
| |
| break; |
| |
| case DATE: |
| obj = BinaryUtils.doReadDate(in); |
| |
| break; |
| |
| case TIMESTAMP: |
| obj = BinaryUtils.doReadTimestamp(in); |
| |
| break; |
| |
| case TIME: |
| obj = BinaryUtils.doReadTime(in); |
| |
| break; |
| |
| case BYTE_ARR: |
| obj = BinaryUtils.doReadByteArray(in); |
| |
| break; |
| |
| case SHORT_ARR: |
| obj = BinaryUtils.doReadShortArray(in); |
| |
| break; |
| |
| case INT_ARR: |
| obj = BinaryUtils.doReadIntArray(in); |
| |
| break; |
| |
| case LONG_ARR: |
| obj = BinaryUtils.doReadLongArray(in); |
| |
| break; |
| |
| case FLOAT_ARR: |
| obj = BinaryUtils.doReadFloatArray(in); |
| |
| break; |
| |
| case DOUBLE_ARR: |
| obj = BinaryUtils.doReadDoubleArray(in); |
| |
| break; |
| |
| case CHAR_ARR: |
| obj = BinaryUtils.doReadCharArray(in); |
| |
| break; |
| |
| case BOOLEAN_ARR: |
| obj = BinaryUtils.doReadBooleanArray(in); |
| |
| break; |
| |
| case DECIMAL_ARR: |
| obj = BinaryUtils.doReadDecimalArray(in); |
| |
| break; |
| |
| case STRING_ARR: |
| obj = BinaryUtils.doReadStringArray(in); |
| |
| break; |
| |
| case UUID_ARR: |
| obj = BinaryUtils.doReadUuidArray(in); |
| |
| break; |
| |
| case DATE_ARR: |
| obj = BinaryUtils.doReadDateArray(in); |
| |
| break; |
| |
| case TIMESTAMP_ARR: |
| obj = BinaryUtils.doReadTimestampArray(in); |
| |
| break; |
| |
| case TIME_ARR: |
| obj = BinaryUtils.doReadTimeArray(in); |
| |
| break; |
| |
| case OBJ_ARR: |
| obj = BinaryUtils.doReadObjectArray(in, ctx, ldr, this, true); |
| |
| break; |
| |
| case COL: |
| obj = BinaryUtils.doReadCollection(in, ctx, ldr, this, true, null); |
| |
| break; |
| |
| case MAP: |
| obj = BinaryUtils.doReadMap(in, ctx, ldr, this, true, null); |
| |
| break; |
| |
| case BINARY_OBJ: |
| obj = BinaryUtils.doReadBinaryObject(in, ctx, false); |
| |
| ((BinaryObjectImpl)obj).context(ctx); |
| |
| if (!GridBinaryMarshaller.KEEP_BINARIES.get()) |
| obj = ((BinaryObject)obj).deserialize(); |
| |
| break; |
| |
| case ENUM: |
| obj = BinaryUtils.doReadEnum(in, BinaryUtils.doReadClass(in, ctx, ldr)); |
| |
| break; |
| |
| case ENUM_ARR: |
| obj = BinaryUtils.doReadEnumArray(in, ctx, ldr, BinaryUtils.doReadClass(in, ctx, ldr)); |
| |
| break; |
| |
| case BINARY_ENUM: |
| obj = BinaryUtils.doReadBinaryEnum(in, ctx); |
| |
| if (!GridBinaryMarshaller.KEEP_BINARIES.get()) |
| obj = ((BinaryObject)obj).deserialize(); |
| |
| break; |
| |
| case CLASS: |
| obj = BinaryUtils.doReadClass(in, ctx, ldr); |
| |
| break; |
| |
| case PROXY: |
| obj = BinaryUtils.doReadProxy(in, ctx, ldr, this); |
| |
| break; |
| |
| case OPTM_MARSH: |
| obj = BinaryUtils.doReadOptimized(in, ctx, ldr); |
| |
| break; |
| |
| default: |
| throw new BinaryObjectException("Invalid flag value: " + flag); |
| } |
| |
| return obj; |
| } |
| |
| /** |
| * @param fieldId Field ID. |
| * @return Deserialized object. |
| * @throws BinaryObjectException If failed. |
| */ |
| @Nullable Object readField(int fieldId) throws BinaryObjectException { |
| if (!findFieldById(fieldId)) |
| return null; |
| |
| return new BinaryReaderExImpl(ctx, in, ldr, hnds, true).deserialize(); |
| } |
| |
| /** |
| * @param name Field name. |
| * @return Field offset. |
| */ |
| private int fieldId(String name) { |
| assert name != null; |
| |
| return mapper.fieldId(typeId, name); |
| } |
| |
| /** |
| * Get or create object schema. |
| * |
| * @return Schema. |
| */ |
| public BinarySchema getOrCreateSchema() { |
| BinarySchema schema = ctx.schemaRegistry(typeId).schema(schemaId); |
| |
| if (schema == null) { |
| if (fieldIdLen != BinaryUtils.FIELD_ID_LEN) { |
| BinaryTypeImpl type = (BinaryTypeImpl) ctx.metadata(typeId, schemaId); |
| |
| BinaryMetadata meta = type != null ? type.metadata() : null; |
| |
| if (type == null || meta == null) |
| throw new BinaryObjectException("Cannot find metadata for object with compact footer: " + |
| typeId); |
| |
| Collection<BinarySchema> existingSchemas = meta.schemas(); |
| |
| for (BinarySchema existingSchema : existingSchemas) { |
| if (schemaId == existingSchema.schemaId()) { |
| schema = existingSchema; |
| |
| break; |
| } |
| } |
| |
| if (schema == null) { |
| List<Integer> existingSchemaIds = new ArrayList<>(existingSchemas.size()); |
| |
| for (BinarySchema existingSchema : existingSchemas) |
| existingSchemaIds.add(existingSchema.schemaId()); |
| |
| |
| throw new BinaryObjectException("Cannot find schema for object with compact footer" + |
| " [typeName=" + type.typeName() + |
| ", typeId=" + typeId + |
| ", missingSchemaId=" + schemaId + |
| ", existingSchemaIds=" + existingSchemaIds + ']' |
| ); |
| } |
| } |
| else |
| schema = createSchema(); |
| |
| assert schema != null; |
| |
| ctx.schemaRegistry(typeId).addSchema(schemaId, schema); |
| } |
| |
| return schema; |
| } |
| |
| /** |
| * Create schema. |
| * |
| * @return Schema. |
| */ |
| private BinarySchema createSchema() { |
| assert fieldIdLen == BinaryUtils.FIELD_ID_LEN; |
| |
| BinarySchema.Builder builder = BinarySchema.Builder.newBuilder(); |
| |
| int searchPos = footerStart; |
| int searchEnd = searchPos + footerLen; |
| |
| while (searchPos < searchEnd) { |
| int fieldId = in.readIntPositioned(searchPos); |
| |
| builder.addField(fieldId); |
| |
| searchPos += BinaryUtils.FIELD_ID_LEN + fieldOffLen; |
| } |
| |
| return builder.build(); |
| } |
| |
| /** |
| * Try finding the field by name. |
| * |
| * @param name Field name. |
| * @return Offset. |
| */ |
| public boolean findFieldByName(String name) { |
| if (raw) |
| throw new BinaryObjectException("Failed to read named field because reader is in raw mode."); |
| |
| assert dataStart != start; |
| |
| if (footerLen == 0) |
| return false; |
| |
| if (userType) { |
| int order; |
| |
| if (matching) { |
| int expOrder = matchingOrder++; |
| |
| BinarySchema.Confirmation confirm = schema.confirmOrder(expOrder, name); |
| |
| switch (confirm) { |
| case CONFIRMED: |
| // The best case: got order without ID calculation and (ID -> order) lookup. |
| if (expOrder == 0) |
| // When we read the very first field, position is set to start, hence this re-positioning. |
| streamPosition(dataStart); |
| |
| return true; |
| |
| case REJECTED: |
| // Rejected, no more speculations are possible. Fallback to the slowest scenario. |
| matching = false; |
| |
| order = schema.order(fieldId(name)); |
| |
| break; |
| |
| default: |
| // Field name is not know for this order. Need to calculate ID and repeat speculation. |
| assert confirm == BinarySchema.Confirmation.CLARIFY; |
| |
| int id = fieldId(name); |
| int realId = schema.fieldId(expOrder); |
| |
| if (id == realId) { |
| // IDs matched, cache field name inside schema. |
| schema.clarifyFieldName(expOrder, name); |
| |
| if (expOrder == 0) |
| streamPosition(dataStart); |
| |
| return true; |
| } |
| else { |
| // No match, stop further speculations. |
| matching = false; |
| |
| order = schema.order(id); |
| } |
| |
| break; |
| } |
| } |
| else |
| order = schema.order(fieldId(name)); |
| |
| return trySetUserFieldPosition(order); |
| } |
| else |
| return trySetSystemFieldPosition(fieldId(name)); |
| } |
| |
| /** |
| * Try finding the field by ID. Used for types with stable schema (Serializable) to avoid |
| * (string -> ID) calculations. |
| * |
| * @param id Field ID. |
| * @return {@code True} if field was found and stream was positioned accordingly. |
| */ |
| private boolean findFieldById(int id) { |
| assert !raw; // Assert, not exception, because this is called only from internals for Serializable types. |
| assert dataStart != start; |
| |
| if (footerLen == 0) |
| return false; |
| |
| if (userType) { |
| int order; |
| |
| if (matching) { |
| // Trying to get field order speculatively. |
| int expOrder = matchingOrder++; |
| |
| int realId = schema.fieldId(expOrder); |
| |
| if (realId == id) { |
| if (expOrder == 0) |
| streamPosition(dataStart); |
| |
| return true; |
| } |
| else { |
| // Mismatch detected, no need for further speculations. |
| matching = false; |
| |
| order = schema.order(id); |
| } |
| } |
| else |
| order = schema.order(id); |
| |
| return trySetUserFieldPosition(order); |
| } |
| else |
| return trySetSystemFieldPosition(id); |
| } |
| |
| /** |
| * Set position for the given user field order. |
| * |
| * @param order Order. |
| * @return {@code True} if field was found and stream was positioned accordingly. |
| */ |
| private boolean trySetUserFieldPosition(int order) { |
| if (order != BinarySchema.ORDER_NOT_FOUND) { |
| int offsetPos = footerStart + order * (fieldIdLen + fieldOffLen) + fieldIdLen; |
| |
| int pos = start + BinaryUtils.fieldOffsetRelative(in, offsetPos, fieldOffLen); |
| |
| streamPosition(pos); |
| |
| return true; |
| } |
| else |
| return false; |
| } |
| |
| /** |
| * Set position for the given system field ID. |
| * |
| * @param id Field ID. |
| * @return {@code True} if field was found and stream was positioned accordingly. |
| */ |
| private boolean trySetSystemFieldPosition(int id) { |
| // System types are never written with compact footers because they do not have metadata. |
| assert fieldIdLen == BinaryUtils.FIELD_ID_LEN; |
| |
| int searchPos = footerStart; |
| int searchTail = searchPos + footerLen; |
| |
| while (true) { |
| if (searchPos >= searchTail) |
| return false; |
| |
| int id0 = in.readIntPositioned(searchPos); |
| |
| if (id0 == id) { |
| int pos = start + BinaryUtils.fieldOffsetRelative(in, searchPos + BinaryUtils.FIELD_ID_LEN, |
| fieldOffLen); |
| |
| streamPosition(pos); |
| |
| return true; |
| } |
| |
| searchPos += BinaryUtils.FIELD_ID_LEN + fieldOffLen; |
| } |
| } |
| |
| /** |
| * Set stream position. |
| * |
| * @param pos Position. |
| */ |
| private void streamPosition(int pos) { |
| in.position(pos); |
| } |
| |
| /** |
| * Set stream position as a part of some random read. Further speculations will be disabled after this call. |
| * |
| * @param pos Position. |
| */ |
| private void streamPositionRandom(int pos) { |
| streamPosition(pos); |
| |
| matching = false; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int readUnsignedByte() throws IOException { |
| return readByte() & 0xff; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int readUnsignedShort() throws IOException { |
| return readShort() & 0xffff; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public String readLine() throws IOException { |
| SB sb = new SB(); |
| |
| int b; |
| |
| while ((b = read()) >= 0) { |
| char c = (char)b; |
| |
| switch (c) { |
| case '\n': |
| return sb.toString(); |
| |
| case '\r': |
| b = read(); |
| |
| if (b < 0 || b == '\n') |
| return sb.toString(); |
| else |
| sb.a((char)b); |
| |
| break; |
| |
| default: |
| sb.a(c); |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** {@inheritDoc} */ |
| @SuppressWarnings("ConstantConditions") |
| @NotNull @Override public String readUTF() throws IOException { |
| return readString(); |
| } |
| |
| /** {@inheritDoc} */ |
| @SuppressWarnings("NullableProblems") |
| @Override public void readFully(byte[] b) throws IOException { |
| readFully(b, 0, b.length); |
| } |
| |
| /** {@inheritDoc} */ |
| @SuppressWarnings("NullableProblems") |
| @Override public void readFully(byte[] b, int off, int len) throws IOException { |
| int cnt = in.read(b, off, len); |
| |
| if (cnt < len) |
| throw new EOFException(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int skipBytes(int n) throws IOException { |
| int toSkip = Math.min(in.remaining(), n); |
| |
| streamPositionRandom(in.position() + toSkip); |
| |
| return toSkip; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int read() throws IOException { |
| return readByte(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int read(byte[] b) throws IOException { |
| return read(b, 0, b.length); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int read(byte[] b, int off, int len) throws IOException { |
| return in.read(b, off, len); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public long skip(long n) throws IOException { |
| return skipBytes((int) n); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public int available() throws IOException { |
| return in.remaining(); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override public void close() throws IOException { |
| // No-op. |
| } |
| |
| /** |
| * @return Binary context. |
| */ |
| public BinaryContext context() { |
| return ctx; |
| } |
| |
| /** |
| * Flag. |
| */ |
| private enum Flag { |
| /** Regular. */ |
| NORMAL, |
| |
| /** Handle. */ |
| HANDLE, |
| |
| /** Null. */ |
| NULL |
| } |
| } |
