http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderReader.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderReader.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderReader.java new file mode 100644 index 0000000..9b9e8b8 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderReader.java @@ -0,0 +1,846 @@ +/* + * 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.builder; + +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.internal.binary.BinaryObjectImpl; +import org.apache.ignite.internal.binary.BinaryReaderExImpl; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryContext; +import org.apache.ignite.internal.binary.BinaryPositionReadable; +import org.apache.ignite.internal.binary.BinaryPrimitives; +import org.apache.ignite.internal.binary.BinarySchema; +import org.apache.ignite.internal.binary.streams.BinaryHeapInputStream; +import org.apache.ignite.internal.binary.BinaryUtils; + +import java.sql.Timestamp; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +import static java.nio.charset.StandardCharsets.UTF_8; + +/** + * + */ +public class BinaryBuilderReader implements BinaryPositionReadable { + /** */ + private final BinaryContext ctx; + + /** */ + private final byte[] arr; + + /** */ + private final BinaryReaderExImpl reader; + + /** */ + private final Map<Integer, BinaryObjectBuilderImpl> objMap; + + /** */ + private int pos; + + /* + * Constructor. + * + * @param objImpl Portable object + */ + BinaryBuilderReader(BinaryObjectImpl objImpl) { + ctx = objImpl.context(); + arr = objImpl.array(); + pos = objImpl.start(); + + reader = new BinaryReaderExImpl(ctx, + BinaryHeapInputStream.create(arr, pos), + ctx.configuration().getClassLoader()); + + objMap = new HashMap<>(); + } + + /** + * Copying constructor. + * + * @param other Other reader. + * @param start Start position. + */ + BinaryBuilderReader(BinaryBuilderReader other, int start) { + this.ctx = other.ctx; + this.arr = other.arr; + this.pos = start; + + reader = new BinaryReaderExImpl(ctx, BinaryHeapInputStream.create(arr, start), null, other.reader.handles()); + + this.objMap = other.objMap; + } + + /** + * @return Portable context. + */ + public BinaryContext portableContext() { + return ctx; + } + + /** + * @param obj Mutable portable object. + */ + public void registerObject(BinaryObjectBuilderImpl obj) { + objMap.put(obj.start(), obj); + } + + /** + * Get schema of the object, starting at the given position. + * + * @return Object's schema. + */ + public BinarySchema schema() { + return reader.getOrCreateSchema(); + } + + /** + * @return Read int value. + */ + public int readInt() { + int res = readInt(0); + + pos += 4; + + return res; + } + + /** + * @return Read int value. + */ + public byte readByte() { + return arr[pos++]; + } + + /** + * @return Read boolean value. + */ + public boolean readBoolean() { + return readByte() == 1; + } + + /** + * @return Read int value. + */ + public byte readByte(int off) { + return arr[pos + off]; + } + + /** + * @param off Offset related to {@link #pos} + * @return Read int value. + */ + public int readInt(int off) { + return BinaryPrimitives.readInt(arr, pos + off); + } + + /** + * @param pos Position in the source array. + * @return Read byte value. + */ + public byte readBytePositioned(int pos) { + return BinaryPrimitives.readByte(arr, pos); + } + + /** {@inheritDoc} */ + @Override public short readShortPositioned(int pos) { + return BinaryPrimitives.readShort(arr, pos); + } + + /** {@inheritDoc} */ + @Override public int readIntPositioned(int pos) { + return BinaryPrimitives.readInt(arr, pos); + } + + /** + * @return Read length of array. + */ + public int readLength() { + return BinaryPrimitives.readInt(arr, pos); + } + + /** + * Read string length. + * + * @return String length. + */ + public int readStringLength() { + return BinaryPrimitives.readInt(arr, pos); + } + + /** + * Reads string. + * + * @return String. + */ + public String readString() { + byte flag = readByte(); + + if (flag == GridBinaryMarshaller.NULL) + return null; + + if (flag != GridBinaryMarshaller.STRING) + throw new BinaryObjectException("Failed to deserialize String."); + + int len = readInt(); + + String str = new String(arr, pos, len, UTF_8); + + pos += len; + + return str; + } + + /** + * + */ + public void skipValue() { + byte type = arr[pos++]; + + int len; + + switch (type) { + case GridBinaryMarshaller.NULL: + return; + + case GridBinaryMarshaller.OBJ: + pos += readInt(GridBinaryMarshaller.TOTAL_LEN_POS - 1) - 1; + + return; + + case GridBinaryMarshaller.BOOLEAN: + case GridBinaryMarshaller.BYTE: + len = 1; + break; + + case GridBinaryMarshaller.CHAR: + case GridBinaryMarshaller.SHORT: + len = 2; + + break; + + case GridBinaryMarshaller.HANDLE: + case GridBinaryMarshaller.FLOAT: + case GridBinaryMarshaller.INT: + len = 4; + + break; + + case GridBinaryMarshaller.ENUM: + //skipping type id and ordinal value + len = 8; + + break; + + case GridBinaryMarshaller.LONG: + case GridBinaryMarshaller.DOUBLE: + len = 8; + + break; + + case GridBinaryMarshaller.BYTE_ARR: + case GridBinaryMarshaller.BOOLEAN_ARR: + len = 4 + readLength(); + + break; + + case GridBinaryMarshaller.STRING: + len = 4 + readStringLength(); + + break; + + case GridBinaryMarshaller.DECIMAL: + len = /** scale */ 4 + /** mag len */ 4 + /** mag bytes count */ readInt(4); + + break; + + case GridBinaryMarshaller.UUID: + len = 8 + 8; + + break; + + case GridBinaryMarshaller.DATE: + len = 8; + + break; + + case GridBinaryMarshaller.TIMESTAMP: + len = 8 + 4; + + break; + + case GridBinaryMarshaller.CHAR_ARR: + case GridBinaryMarshaller.SHORT_ARR: + len = 4 + readLength() * 2; + + break; + + case GridBinaryMarshaller.INT_ARR: + case GridBinaryMarshaller.FLOAT_ARR: + len = 4 + readLength() * 4; + + break; + + case GridBinaryMarshaller.LONG_ARR: + case GridBinaryMarshaller.DOUBLE_ARR: + len = 4 + readLength() * 8; + + break; + + case GridBinaryMarshaller.DECIMAL_ARR: + case GridBinaryMarshaller.DATE_ARR: + case GridBinaryMarshaller.TIMESTAMP_ARR: + case GridBinaryMarshaller.OBJ_ARR: + case GridBinaryMarshaller.ENUM_ARR: + case GridBinaryMarshaller.UUID_ARR: + case GridBinaryMarshaller.STRING_ARR: { + int size = readInt(); + + for (int i = 0; i < size; i++) + skipValue(); + + return; + } + + case GridBinaryMarshaller.COL: { + int size = readInt(); + + pos++; // skip collection type + + for (int i = 0; i < size; i++) + skipValue(); + + return; + } + + case GridBinaryMarshaller.MAP: { + int size = readInt(); + + pos++; // skip collection type + + for (int i = 0; i < size; i++) { + skipValue(); // skip key. + skipValue(); // skip value. + } + + return; + } + + case GridBinaryMarshaller.PORTABLE_OBJ: + len = readInt() + 4; + + break; + + default: + throw new BinaryObjectException("Invalid flag value: " + type); + } + + pos += len; + } + + /** + * @param pos Position. + * @param len Length. + * @return Object. + */ + public Object getValueQuickly(int pos, int len) { + byte type = arr[pos]; + + switch (type) { + case GridBinaryMarshaller.NULL: + return null; + + case GridBinaryMarshaller.HANDLE: { + int objStart = pos - readIntPositioned(pos + 1); + + BinaryObjectBuilderImpl res = objMap.get(objStart); + + if (res == null) { + res = new BinaryObjectBuilderImpl(new BinaryBuilderReader(this, objStart), objStart); + + objMap.put(objStart, res); + } + + return res; + } + + case GridBinaryMarshaller.OBJ: { + BinaryObjectBuilderImpl res = objMap.get(pos); + + if (res == null) { + res = new BinaryObjectBuilderImpl(new BinaryBuilderReader(this, pos), pos); + + objMap.put(pos, res); + } + + return res; + } + + case GridBinaryMarshaller.BYTE: + return arr[pos + 1]; + + case GridBinaryMarshaller.SHORT: + return BinaryPrimitives.readShort(arr, pos + 1); + + case GridBinaryMarshaller.INT: + return BinaryPrimitives.readInt(arr, pos + 1); + + case GridBinaryMarshaller.LONG: + return BinaryPrimitives.readLong(arr, pos + 1); + + case GridBinaryMarshaller.FLOAT: + return BinaryPrimitives.readFloat(arr, pos + 1); + + case GridBinaryMarshaller.DOUBLE: + return BinaryPrimitives.readDouble(arr, pos + 1); + + case GridBinaryMarshaller.CHAR: + return BinaryPrimitives.readChar(arr, pos + 1); + + case GridBinaryMarshaller.BOOLEAN: + return arr[pos + 1] != 0; + + case GridBinaryMarshaller.DECIMAL: + case GridBinaryMarshaller.STRING: + case GridBinaryMarshaller.UUID: + case GridBinaryMarshaller.DATE: + case GridBinaryMarshaller.TIMESTAMP: + return new BinaryPlainLazyValue(this, pos, len); + + case GridBinaryMarshaller.BYTE_ARR: + case GridBinaryMarshaller.SHORT_ARR: + case GridBinaryMarshaller.INT_ARR: + case GridBinaryMarshaller.LONG_ARR: + case GridBinaryMarshaller.FLOAT_ARR: + case GridBinaryMarshaller.DOUBLE_ARR: + case GridBinaryMarshaller.CHAR_ARR: + case GridBinaryMarshaller.BOOLEAN_ARR: + case GridBinaryMarshaller.DECIMAL_ARR: + case GridBinaryMarshaller.DATE_ARR: + case GridBinaryMarshaller.TIMESTAMP_ARR: + case GridBinaryMarshaller.UUID_ARR: + case GridBinaryMarshaller.STRING_ARR: + case GridBinaryMarshaller.ENUM_ARR: + case GridBinaryMarshaller.OBJ_ARR: + case GridBinaryMarshaller.COL: + case GridBinaryMarshaller.MAP: + return new LazyCollection(pos); + + case GridBinaryMarshaller.ENUM: { + if (len == 1) { + assert readByte(pos) == GridBinaryMarshaller.NULL; + + return null; + } + + int mark = position(); + position(pos + 1); + + BinaryBuilderEnum builderEnum = new BinaryBuilderEnum(this); + + position(mark); + + return builderEnum; + } + + case GridBinaryMarshaller.PORTABLE_OBJ: { + int size = readIntPositioned(pos + 1); + + int start = readIntPositioned(pos + 4 + size); + + BinaryObjectImpl portableObj = new BinaryObjectImpl(ctx, arr, pos + 4 + start); + + return new BinaryPlainBinaryObject(portableObj); + } + + default: + throw new BinaryObjectException("Invalid flag value: " + type); + } + } + + /** + * @return Parsed value. + */ + public Object parseValue() { + int valPos = pos; + + byte type = arr[pos++]; + + int plainLazyValLen; + + boolean modifiableLazyVal = false; + + switch (type) { + case GridBinaryMarshaller.NULL: + return null; + + case GridBinaryMarshaller.HANDLE: { + int objStart = pos - 1 - readInt(); + + BinaryObjectBuilderImpl res = objMap.get(objStart); + + if (res == null) { + res = new BinaryObjectBuilderImpl(new BinaryBuilderReader(this, objStart), objStart); + + objMap.put(objStart, res); + } + + return res; + } + + case GridBinaryMarshaller.OBJ: { + pos--; + + BinaryObjectBuilderImpl res = objMap.get(pos); + + if (res == null) { + res = new BinaryObjectBuilderImpl(new BinaryBuilderReader(this, pos), pos); + + objMap.put(pos, res); + } + + pos += readInt(GridBinaryMarshaller.TOTAL_LEN_POS); + + return res; + } + + case GridBinaryMarshaller.BYTE: + return arr[pos++]; + + case GridBinaryMarshaller.SHORT: { + Object res = BinaryPrimitives.readShort(arr, pos); + pos += 2; + return res; + } + + case GridBinaryMarshaller.INT: + return readInt(); + + case GridBinaryMarshaller.LONG: + plainLazyValLen = 8; + + break; + + case GridBinaryMarshaller.FLOAT: + plainLazyValLen = 4; + + break; + + case GridBinaryMarshaller.DOUBLE: + plainLazyValLen = 8; + + break; + + case GridBinaryMarshaller.CHAR: + plainLazyValLen = 2; + + break; + + case GridBinaryMarshaller.BOOLEAN: + return arr[pos++] != 0; + + case GridBinaryMarshaller.DECIMAL: + plainLazyValLen = /** scale */ 4 + /** mag len */ 4 + /** mag bytes count */ readInt(4); + + break; + + case GridBinaryMarshaller.STRING: + plainLazyValLen = 4 + readStringLength(); + + break; + + case GridBinaryMarshaller.UUID: + plainLazyValLen = 8 + 8; + + break; + + case GridBinaryMarshaller.DATE: + plainLazyValLen = 8; + + break; + + case GridBinaryMarshaller.TIMESTAMP: + plainLazyValLen = 8 + 4; + + break; + + case GridBinaryMarshaller.BYTE_ARR: + plainLazyValLen = 4 + readLength(); + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.SHORT_ARR: + plainLazyValLen = 4 + readLength() * 2; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.INT_ARR: + plainLazyValLen = 4 + readLength() * 4; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.LONG_ARR: + plainLazyValLen = 4 + readLength() * 8; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.FLOAT_ARR: + plainLazyValLen = 4 + readLength() * 4; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.DOUBLE_ARR: + plainLazyValLen = 4 + readLength() * 8; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.CHAR_ARR: + plainLazyValLen = 4 + readLength() * 2; + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.BOOLEAN_ARR: + plainLazyValLen = 4 + readLength(); + modifiableLazyVal = true; + + break; + + case GridBinaryMarshaller.OBJ_ARR: + return new BinaryObjectArrayLazyValue(this); + + case GridBinaryMarshaller.DATE_ARR: { + int size = readInt(); + + Date[] res = new Date[size]; + + for (int i = 0; i < res.length; i++) { + byte flag = arr[pos++]; + + if (flag == GridBinaryMarshaller.NULL) continue; + + if (flag != GridBinaryMarshaller.DATE) + throw new BinaryObjectException("Invalid flag value: " + flag); + + long time = BinaryPrimitives.readLong(arr, pos); + + pos += 8; + + res[i] = new Date(time); + } + + return res; + } + + case GridBinaryMarshaller.TIMESTAMP_ARR: { + int size = readInt(); + + Timestamp[] res = new Timestamp[size]; + + for (int i = 0; i < res.length; i++) { + byte flag = arr[pos++]; + + if (flag == GridBinaryMarshaller.NULL) + continue; + + if (flag != GridBinaryMarshaller.TIMESTAMP) + throw new BinaryObjectException("Invalid flag value: " + flag); + + long time = BinaryPrimitives.readLong(arr, pos); + + pos += 8; + + int nano = BinaryPrimitives.readInt(arr, pos); + + pos += 4; + + Timestamp ts = new Timestamp(time); + + ts.setNanos(ts.getNanos() + nano); + + res[i] = ts; + } + + return res; + } + + case GridBinaryMarshaller.UUID_ARR: + case GridBinaryMarshaller.STRING_ARR: + case GridBinaryMarshaller.DECIMAL_ARR: { + int size = readInt(); + + for (int i = 0; i < size; i++) { + byte flag = arr[pos++]; + + if (flag == GridBinaryMarshaller.UUID) + pos += 8 + 8; + else if (flag == GridBinaryMarshaller.STRING) + pos += 4 + readStringLength(); + else if (flag == GridBinaryMarshaller.DECIMAL) { + pos += 4; // scale value + pos += 4 + readLength(); + } + else + assert flag == GridBinaryMarshaller.NULL; + } + + return new BinaryModifiableLazyValue(this, valPos, pos - valPos); + } + + case GridBinaryMarshaller.COL: { + int size = readInt(); + byte colType = arr[pos++]; + + switch (colType) { + case GridBinaryMarshaller.USER_COL: + case GridBinaryMarshaller.ARR_LIST: + return new BinaryLazyArrayList(this, size); + + case GridBinaryMarshaller.LINKED_LIST: + return new BinaryLazyLinkedList(this, size); + + case GridBinaryMarshaller.HASH_SET: + case GridBinaryMarshaller.LINKED_HASH_SET: + return new BinaryLazySet(this, size); + } + + throw new BinaryObjectException("Unknown collection type: " + colType); + } + + case GridBinaryMarshaller.MAP: + return BinaryLazyMap.parseMap(this); + + case GridBinaryMarshaller.ENUM: + return new BinaryBuilderEnum(this); + + case GridBinaryMarshaller.ENUM_ARR: + return new BinaryEnumArrayLazyValue(this); + + case GridBinaryMarshaller.PORTABLE_OBJ: { + int size = readInt(); + + pos += size; + + int start = readInt(); + + BinaryObjectImpl portableObj = new BinaryObjectImpl(ctx, arr, + pos - 4 - size + start); + + return new BinaryPlainBinaryObject(portableObj); + } + + default: + throw new BinaryObjectException("Invalid flag value: " + type); + } + + BinaryAbstractLazyValue res; + + if (modifiableLazyVal) + res = new BinaryModifiableLazyValue(this, valPos, 1 + plainLazyValLen); + else + res = new BinaryPlainLazyValue(this, valPos, 1 + plainLazyValLen); + + pos += plainLazyValLen; + + return res; + } + + /** + * @return Array. + */ + public byte[] array() { + return arr; + } + + /** + * @return Position of reader. + */ + public int position() { + return pos; + } + + /** + * @param pos New pos. + */ + public void position(int pos) { + this.pos = pos; + } + + /** + * @param n Number of bytes to skip. + */ + public void skip(int n) { + pos += n; + } + + /** + * @return Reader. + */ + BinaryReaderExImpl reader() { + return reader; + } + + /** + * + */ + private class LazyCollection implements BinaryLazyValue { + /** */ + private final int valOff; + + /** */ + private Object col; + + /** + * @param valOff Value. + */ + protected LazyCollection(int valOff) { + this.valOff = valOff; + } + + /** + * @return Object. + */ + private Object wrappedCollection() { + if (col == null) { + position(valOff); + + col = parseValue(); + } + + return col; + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + ctx.writeValue(writer, wrappedCollection()); + } + + /** {@inheritDoc} */ + @Override public Object value() { + return BinaryUtils.unwrapLazy(wrappedCollection()); + } + } +}
http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializationAware.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializationAware.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializationAware.java new file mode 100644 index 0000000..7710ba3 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializationAware.java @@ -0,0 +1,31 @@ +/* + * 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.builder; + +import org.apache.ignite.internal.binary.BinaryWriterExImpl; + +/** + * + */ +interface BinaryBuilderSerializationAware { + /** + * @param writer Writer. + * @param ctx Context. + */ + public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx); +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java new file mode 100644 index 0000000..458602d --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderSerializer.java @@ -0,0 +1,217 @@ +/* + * 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.builder; + +import org.apache.ignite.binary.BinaryObject; +import org.apache.ignite.internal.binary.BinaryMetadata; +import org.apache.ignite.internal.binary.BinaryObjectExImpl; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryContext; +import org.apache.ignite.internal.binary.BinaryUtils; + +import java.util.Collection; +import java.util.IdentityHashMap; +import java.util.Map; + +/** + * + */ +class BinaryBuilderSerializer { + /** */ + private final Map<BinaryObjectBuilderImpl, Integer> objToPos = new IdentityHashMap<>(); + + /** */ + private Map<BinaryObject, BinaryObjectBuilderImpl> portableObjToWrapper; + + /** + * @param obj Mutable object. + * @param posInResArr Object position in the array. + */ + public void registerObjectWriting(BinaryObjectBuilderImpl obj, int posInResArr) { + objToPos.put(obj, posInResArr); + } + + /** + * @param writer Writer. + * @param val Value. + */ + public void writeValue(BinaryWriterExImpl writer, Object val) { + if (val == null) { + writer.writeByte(GridBinaryMarshaller.NULL); + + return; + } + + if (val instanceof BinaryBuilderSerializationAware) { + ((BinaryBuilderSerializationAware)val).writeTo(writer, this); + + return; + } + + if (val instanceof BinaryObjectExImpl) { + if (portableObjToWrapper == null) + portableObjToWrapper = new IdentityHashMap<>(); + + BinaryObjectBuilderImpl wrapper = portableObjToWrapper.get(val); + + if (wrapper == null) { + wrapper = BinaryObjectBuilderImpl.wrap((BinaryObject)val); + + portableObjToWrapper.put((BinaryObject)val, wrapper); + } + + val = wrapper; + } + + if (val instanceof BinaryObjectBuilderImpl) { + BinaryObjectBuilderImpl obj = (BinaryObjectBuilderImpl)val; + + Integer posInResArr = objToPos.get(obj); + + if (posInResArr == null) { + objToPos.put(obj, writer.out().position()); + + obj.serializeTo(writer.newWriter(obj.typeId()), this); + } + else { + int handle = writer.out().position() - posInResArr; + + writer.writeByte(GridBinaryMarshaller.HANDLE); + writer.writeInt(handle); + } + + return; + } + + if (val.getClass().isEnum()) { + String typeName = BinaryContext.typeName(val.getClass().getName()); + int typeId = writer.context().typeId(typeName); + + BinaryMetadata meta = new BinaryMetadata(typeId, typeName, null, null, null, true); + writer.context().updateMetadata(typeId, meta); + + writer.writeByte(GridBinaryMarshaller.ENUM); + writer.writeInt(typeId); + writer.writeInt(((Enum)val).ordinal()); + + return; + } + + if (val instanceof Collection) { + Collection<?> c = (Collection<?>)val; + + writer.writeByte(GridBinaryMarshaller.COL); + writer.writeInt(c.size()); + + byte colType = writer.context().collectionType(c.getClass()); + + writer.writeByte(colType); + + for (Object obj : c) + writeValue(writer, obj); + + return; + } + + if (val instanceof Map) { + Map<?, ?> map = (Map<?, ?>)val; + + writer.writeByte(GridBinaryMarshaller.MAP); + writer.writeInt(map.size()); + + writer.writeByte(writer.context().mapType(map.getClass())); + + for (Map.Entry<?, ?> entry : map.entrySet()) { + writeValue(writer, entry.getKey()); + writeValue(writer, entry.getValue()); + } + + return; + } + + Byte flag = BinaryUtils.PLAIN_CLASS_TO_FLAG.get(val.getClass()); + + if (flag != null) { + BinaryUtils.writePlainObject(writer, val); + + return; + } + + if (val instanceof Object[]) { + int compTypeId = writer.context().typeId(((Object[])val).getClass().getComponentType().getName()); + + if (val instanceof BinaryBuilderEnum[]) { + writeArray(writer, GridBinaryMarshaller.ENUM_ARR, (Object[])val, compTypeId); + + return; + } + + if (((Object[])val).getClass().getComponentType().isEnum()) { + Enum[] enumArr = (Enum[])val; + + writer.writeByte(GridBinaryMarshaller.ENUM_ARR); + writer.writeInt(compTypeId); + writer.writeInt(enumArr.length); + + for (Enum anEnum : enumArr) + writeValue(writer, anEnum); + + return; + } + + writeArray(writer, GridBinaryMarshaller.OBJ_ARR, (Object[])val, compTypeId); + + return; + } + + writer.doWriteObject(val); + } + + /** + * @param writer Writer. + * @param elementType Element type. + * @param arr The array. + * @param compTypeId Component type ID. + */ + public void writeArray(BinaryWriterExImpl writer, byte elementType, Object[] arr, int compTypeId) { + writer.writeByte(elementType); + writer.writeInt(compTypeId); + writer.writeInt(arr.length); + + for (Object obj : arr) + writeValue(writer, obj); + } + + /** + * @param writer Writer. + * @param elementType Element type. + * @param arr The array. + * @param clsName Component class name. + */ + public void writeArray(BinaryWriterExImpl writer, byte elementType, Object[] arr, String clsName) { + writer.writeByte(elementType); + writer.writeInt(GridBinaryMarshaller.UNREGISTERED_TYPE_ID); + writer.writeString(clsName); + writer.writeInt(arr.length); + + for (Object obj : arr) + writeValue(writer, obj); + } + +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryEnumArrayLazyValue.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryEnumArrayLazyValue.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryEnumArrayLazyValue.java new file mode 100644 index 0000000..db55050 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryEnumArrayLazyValue.java @@ -0,0 +1,113 @@ +/* + * 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.builder; + +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.util.typedef.internal.U; +import org.apache.ignite.binary.BinaryObjectException; +import org.apache.ignite.binary.BinaryInvalidTypeException; + +/** + * + */ +class BinaryEnumArrayLazyValue extends BinaryAbstractLazyValue { + /** */ + private final int len; + + /** */ + private final int compTypeId; + + /** */ + private final String clsName; + + /** + * @param reader Reader. + */ + protected BinaryEnumArrayLazyValue(BinaryBuilderReader reader) { + super(reader, reader.position() - 1); + + int typeId = reader.readInt(); + + if (typeId == GridBinaryMarshaller.UNREGISTERED_TYPE_ID) { + clsName = reader.readString(); + + Class cls; + + try { + cls = U.forName(reader.readString(), reader.portableContext().configuration().getClassLoader()); + } + catch (ClassNotFoundException e) { + throw new BinaryInvalidTypeException("Failed to load the class: " + clsName, e); + } + + compTypeId = reader.portableContext().descriptorForClass(cls, true).typeId(); + } + else { + compTypeId = typeId; + clsName = null; + } + + int size = reader.readInt(); + + for (int i = 0; i < size; i++) + reader.skipValue(); + + len = reader.position() - valOff; + } + + /** {@inheritDoc} */ + @Override protected Object init() { + reader.position(valOff + 1); + + //skipping component type id + reader.readInt(); + + int size = reader.readInt(); + + BinaryBuilderEnum[] res = new BinaryBuilderEnum[size]; + + for (int i = 0; i < size; i++) { + byte flag = reader.readByte(); + + if (flag == GridBinaryMarshaller.NULL) + continue; + + if (flag != GridBinaryMarshaller.ENUM) + throw new BinaryObjectException("Invalid flag value: " + flag); + + res[i] = new BinaryBuilderEnum(reader); + } + + return res; + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (val != null) { + if (clsName != null) + ctx.writeArray(writer, GridBinaryMarshaller.ENUM_ARR, (Object[])val, clsName); + else + ctx.writeArray(writer, GridBinaryMarshaller.ENUM_ARR, (Object[])val, compTypeId); + + return; + } + + writer.write(reader.array(), valOff, len); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyArrayList.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyArrayList.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyArrayList.java new file mode 100644 index 0000000..3627b1d --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyArrayList.java @@ -0,0 +1,167 @@ +/* + * 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.builder; + +import java.util.AbstractList; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryUtils; + +/** + * + */ +class BinaryLazyArrayList extends AbstractList<Object> implements BinaryBuilderSerializationAware { + /** */ + private final BinaryBuilderReader reader; + + /** */ + private final int off; + + /** */ + private List<Object> delegate; + + /** + * @param reader Reader. + * @param size Size, + */ + BinaryLazyArrayList(BinaryBuilderReader reader, int size) { + this.reader = reader; + off = reader.position() - 1/* flag */ - 4/* size */ - 1/* col type */; + + assert size >= 0; + + for (int i = 0; i < size; i++) + reader.skipValue(); + } + + /** + * + */ + private void ensureDelegateInit() { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + reader.position(off + 1/* flag */ + 4/* size */ + 1/* col type */); + + delegate = new ArrayList<>(size); + + for (int i = 0; i < size; i++) + delegate.add(reader.parseValue()); + } + } + + /** {@inheritDoc} */ + @Override public Object get(int idx) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.get(idx)); + } + + /** {@inheritDoc} */ + @Override public boolean add(Object o) { + ensureDelegateInit(); + + return delegate.add(o); + } + + /** {@inheritDoc} */ + @Override public void add(int idx, Object element) { + ensureDelegateInit(); + + delegate.add(idx, element); + } + + /** {@inheritDoc} */ + @Override public Object set(int idx, Object element) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.set(idx, element)); + } + + /** {@inheritDoc} */ + @Override public Object remove(int idx) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.remove(idx)); + } + + /** {@inheritDoc} */ + @Override public void clear() { + if (delegate == null) + delegate = new ArrayList<>(); + else + delegate.clear(); + } + + /** {@inheritDoc} */ + @Override public boolean addAll(int idx, Collection<?> c) { + return delegate.addAll(idx, c); + } + + /** {@inheritDoc} */ + @Override protected void removeRange(int fromIdx, int toIdx) { + ensureDelegateInit(); + + delegate.subList(fromIdx, toIdx).clear(); + } + + /** {@inheritDoc} */ + @Override public int size() { + if (delegate == null) + return reader.readIntPositioned(off + 1); + + return delegate.size(); + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + int hdrSize = 1 /* flag */ + 4 /* size */ + 1 /* col type */; + + writer.write(reader.array(), off, hdrSize); + + reader.position(off + hdrSize); + + for (int i = 0; i < size; i++) { + Object o = reader.parseValue(); + + ctx.writeValue(writer, o); + } + } + else { + writer.writeByte(GridBinaryMarshaller.COL); + writer.writeInt(delegate.size()); + + byte colType = reader.array()[off + 1 /* flag */ + 4 /* size */]; + writer.writeByte(colType); + + int oldPos = reader.position(); + + for (Object o : delegate) + ctx.writeValue(writer, o); + + // PortableBuilderImpl might have been written. It could override reader's position. + reader.position(oldPos); + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyLinkedList.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyLinkedList.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyLinkedList.java new file mode 100644 index 0000000..1813fcc --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyLinkedList.java @@ -0,0 +1,218 @@ +/* + * 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.builder; + +import java.util.AbstractList; +import java.util.Collection; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryUtils; + +/** + * + */ +class BinaryLazyLinkedList extends AbstractList<Object> implements BinaryBuilderSerializationAware { + /** */ + private final BinaryBuilderReader reader; + + /** */ + private final int off; + + /** */ + private List<Object> delegate; + + /** + * @param reader Reader. + * @param size Size, + */ + BinaryLazyLinkedList(BinaryBuilderReader reader, int size) { + this.reader = reader; + off = reader.position() - 1/* flag */ - 4/* size */ - 1/* col type */; + + assert size >= 0; + + for (int i = 0; i < size; i++) + reader.skipValue(); + } + + /** + * + */ + private void ensureDelegateInit() { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + reader.position(off + 1/* flag */ + 4/* size */ + 1/* col type */); + + delegate = new LinkedList<>(); + + for (int i = 0; i < size; i++) + delegate.add(reader.parseValue()); + } + } + + /** {@inheritDoc} */ + @Override public Object get(int idx) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.get(idx)); + } + + /** {@inheritDoc} */ + @Override public boolean add(Object o) { + ensureDelegateInit(); + + return delegate.add(o); + } + + /** {@inheritDoc} */ + @Override public void add(int idx, Object element) { + ensureDelegateInit(); + + delegate.add(idx, element); + } + + /** {@inheritDoc} */ + @Override public Object set(int idx, Object element) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.set(idx, element)); + } + + /** {@inheritDoc} */ + @Override public Object remove(int idx) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.remove(idx)); + } + + /** {@inheritDoc} */ + @Override public void clear() { + if (delegate == null) + delegate = new LinkedList<>(); + else + delegate.clear(); + } + + /** {@inheritDoc} */ + @Override public boolean addAll(int idx, Collection<?> c) { + ensureDelegateInit(); + + return delegate.addAll(idx, c); + } + + /** {@inheritDoc} */ + @Override protected void removeRange(int fromIdx, int toIdx) { + ensureDelegateInit(); + + delegate.subList(fromIdx, toIdx).clear(); + } + + /** {@inheritDoc} */ + @Override public int size() { + if (delegate == null) + return reader.readIntPositioned(off + 1); + + return delegate.size(); + } + + /** {@inheritDoc} */ + @Override public ListIterator<Object> listIterator(final int idx) { + ensureDelegateInit(); + + return new ListIterator<Object>() { + /** */ + private final ListIterator<Object> delegate = BinaryLazyLinkedList.super.listIterator(idx); + + @Override public boolean hasNext() { + return delegate.hasNext(); + } + + @Override public Object next() { + return BinaryUtils.unwrapLazy(delegate.next()); + } + + @Override public boolean hasPrevious() { + return delegate.hasPrevious(); + } + + @Override public Object previous() { + return BinaryUtils.unwrapLazy(delegate.previous()); + } + + @Override public int nextIndex() { + return delegate.nextIndex(); + } + + @Override public int previousIndex() { + return delegate.previousIndex(); + } + + @Override public void remove() { + delegate.remove(); + } + + @Override public void set(Object o) { + delegate.set(o); + } + + @Override public void add(Object o) { + delegate.add(o); + } + }; + } + + /** {@inheritDoc} */ + @Override public Iterator<Object> iterator() { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazyIterator(super.iterator()); + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + int hdrSize = 1 /* flag */ + 4 /* size */ + 1 /* col type */; + writer.write(reader.array(), off, hdrSize); + + reader.position(off + hdrSize); + + for (int i = 0; i < size; i++) { + Object o = reader.parseValue(); + + ctx.writeValue(writer, o); + } + } + else { + writer.writeByte(GridBinaryMarshaller.COL); + writer.writeInt(delegate.size()); + + byte colType = reader.array()[off + 1 /* flag */ + 4 /* size */]; + writer.writeByte(colType); + + for (Object o : delegate) + ctx.writeValue(writer, o); + } + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyMap.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyMap.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyMap.java new file mode 100644 index 0000000..c82ff7d --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyMap.java @@ -0,0 +1,221 @@ +/* + * 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.builder; + +import java.util.AbstractMap; +import java.util.AbstractSet; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; +import java.util.Set; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryUtils; +import org.jetbrains.annotations.Nullable; + +/** + * + */ +class BinaryLazyMap extends AbstractMap<Object, Object> implements BinaryBuilderSerializationAware { + /** */ + private final BinaryBuilderReader reader; + + /** */ + private final int off; + + /** */ + private Map<Object, Object> delegate; + + /** + * @param reader Reader. + * @param off Offset. + */ + private BinaryLazyMap(BinaryBuilderReader reader, int off) { + this.reader = reader; + this.off = off; + } + + /** + * @param reader Reader. + * @return PortableLazyMap. + */ + @Nullable public static BinaryLazyMap parseMap(BinaryBuilderReader reader) { + int off = reader.position() - 1; + + int size = reader.readInt(); + + reader.skip(1); // map type. + + for (int i = 0; i < size; i++) { + reader.skipValue(); // skip key + reader.skipValue(); // skip value + } + + return new BinaryLazyMap(reader, off); + } + + /** + * + */ + private void ensureDelegateInit() { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + reader.position(off + 1/* flag */ + 4/* size */ + 1/* col type */); + + delegate = new LinkedHashMap<>(); + + for (int i = 0; i < size; i++) + delegate.put(BinaryUtils.unwrapLazy(reader.parseValue()), reader.parseValue()); + } + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (delegate == null) { + int size = reader.readIntPositioned(off + 1); + + int hdrSize = 1 /* flag */ + 4 /* size */ + 1 /* col type */; + writer.write(reader.array(), off, hdrSize); + + reader.position(off + hdrSize); + + for (int i = 0; i < size; i++) { + ctx.writeValue(writer, reader.parseValue()); // key + ctx.writeValue(writer, reader.parseValue()); // value + } + } + else { + writer.writeByte(GridBinaryMarshaller.MAP); + writer.writeInt(delegate.size()); + + byte colType = reader.array()[off + 1 /* flag */ + 4 /* size */]; + + writer.writeByte(colType); + + for (Entry<Object, Object> entry : delegate.entrySet()) { + ctx.writeValue(writer, entry.getKey()); + ctx.writeValue(writer, entry.getValue()); + } + } + } + + /** {@inheritDoc} */ + @Override public int size() { + if (delegate == null) + return reader.readIntPositioned(off + 1); + + return delegate.size(); + } + + /** {@inheritDoc} */ + @Override public boolean containsKey(Object key) { + ensureDelegateInit(); + + return delegate.containsKey(key); + } + + /** {@inheritDoc} */ + @Override public boolean containsValue(Object val) { + return values().contains(val); + } + + /** {@inheritDoc} */ + @Override public Set<Object> keySet() { + ensureDelegateInit(); + + return delegate.keySet(); + } + + /** {@inheritDoc} */ + @Override public void clear() { + if (delegate == null) + delegate = new LinkedHashMap<>(); + else + delegate.clear(); + } + + /** {@inheritDoc} */ + @Override public Object get(Object key) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.get(key)); + } + + /** {@inheritDoc} */ + @Override public Object put(Object key, Object val) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.put(key, val)); + } + + /** {@inheritDoc} */ + @Override public Object remove(Object key) { + ensureDelegateInit(); + + return BinaryUtils.unwrapLazy(delegate.remove(key)); + } + + /** {@inheritDoc} */ + @Override public Set<Entry<Object, Object>> entrySet() { + ensureDelegateInit(); + + return new AbstractSet<Entry<Object, Object>>() { + @Override public boolean contains(Object o) { + throw new UnsupportedOperationException(); + } + + @Override public Iterator<Entry<Object, Object>> iterator() { + return new Iterator<Entry<Object, Object>>() { + /** */ + private final Iterator<Entry<Object, Object>> itr = delegate.entrySet().iterator(); + + @Override public boolean hasNext() { + return itr.hasNext(); + } + + @Override public Entry<Object, Object> next() { + Entry<Object, Object> res = itr.next(); + + final Object val = res.getValue(); + + if (val instanceof BinaryLazyValue) { + return new SimpleEntry<Object, Object>(res.getKey(), val) { + private static final long serialVersionUID = 0L; + + @Override public Object getValue() { + return ((BinaryLazyValue)val).value(); + } + }; + } + + return res; + } + + @Override public void remove() { + itr.remove(); + } + }; + } + + @Override public int size() { + return delegate.size(); + } + }; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazySet.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazySet.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazySet.java new file mode 100644 index 0000000..6be4c76 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazySet.java @@ -0,0 +1,92 @@ +/* + * 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.builder; + +import java.util.Collection; +import java.util.Set; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryUtils; +import org.apache.ignite.internal.util.typedef.internal.U; + +/** + * + */ +class BinaryLazySet extends BinaryAbstractLazyValue { + /** */ + private final int off; + + /** + * @param reader Reader. + * @param size Size. + */ + BinaryLazySet(BinaryBuilderReader reader, int size) { + super(reader, reader.position() - 1); + + off = reader.position() - 1/* flag */ - 4/* size */ - 1/* col type */; + + assert size >= 0; + + for (int i = 0; i < size; i++) + reader.skipValue(); + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (val == null) { + int size = reader.readIntPositioned(off + 1); + + int hdrSize = 1 /* flag */ + 4 /* size */ + 1 /* col type */; + writer.write(reader.array(), off, hdrSize); + + reader.position(off + hdrSize); + + for (int i = 0; i < size; i++) { + Object o = reader.parseValue(); + + ctx.writeValue(writer, o); + } + } + else { + Collection<Object> c = (Collection<Object>)val; + + writer.writeByte(GridBinaryMarshaller.COL); + writer.writeInt(c.size()); + + byte colType = reader.array()[off + 1 /* flag */ + 4 /* size */]; + writer.writeByte(colType); + + for (Object o : c) + ctx.writeValue(writer, o); + } + } + + /** {@inheritDoc} */ + @Override protected Object init() { + int size = reader.readIntPositioned(off + 1); + + reader.position(off + 1/* flag */ + 4/* size */ + 1/* col type */); + + Set<Object> res = U.newLinkedHashSet(size); + + for (int i = 0; i < size; i++) + res.add(BinaryUtils.unwrapLazy(reader.parseValue())); + + return res; + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyValue.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyValue.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyValue.java new file mode 100644 index 0000000..f9da84b --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryLazyValue.java @@ -0,0 +1,28 @@ +/* + * 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.builder; + +/** + * + */ +public interface BinaryLazyValue extends BinaryBuilderSerializationAware { + /** + * @return Value. + */ + public Object value(); +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryModifiableLazyValue.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryModifiableLazyValue.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryModifiableLazyValue.java new file mode 100644 index 0000000..070abf3 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryModifiableLazyValue.java @@ -0,0 +1,52 @@ +/* + * 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.builder; + +import org.apache.ignite.internal.binary.BinaryWriterExImpl; + +/** + * + */ +public class BinaryModifiableLazyValue extends BinaryAbstractLazyValue { + /** */ + protected final int len; + + /** + * @param reader + * @param valOff + * @param len + */ + public BinaryModifiableLazyValue(BinaryBuilderReader reader, int valOff, int len) { + super(reader, valOff); + + this.len = len; + } + + /** {@inheritDoc} */ + @Override protected Object init() { + return reader.reader().unmarshal(valOff); + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (val == null) + writer.write(reader.array(), valOff, len); + else + writer.writeObject(val); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectArrayLazyValue.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectArrayLazyValue.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectArrayLazyValue.java new file mode 100644 index 0000000..05713b4 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectArrayLazyValue.java @@ -0,0 +1,90 @@ +/* + * 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.builder; + +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.internal.util.typedef.internal.U; +import org.apache.ignite.binary.BinaryInvalidTypeException; + +/** + * + */ +class BinaryObjectArrayLazyValue extends BinaryAbstractLazyValue { + /** */ + private Object[] lazyValsArr; + + /** */ + private int compTypeId; + + /** */ + private String clsName; + + /** + * @param reader Reader. + */ + protected BinaryObjectArrayLazyValue(BinaryBuilderReader reader) { + super(reader, reader.position() - 1); + + int typeId = reader.readInt(); + + if (typeId == GridBinaryMarshaller.UNREGISTERED_TYPE_ID) { + clsName = reader.readString(); + + Class cls; + + try { + cls = U.forName(reader.readString(), reader.portableContext().configuration().getClassLoader()); + } + catch (ClassNotFoundException e) { + throw new BinaryInvalidTypeException("Failed to load the class: " + clsName, e); + } + + compTypeId = reader.portableContext().descriptorForClass(cls, true).typeId(); + } + else { + compTypeId = typeId; + clsName = null; + } + + int size = reader.readInt(); + + lazyValsArr = new Object[size]; + + for (int i = 0; i < size; i++) + lazyValsArr[i] = reader.parseValue(); + } + + /** {@inheritDoc} */ + @Override protected Object init() { + for (int i = 0; i < lazyValsArr.length; i++) { + if (lazyValsArr[i] instanceof BinaryLazyValue) + lazyValsArr[i] = ((BinaryLazyValue)lazyValsArr[i]).value(); + } + + return lazyValsArr; + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + if (clsName == null) + ctx.writeArray(writer, GridBinaryMarshaller.OBJ_ARR, lazyValsArr, compTypeId); + else + ctx.writeArray(writer, GridBinaryMarshaller.OBJ_ARR, lazyValsArr, clsName); + } +} http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java index f1d4185..5e60a20 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryObjectBuilderImpl.java @@ -25,19 +25,12 @@ import org.apache.ignite.binary.BinaryType; import org.apache.ignite.internal.binary.BinaryMetadata; import org.apache.ignite.internal.binary.BinaryObjectImpl; import org.apache.ignite.internal.binary.BinaryWriterExImpl; -import org.apache.ignite.internal.binary.GridPortableMarshaller; -import org.apache.ignite.internal.binary.PortableContext; -import org.apache.ignite.internal.binary.PortableSchema; -import org.apache.ignite.internal.binary.PortableSchemaRegistry; -import org.apache.ignite.internal.binary.BinaryMetadata; -import org.apache.ignite.internal.binary.BinaryObjectImpl; +import org.apache.ignite.internal.binary.GridBinaryMarshaller; +import org.apache.ignite.internal.binary.BinaryContext; +import org.apache.ignite.internal.binary.BinarySchema; +import org.apache.ignite.internal.binary.BinarySchemaRegistry; import org.apache.ignite.internal.binary.BinaryObjectOffheapImpl; -import org.apache.ignite.internal.binary.BinaryWriterExImpl; -import org.apache.ignite.internal.binary.GridPortableMarshaller; -import org.apache.ignite.internal.binary.PortableContext; -import org.apache.ignite.internal.binary.PortableSchema; -import org.apache.ignite.internal.binary.PortableSchemaRegistry; -import org.apache.ignite.internal.binary.PortableUtils; +import org.apache.ignite.internal.binary.BinaryUtils; import org.apache.ignite.internal.util.typedef.F; import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.lang.IgniteBiTuple; @@ -49,13 +42,6 @@ import java.util.LinkedHashMap; import java.util.Map; import java.util.Set; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.DFLT_HDR_LEN; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.FLAGS_POS; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.HASH_CODE_POS; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.PROTO_VER_POS; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.TYPE_ID_POS; -import static org.apache.ignite.internal.binary.GridPortableMarshaller.UNREGISTERED_TYPE_ID; - /** * */ @@ -64,7 +50,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { private static final Object REMOVED_FIELD_MARKER = new Object(); /** */ - private final PortableContext ctx; + private final BinaryContext ctx; /** */ private final int typeId; @@ -94,7 +80,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { private final int hdrLen; /** Context of PortableObject reading process. Or {@code null} if object is not created from PortableObject. */ - private final PortableBuilderReader reader; + private final BinaryBuilderReader reader; /** */ private int hashCode; @@ -103,8 +89,8 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { * @param clsName Class name. * @param ctx Portable context. */ - public BinaryObjectBuilderImpl(PortableContext ctx, String clsName) { - this(ctx, ctx.typeId(clsName), PortableContext.typeName(clsName)); + public BinaryObjectBuilderImpl(BinaryContext ctx, String clsName) { + this(ctx, ctx.typeId(clsName), BinaryContext.typeName(clsName)); } /** @@ -112,7 +98,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { * @param ctx Context. * @param typeId Type id. */ - public BinaryObjectBuilderImpl(PortableContext ctx, int typeId, String typeName) { + public BinaryObjectBuilderImpl(BinaryContext ctx, int typeId, String typeName) { this.typeId = typeId; this.typeName = typeName; this.ctx = ctx; @@ -120,7 +106,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { start = -1; flags = -1; reader = null; - hdrLen = GridPortableMarshaller.DFLT_HDR_LEN; + hdrLen = GridBinaryMarshaller.DFLT_HDR_LEN; readCache = Collections.emptyMap(); } @@ -129,7 +115,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { * @param obj Object to wrap. */ public BinaryObjectBuilderImpl(BinaryObjectImpl obj) { - this(new PortableBuilderReader(obj), obj.start()); + this(new BinaryBuilderReader(obj), obj.start()); reader.registerObject(this); } @@ -138,23 +124,23 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { * @param reader ctx * @param start Start. */ - BinaryObjectBuilderImpl(PortableBuilderReader reader, int start) { + BinaryObjectBuilderImpl(BinaryBuilderReader reader, int start) { this.reader = reader; this.start = start; - this.flags = reader.readShortPositioned(start + GridPortableMarshaller.FLAGS_POS); + this.flags = reader.readShortPositioned(start + GridBinaryMarshaller.FLAGS_POS); - byte ver = reader.readBytePositioned(start + GridPortableMarshaller.PROTO_VER_POS); + byte ver = reader.readBytePositioned(start + GridBinaryMarshaller.PROTO_VER_POS); - PortableUtils.checkProtocolVersion(ver); + BinaryUtils.checkProtocolVersion(ver); - int typeId = reader.readIntPositioned(start + GridPortableMarshaller.TYPE_ID_POS); + int typeId = reader.readIntPositioned(start + GridBinaryMarshaller.TYPE_ID_POS); ctx = reader.portableContext(); - hashCode = reader.readIntPositioned(start + GridPortableMarshaller.HASH_CODE_POS); + hashCode = reader.readIntPositioned(start + GridBinaryMarshaller.HASH_CODE_POS); - if (typeId == GridPortableMarshaller.UNREGISTERED_TYPE_ID) { + if (typeId == GridBinaryMarshaller.UNREGISTERED_TYPE_ID) { int mark = reader.position(); - reader.position(start + GridPortableMarshaller.DFLT_HDR_LEN); + reader.position(start + GridBinaryMarshaller.DFLT_HDR_LEN); clsNameToWrite = reader.readString(); @@ -177,7 +163,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { } else { this.typeId = typeId; - hdrLen = GridPortableMarshaller.DFLT_HDR_LEN; + hdrLen = GridBinaryMarshaller.DFLT_HDR_LEN; } } @@ -186,7 +172,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { try (BinaryWriterExImpl writer = new BinaryWriterExImpl(ctx)) { writer.typeId(typeId); - PortableBuilderSerializer serializationCtx = new PortableBuilderSerializer(); + BinaryBuilderSerializer serializationCtx = new BinaryBuilderSerializer(); serializationCtx.registerObjectWriting(this, 0); @@ -202,14 +188,14 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { * @param writer Writer. * @param serializer Serializer. */ - void serializeTo(BinaryWriterExImpl writer, PortableBuilderSerializer serializer) { + void serializeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer serializer) { try { writer.preWrite(registeredType ? null : clsNameToWrite); Set<Integer> remainsFlds = null; if (reader != null) { - PortableSchema schema = reader.schema(); + BinarySchema schema = reader.schema(); Map<Integer, Object> assignedFldsById; @@ -228,16 +214,16 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { assignedFldsById = Collections.emptyMap(); // Get footer details. - int fieldIdLen = PortableUtils.fieldIdLength(flags); - int fieldOffsetLen = PortableUtils.fieldOffsetLength(flags); + int fieldIdLen = BinaryUtils.fieldIdLength(flags); + int fieldOffsetLen = BinaryUtils.fieldOffsetLength(flags); - IgniteBiTuple<Integer, Integer> footer = PortableUtils.footerAbsolute(reader, start); + IgniteBiTuple<Integer, Integer> footer = BinaryUtils.footerAbsolute(reader, start); int footerPos = footer.get1(); int footerEnd = footer.get2(); // Get raw position. - int rawPos = PortableUtils.rawOffsetAbsolute(reader, start); + int rawPos = BinaryUtils.rawOffsetAbsolute(reader, start); // Position reader on data. reader.position(start + hdrLen); @@ -265,7 +251,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { else { int type = fieldLen != 0 ? reader.readByte(0) : 0; - if (fieldLen != 0 && !PortableUtils.isPlainArrayType(type) && PortableUtils.isPlainType(type)) { + if (fieldLen != 0 && !BinaryUtils.isPlainArrayType(type) && BinaryUtils.isPlainType(type)) { writer.writeFieldId(fieldId); writer.write(reader.array(), reader.position(), fieldLen); @@ -321,26 +307,26 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { int newFldTypeId; - if (val instanceof PortableValueWithType) { - newFldTypeId = ((PortableValueWithType)val).typeId(); + if (val instanceof BinaryValueWithType) { + newFldTypeId = ((BinaryValueWithType)val).typeId(); - if (newFldTypeId == GridPortableMarshaller.OBJ && ((PortableValueWithType)val).value() == null) + if (newFldTypeId == GridBinaryMarshaller.OBJ && ((BinaryValueWithType)val).value() == null) nullObjField = true; } else - newFldTypeId = PortableUtils.typeByClass(val.getClass()); + newFldTypeId = BinaryUtils.typeByClass(val.getClass()); - String newFldTypeName = PortableUtils.fieldTypeName(newFldTypeId); + String newFldTypeName = BinaryUtils.fieldTypeName(newFldTypeId); if (oldFldTypeName == null) { // It's a new field, we have to add it to metadata. if (fieldsMeta == null) fieldsMeta = new HashMap<>(); - fieldsMeta.put(name, PortableUtils.fieldTypeId(newFldTypeName)); + fieldsMeta.put(name, BinaryUtils.fieldTypeId(newFldTypeName)); } else if (!nullObjField) { - String objTypeName = PortableUtils.fieldTypeName(GridPortableMarshaller.OBJ); + String objTypeName = BinaryUtils.fieldTypeName(GridBinaryMarshaller.OBJ); if (!objTypeName.equals(oldFldTypeName) && !oldFldTypeName.equals(newFldTypeName)) { throw new BinaryObjectException( @@ -357,8 +343,8 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { if (reader != null) { // Write raw data if any. - int rawOff = PortableUtils.rawOffsetAbsolute(reader, start); - int footerStart = PortableUtils.footerStartAbsolute(reader, start); + int rawOff = BinaryUtils.rawOffsetAbsolute(reader, start); + int footerStart = BinaryUtils.footerStartAbsolute(reader, start); if (rawOff < footerStart) { writer.rawWriter(); @@ -367,7 +353,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { } // Shift reader to the end of the object. - reader.position(start + PortableUtils.length(reader, start)); + reader.position(start + BinaryUtils.length(reader, start)); } writer.postWrite(true, registeredType, hashCode); @@ -375,7 +361,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { // Update metadata if needed. int schemaId = writer.schemaId(); - PortableSchemaRegistry schemaReg = ctx.schemaRegistry(typeId); + BinarySchemaRegistry schemaReg = ctx.schemaRegistry(typeId); if (schemaReg.schema(schemaId) == null) { String typeName = this.typeName; @@ -386,7 +372,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { typeName = meta.typeName(); } - PortableSchema curSchema = writer.currentSchema(); + BinarySchema curSchema = writer.currentSchema(); ctx.updateMetadata(typeId, new BinaryMetadata(typeId, typeName, fieldsMeta, ctx.affinityKeyFieldName(typeId), Collections.singleton(curSchema), false)); @@ -419,7 +405,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { private IgniteBiTuple<Integer, Integer> fieldPositionAndLength(int footerPos, int footerEnd, int rawPos, int fieldIdLen, int fieldOffsetLen) { // Get field offset first. - int fieldOffset = PortableUtils.fieldOffsetRelative(reader, footerPos + fieldIdLen, fieldOffsetLen); + int fieldOffset = BinaryUtils.fieldOffsetRelative(reader, footerPos + fieldIdLen, fieldOffsetLen); int fieldPos = start + fieldOffset; // Get field length. @@ -430,7 +416,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { fieldLen = rawPos - fieldPos; else { // Field is somewhere in the middle, get difference with the next offset. - int nextFieldOffset = PortableUtils.fieldOffsetRelative(reader, + int nextFieldOffset = BinaryUtils.fieldOffsetRelative(reader, footerPos + fieldIdLen + fieldOffsetLen + fieldIdLen, fieldOffsetLen); fieldLen = nextFieldOffset - fieldOffset; @@ -446,19 +432,19 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { assert reader != null; if (readCache == null) { - int fieldIdLen = PortableUtils.fieldIdLength(flags); - int fieldOffsetLen = PortableUtils.fieldOffsetLength(flags); + int fieldIdLen = BinaryUtils.fieldIdLength(flags); + int fieldOffsetLen = BinaryUtils.fieldOffsetLength(flags); - PortableSchema schema = reader.schema(); + BinarySchema schema = reader.schema(); Map<Integer, Object> readCache = new HashMap<>(); - IgniteBiTuple<Integer, Integer> footer = PortableUtils.footerAbsolute(reader, start); + IgniteBiTuple<Integer, Integer> footer = BinaryUtils.footerAbsolute(reader, start); int footerPos = footer.get1(); int footerEnd = footer.get2(); - int rawPos = PortableUtils.rawOffsetAbsolute(reader, start); + int rawPos = BinaryUtils.rawOffsetAbsolute(reader, start); int idx = 0; @@ -499,20 +485,20 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { val = readCache.get(fldId); } - return (T)PortableUtils.unwrapLazy(val); + return (T)BinaryUtils.unwrapLazy(val); } /** {@inheritDoc} */ @Override public BinaryObjectBuilder setField(String name, Object val0) { - Object val = val0 == null ? new PortableValueWithType(PortableUtils.typeByClass(Object.class), null) : val0; + Object val = val0 == null ? new BinaryValueWithType(BinaryUtils.typeByClass(Object.class), null) : val0; if (assignedVals == null) assignedVals = new LinkedHashMap<>(); Object oldVal = assignedVals.put(name, val); - if (oldVal instanceof PortableValueWithType && val0 != null) { - ((PortableValueWithType)oldVal).value(val); + if (oldVal instanceof BinaryValueWithType && val0 != null) { + ((BinaryValueWithType)oldVal).value(val); assignedVals.put(name, oldVal); } @@ -525,7 +511,7 @@ public class BinaryObjectBuilderImpl implements BinaryObjectBuilder { if (assignedVals == null) assignedVals = new LinkedHashMap<>(); - assignedVals.put(name, new PortableValueWithType(PortableUtils.typeByClass(type), val)); + assignedVals.put(name, new BinaryValueWithType(BinaryUtils.typeByClass(type), val)); return this; } http://git-wip-us.apache.org/repos/asf/ignite/blob/71ad9cea/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryPlainBinaryObject.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryPlainBinaryObject.java b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryPlainBinaryObject.java new file mode 100644 index 0000000..5ac4e97 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryPlainBinaryObject.java @@ -0,0 +1,53 @@ +/* + * 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.builder; + +import org.apache.ignite.internal.binary.BinaryObjectImpl; +import org.apache.ignite.internal.binary.BinaryObjectOffheapImpl; +import org.apache.ignite.internal.binary.BinaryWriterExImpl; +import org.apache.ignite.binary.BinaryObject; + +/** + * + */ +public class BinaryPlainBinaryObject implements BinaryLazyValue { + /** */ + private final BinaryObject portableObj; + + /** + * @param portableObj Portable object. + */ + public BinaryPlainBinaryObject(BinaryObject portableObj) { + this.portableObj = portableObj; + } + + /** {@inheritDoc} */ + @Override public Object value() { + return portableObj; + } + + /** {@inheritDoc} */ + @Override public void writeTo(BinaryWriterExImpl writer, BinaryBuilderSerializer ctx) { + BinaryObject val = portableObj; + + if (val instanceof BinaryObjectOffheapImpl) + val = ((BinaryObjectOffheapImpl)val).heapCopy(); + + writer.doWritePortableObject((BinaryObjectImpl)val); + } +}
