http://git-wip-us.apache.org/repos/asf/ignite/blob/35b6d61f/modules/core/src/main/java/org/apache/ignite/internal/portable/IgniteObjectWriterExImpl.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/IgniteObjectWriterExImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/IgniteObjectWriterExImpl.java new file mode 100644 index 0000000..de2b810 --- /dev/null +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/IgniteObjectWriterExImpl.java @@ -0,0 +1,1892 @@ +/* + * 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.portable; + +import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.internal.portable.streams.PortableHeapOutputStream; +import org.apache.ignite.internal.portable.streams.PortableOutputStream; +import org.apache.ignite.internal.util.typedef.internal.A; +import org.apache.ignite.igniteobject.IgniteObjectException; +import org.apache.ignite.igniteobject.IgniteObjectRawWriter; +import org.apache.ignite.igniteobject.IgniteObjectWriter; +import org.jetbrains.annotations.Nullable; + +import java.io.IOException; +import java.io.ObjectOutput; +import java.lang.reflect.InvocationTargetException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Timestamp; +import java.util.Collection; +import java.util.Date; +import java.util.IdentityHashMap; +import java.util.Map; +import java.util.UUID; + +import static java.nio.charset.StandardCharsets.UTF_8; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BOOLEAN; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BOOLEAN_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BYTE; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.BYTE_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.CHAR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.CHAR_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.CLASS; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.COL; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DATE; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DATE_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DECIMAL; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DECIMAL_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DOUBLE; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.DOUBLE_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.ENUM; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.ENUM_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.FLOAT; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.FLOAT_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.INT; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.INT_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.LONG; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.LONG_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.MAP; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.MAP_ENTRY; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.NULL; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.OBJ; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.OBJ_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.OPTM_MARSH; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.PORTABLE_OBJ; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.RAW_DATA_OFF_POS; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.SHORT; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.SHORT_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.STRING; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.STRING_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.TIMESTAMP; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.TIMESTAMP_ARR; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.TOTAL_LEN_POS; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.UNREGISTERED_TYPE_ID; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.UUID; +import static org.apache.ignite.internal.portable.GridPortableMarshaller.UUID_ARR; + + /** + * Portable writer implementation. + */ +public class IgniteObjectWriterExImpl implements IgniteObjectWriter, IgniteObjectRawWriterEx, ObjectOutput { + /** Length: integer. */ + private static final int LEN_INT = 4; + + /** */ + private static final int INIT_CAP = 1024; + + /** */ + private final PortableContext ctx; + + /** */ + private final WriterContext wCtx; + + /** */ + private final int start; + + /** */ + private int mark; + + /** */ + private Class<?> cls; + + /** */ + private int typeId; + + /** */ + private boolean allowFields = true; + + /** */ + private boolean metaEnabled; + + /** */ + private int metaHashSum; + + /** + * @param ctx Context. + * @param off Start offset. + */ + IgniteObjectWriterExImpl(PortableContext ctx, int off) { + this.ctx = ctx; + + PortableOutputStream out = new PortableHeapOutputStream(off + INIT_CAP); + + out.position(off); + + wCtx = new WriterContext(out, null); + + start = off; + } + + /** + * @param ctx Context. + * @param out Output stream. + * @param off Start offset. + */ + IgniteObjectWriterExImpl(PortableContext ctx, PortableOutputStream out, int off) { + this.ctx = ctx; + + wCtx = new WriterContext(out, null); + + start = off; + } + + /** + * @param ctx Context. + * @param off Start offset. + * @param typeId Type ID. + */ + public IgniteObjectWriterExImpl(PortableContext ctx, int off, int typeId, boolean metaEnabled) { + this(ctx, off); + + this.typeId = typeId; + + this.metaEnabled = metaEnabled; + } + + /** + * @param ctx Context. + * @param wCtx Writer context. + */ + private IgniteObjectWriterExImpl(PortableContext ctx, WriterContext wCtx) { + this.ctx = ctx; + this.wCtx = wCtx; + + start = wCtx.out.position(); + } + + /** + * Close the writer releasing resources if necessary. + */ + @Override public void close() { + wCtx.out.close(); + } + + /** + * @return Meta data hash sum or {@code null} if meta data is disabled. + */ + @Nullable Integer metaDataHashSum() { + return metaEnabled ? metaHashSum : null; + } + + /** + * @param obj Object. + * @param detached Detached or not. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void marshal(Object obj, boolean detached) throws IgniteObjectException { + assert obj != null; + + cls = obj.getClass(); + + PortableClassDescriptor desc = ctx.descriptorForClass(cls); + + if (desc == null) + throw new IgniteObjectException("Object is not portable: [class=" + cls + ']'); + + if (desc.excluded()) { + doWriteByte(NULL); + return; + } + + if (desc.useOptimizedMarshaller()) { + writeByte(OPTM_MARSH); + + try { + byte[] arr = ctx.optimizedMarsh().marshal(obj); + + writeInt(arr.length); + + write(arr); + } + catch (IgniteCheckedException e) { + throw new IgniteObjectException("Failed to marshal object with optimized marshaller: " + obj, e); + } + + return; + } + + if (desc.getWriteReplaceMethod() != null) { + Object replace; + + try { + replace = desc.getWriteReplaceMethod().invoke(obj); + } + catch (IllegalAccessException e) { + throw new RuntimeException(e); + } + catch (InvocationTargetException e) { + if (e.getTargetException() instanceof IgniteObjectException) + throw (IgniteObjectException)e.getTargetException(); + + throw new IgniteObjectException("Failed to execute writeReplace() method on " + obj, e); + } + + if (replace == null) { + doWriteByte(NULL); + return; + } + + if (cls != replace.getClass()) { + cls = replace.getClass(); + + desc = ctx.descriptorForClass(cls); + + if (desc == null) + throw new IgniteObjectException("Object is not portable: [class=" + cls + ']'); + } + + obj = replace; + } + + typeId = desc.typeId(); + + metaEnabled = ctx.isMetaDataEnabled(typeId); + + if (detached) + wCtx.resetHandles(); + + desc.write(obj, this); + } + + /** + * @param obj Object. + * @return Handle. + */ + int handle(Object obj) { + assert obj != null; + + return wCtx.handle(obj); + } + + /** + * @return Array. + */ + public byte[] array() { + return wCtx.out.arrayCopy(); + } + + /** + * @return Output stream. + */ + public PortableOutputStream outputStream() { + return wCtx.out; + } + + /** + * @return Stream current position. + */ + int position() { + return wCtx.out.position(); + } + + /** + * Sets new position. + * + * @param pos Position. + */ + void position(int pos) { + wCtx.out.position(pos); + } + + /** + * @param bytes Number of bytes to reserve. + * @return Offset. + */ + public int reserve(int bytes) { + int pos = wCtx.out.position(); + + wCtx.out.position(pos + bytes); + + return pos; + } + + /** + * @param bytes Number of bytes to reserve. + * @return Offset. + */ + public int reserveAndMark(int bytes) { + int off0 = reserve(bytes); + + mark = wCtx.out.position(); + + return off0; + } + + /** + * @param off Offset. + */ + public void writeDelta(int off) { + wCtx.out.writeInt(off, wCtx.out.position() - mark); + } + + /** + * + */ + public void writeLength() { + wCtx.out.writeInt(start + TOTAL_LEN_POS, wCtx.out.position() - start); + } + + /** + * + */ + public void writeRawOffsetIfNeeded() { + if (allowFields) + wCtx.out.writeInt(start + RAW_DATA_OFF_POS, wCtx.out.position() - start); + } + + /** + * @param val Byte array. + */ + public void write(byte[] val) { + assert val != null; + + wCtx.out.writeByteArray(val); + } + + /** + * @param val Byte array. + * @param off Offset. + * @param len Length. + */ + public void write(byte[] val, int off, int len) { + assert val != null; + + wCtx.out.write(val, off, len); + } + + /** + * @param val Value. + */ + public void doWriteByte(byte val) { + wCtx.out.writeByte(val); + } + + /** + * @param val Value. + */ + public void doWriteShort(short val) { + wCtx.out.writeShort(val); + } + + /** + * @param val Value. + */ + public void doWriteInt(int val) { + wCtx.out.writeInt(val); + } + + /** + * @param val Value. + */ + public void doWriteLong(long val) { + wCtx.out.writeLong(val); + } + + /** + * @param val Value. + */ + public void doWriteFloat(float val) { + wCtx.out.writeFloat(val); + } + + /** + * @param val Value. + */ + public void doWriteDouble(double val) { + wCtx.out.writeDouble(val); + } + + /** + * @param val Value. + */ + public void doWriteChar(char val) { + wCtx.out.writeChar(val); + } + + /** + * @param val Value. + */ + public void doWriteBoolean(boolean val) { + wCtx.out.writeBoolean(val); + } + + /** + * @param val String value. + */ + public void doWriteDecimal(@Nullable BigDecimal val) { + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(DECIMAL); + + BigInteger intVal = val.unscaledValue(); + + if (intVal.signum() == -1) { + intVal = intVal.negate(); + + wCtx.out.writeInt(val.scale() | 0x80000000); + } + else + wCtx.out.writeInt(val.scale()); + + byte[] vals = intVal.toByteArray(); + + wCtx.out.writeInt(vals.length); + wCtx.out.writeByteArray(vals); + } + } + + /** + * @param val String value. + */ + public void doWriteString(@Nullable String val) { + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(STRING); + + if (ctx.isConvertString()) { + doWriteBoolean(true); + + byte[] strArr = val.getBytes(UTF_8); + + doWriteInt(strArr.length); + + wCtx.out.writeByteArray(strArr); + } + else { + doWriteBoolean(false); + + char[] strArr = val.toCharArray(); + + doWriteInt(strArr.length); + + wCtx.out.writeCharArray(strArr); + } + } + } + + /** + * @param uuid UUID. + */ + public void doWriteUuid(@Nullable UUID uuid) { + if (uuid == null) + doWriteByte(NULL); + else { + doWriteByte(UUID); + doWriteLong(uuid.getMostSignificantBits()); + doWriteLong(uuid.getLeastSignificantBits()); + } + } + + /** + * @param date Date. + */ + public void doWriteDate(@Nullable Date date) { + if (date == null) + doWriteByte(NULL); + else { + doWriteByte(DATE); + doWriteLong(date.getTime()); + } + } + + /** + * @param ts Timestamp. + */ + public void doWriteTimestamp(@Nullable Timestamp ts) { + if (ts== null) + doWriteByte(NULL); + else { + doWriteByte(TIMESTAMP); + doWriteLong(ts.getTime()); + doWriteInt(ts.getNanos() % 1000000); + } + } + + /** + * @param obj Object. + * @param detached Detached or not. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + public void doWriteObject(@Nullable Object obj, boolean detached) throws IgniteObjectException { + if (obj == null) + doWriteByte(NULL); + else { + WriterContext wCtx = detached ? new WriterContext(this.wCtx.out, this.wCtx.handles) : this.wCtx; + + IgniteObjectWriterExImpl writer = new IgniteObjectWriterExImpl(ctx, wCtx); + + writer.marshal(obj, detached); + + if (detached) + this.wCtx.out = wCtx.out; + } + } + + /** + * @param val Byte array. + */ + void doWriteByteArray(@Nullable byte[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(BYTE_ARR); + doWriteInt(val.length); + + wCtx.out.writeByteArray(val); + } + } + + /** + * @param val Short array. + */ + void doWriteShortArray(@Nullable short[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(SHORT_ARR); + doWriteInt(val.length); + + wCtx.out.writeShortArray(val); + } + } + + /** + * @param val Integer array. + */ + void doWriteIntArray(@Nullable int[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(INT_ARR); + doWriteInt(val.length); + + wCtx.out.writeIntArray(val); + } + } + + /** + * @param val Long array. + */ + void doWriteLongArray(@Nullable long[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(LONG_ARR); + doWriteInt(val.length); + + wCtx.out.writeLongArray(val); + } + } + + /** + * @param val Float array. + */ + void doWriteFloatArray(@Nullable float[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(FLOAT_ARR); + doWriteInt(val.length); + + wCtx.out.writeFloatArray(val); + } + } + + /** + * @param val Double array. + */ + void doWriteDoubleArray(@Nullable double[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(DOUBLE_ARR); + doWriteInt(val.length); + + wCtx.out.writeDoubleArray(val); + } + } + + /** + * @param val Char array. + */ + void doWriteCharArray(@Nullable char[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(CHAR_ARR); + doWriteInt(val.length); + + wCtx.out.writeCharArray(val); + } + } + + /** + * @param val Boolean array. + */ + void doWriteBooleanArray(@Nullable boolean[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(BOOLEAN_ARR); + doWriteInt(val.length); + + wCtx.out.writeBooleanArray(val); + } + } + + /** + * @param val Array of strings. + */ + void doWriteDecimalArray(@Nullable BigDecimal[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(DECIMAL_ARR); + doWriteInt(val.length); + + for (BigDecimal str : val) + doWriteDecimal(str); + } + } + + /** + * @param val Array of strings. + */ + void doWriteStringArray(@Nullable String[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(STRING_ARR); + doWriteInt(val.length); + + for (String str : val) + doWriteString(str); + } + } + + /** + * @param val Array of UUIDs. + */ + void doWriteUuidArray(@Nullable UUID[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(UUID_ARR); + doWriteInt(val.length); + + for (UUID uuid : val) + doWriteUuid(uuid); + } + } + + /** + * @param val Array of dates. + */ + void doWriteDateArray(@Nullable Date[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(DATE_ARR); + doWriteInt(val.length); + + for (Date date : val) + doWriteDate(date); + } + } + + /** + * @param val Array of timestamps. + */ + void doWriteTimestampArray(@Nullable Timestamp[] val) { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + doWriteByte(TIMESTAMP_ARR); + doWriteInt(val.length); + + for (Timestamp ts : val) + doWriteTimestamp(ts); + } + } + + /** + * @param val Array of objects. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void doWriteObjectArray(@Nullable Object[] val) throws IgniteObjectException { + if (val == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(val)) + return; + + PortableClassDescriptor desc = ctx.descriptorForClass(val.getClass().getComponentType()); + + doWriteByte(OBJ_ARR); + + if (desc.registered()) + doWriteInt(desc.typeId()); + else { + doWriteInt(UNREGISTERED_TYPE_ID); + doWriteString(val.getClass().getComponentType().getName()); + } + + doWriteInt(val.length); + + for (Object obj : val) + doWriteObject(obj, false); + } + } + + /** + * @param col Collection. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void doWriteCollection(@Nullable Collection<?> col) throws IgniteObjectException { + if (col == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(col)) + return; + + doWriteByte(COL); + doWriteInt(col.size()); + doWriteByte(ctx.collectionType(col.getClass())); + + for (Object obj : col) + doWriteObject(obj, false); + } + } + + /** + * @param map Map. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void doWriteMap(@Nullable Map<?, ?> map) throws IgniteObjectException { + if (map == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(map)) + return; + + doWriteByte(MAP); + doWriteInt(map.size()); + doWriteByte(ctx.mapType(map.getClass())); + + for (Map.Entry<?, ?> e : map.entrySet()) { + doWriteObject(e.getKey(), false); + doWriteObject(e.getValue(), false); + } + } + } + + /** + * @param e Map entry. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void doWriteMapEntry(@Nullable Map.Entry<?, ?> e) throws IgniteObjectException { + if (e == null) + doWriteByte(NULL); + else { + if (tryWriteAsHandle(e)) + return; + + doWriteByte(MAP_ENTRY); + doWriteObject(e.getKey(), false); + doWriteObject(e.getValue(), false); + } + } + + /** + * @param val Value. + */ + void doWriteEnum(@Nullable Enum<?> val) { + if (val == null) + doWriteByte(NULL); + else { + PortableClassDescriptor desc = ctx.descriptorForClass(val.getClass()); + + doWriteByte(ENUM); + + if (desc.registered()) + doWriteInt(desc.typeId()); + else { + doWriteInt(UNREGISTERED_TYPE_ID); + doWriteString(val.getClass().getName()); + } + + doWriteInt(val.ordinal()); + } + } + + /** + * @param val Array. + */ + void doWriteEnumArray(@Nullable Object[] val) { + assert val == null || val.getClass().getComponentType().isEnum(); + + if (val == null) + doWriteByte(NULL); + else { + PortableClassDescriptor desc = ctx.descriptorForClass(val.getClass().getComponentType()); + doWriteByte(ENUM_ARR); + + if (desc.registered()) + doWriteInt(desc.typeId()); + else { + doWriteInt(UNREGISTERED_TYPE_ID); + doWriteString(val.getClass().getComponentType().getName()); + } + + doWriteInt(val.length); + + // TODO: Denis: Redundant data for each element of the array. + for (Object o : val) + doWriteEnum((Enum<?>)o); + } + } + + /** + * @param val Class. + */ + void doWriteClass(@Nullable Class val) { + if (val == null) + doWriteByte(NULL); + else { + PortableClassDescriptor desc = ctx.descriptorForClass(val); + + doWriteByte(CLASS); + + if (desc.registered()) + doWriteInt(desc.typeId()); + else { + doWriteInt(UNREGISTERED_TYPE_ID); + doWriteString(val.getClass().getName()); + } + } + } + + /** + * @param po Portable object. + */ + public void doWritePortableObject(@Nullable IgniteObjectImpl po) { + if (po == null) + doWriteByte(NULL); + else { + doWriteByte(PORTABLE_OBJ); + + byte[] poArr = po.array(); + + doWriteInt(poArr.length); + + wCtx.out.writeByteArray(poArr); + + doWriteInt(po.start()); + } + } + + /** + * @param val Value. + */ + void writeByteField(@Nullable Byte val) { + doWriteInt(val != null ? 2 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(BYTE); + doWriteByte(val); + } + } + + /** + * @param val Class. + */ + void writeClassField(@Nullable Class val) { + int lenPos = reserveAndMark(4); + + doWriteClass(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeShortField(@Nullable Short val) { + doWriteInt(val != null ? 3 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(SHORT); + doWriteShort(val); + } + } + + /** + * @param val Value. + */ + void writeIntField(@Nullable Integer val) { + doWriteInt(val != null ? 5 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(INT); + doWriteInt(val); + } + } + + /** + * @param val Value. + */ + void writeLongField(@Nullable Long val) { + doWriteInt(val != null ? 9 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(LONG); + doWriteLong(val); + } + } + + /** + * @param val Value. + */ + void writeFloatField(@Nullable Float val) { + doWriteInt(val != null ? 5 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(FLOAT); + doWriteFloat(val); + } + } + + /** + * @param val Value. + */ + void writeDoubleField(@Nullable Double val) { + doWriteInt(val != null ? 9 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(DOUBLE); + doWriteDouble(val); + } + } + + /** + * @param val Value. + */ + void writeCharField(@Nullable Character val) { + doWriteInt(val != null ? 3 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(CHAR); + doWriteChar(val); + } + } + + /** + * @param val Value. + */ + void writeBooleanField(@Nullable Boolean val) { + doWriteInt(val != null ? 2 : 1); + + if (val == null) + doWriteByte(NULL); + else { + doWriteByte(BOOLEAN); + doWriteBoolean(val); + } + } + + /** + * @param val Value. + */ + void writeDecimalField(@Nullable BigDecimal val) { + int lenPos = reserveAndMark(4); + + doWriteDecimal(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeStringField(@Nullable String val) { + int lenPos = reserveAndMark(4); + + doWriteString(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeUuidField(@Nullable UUID val) { + doWriteInt(val != null ? 17 : 1); + doWriteUuid(val); + } + + /** + * @param val Value. + */ + void writeDateField(@Nullable Date val) { + doWriteInt(val != null ? 9 : 1); + doWriteDate(val); + } + + /** + * @param val Value. + */ + void writeTimestampField(@Nullable Timestamp val) { + doWriteInt(val != null ? 13 : 1); + doWriteTimestamp(val); + } + + /** + * @param obj Object. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writeObjectField(@Nullable Object obj) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWriteObject(obj, false); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeByteArrayField(@Nullable byte[] val) { + int lenPos = reserveAndMark(4); + + doWriteByteArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeShortArrayField(@Nullable short[] val) { + int lenPos = reserveAndMark(4); + + doWriteShortArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeIntArrayField(@Nullable int[] val) { + int lenPos = reserveAndMark(4); + + doWriteIntArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeLongArrayField(@Nullable long[] val) { + int lenPos = reserveAndMark(4); + + doWriteLongArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeFloatArrayField(@Nullable float[] val) { + int lenPos = reserveAndMark(4); + + doWriteFloatArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeDoubleArrayField(@Nullable double[] val) { + int lenPos = reserveAndMark(4); + + doWriteDoubleArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeCharArrayField(@Nullable char[] val) { + int lenPos = reserveAndMark(4); + + doWriteCharArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeBooleanArrayField(@Nullable boolean[] val) { + int lenPos = reserveAndMark(4); + + doWriteBooleanArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeDecimalArrayField(@Nullable BigDecimal[] val) { + int lenPos = reserveAndMark(4); + + doWriteDecimalArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeStringArrayField(@Nullable String[] val) { + int lenPos = reserveAndMark(4); + + doWriteStringArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeUuidArrayField(@Nullable UUID[] val) { + int lenPos = reserveAndMark(4); + + doWriteUuidArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeDateArrayField(@Nullable Date[] val) { + int lenPos = reserveAndMark(4); + + doWriteDateArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeTimestampArrayField(@Nullable Timestamp[] val) { + int lenPos = reserveAndMark(4); + + doWriteTimestampArray(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writeObjectArrayField(@Nullable Object[] val) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWriteObjectArray(val); + + writeDelta(lenPos); + } + + /** + * @param col Collection. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writeCollectionField(@Nullable Collection<?> col) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWriteCollection(col); + + writeDelta(lenPos); + } + + /** + * @param map Map. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writeMapField(@Nullable Map<?, ?> map) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWriteMap(map); + + writeDelta(lenPos); + } + + /** + * @param e Map entry. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writeMapEntryField(@Nullable Map.Entry<?, ?> e) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWriteMapEntry(e); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeEnumField(@Nullable Enum<?> val) { + int lenPos = reserveAndMark(4); + + doWriteEnum(val); + + writeDelta(lenPos); + } + + /** + * @param val Value. + */ + void writeEnumArrayField(@Nullable Object[] val) { + int lenPos = reserveAndMark(4); + + doWriteEnumArray(val); + + writeDelta(lenPos); + } + + /** + * @param po Portable object. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. + */ + void writePortableObjectField(@Nullable IgniteObjectImpl po) throws IgniteObjectException { + int lenPos = reserveAndMark(4); + + doWritePortableObject(po); + + writeDelta(lenPos); + } + + /** {@inheritDoc} */ + @Override public void writeByte(String fieldName, byte val) throws IgniteObjectException { + writeFieldId(fieldName, BYTE); + writeByteField(val); + } + + /** {@inheritDoc} */ + @Override public void writeByte(byte val) throws IgniteObjectException { + doWriteByte(val); + } + + /** {@inheritDoc} */ + @Override public void writeShort(String fieldName, short val) throws IgniteObjectException { + writeFieldId(fieldName, SHORT); + writeShortField(val); + } + + /** {@inheritDoc} */ + @Override public void writeShort(short val) throws IgniteObjectException { + doWriteShort(val); + } + + /** {@inheritDoc} */ + @Override public void writeInt(String fieldName, int val) throws IgniteObjectException { + writeFieldId(fieldName, INT); + writeIntField(val); + } + + /** {@inheritDoc} */ + @Override public void writeInt(int val) throws IgniteObjectException { + doWriteInt(val); + } + + /** {@inheritDoc} */ + @Override public void writeLong(String fieldName, long val) throws IgniteObjectException { + writeFieldId(fieldName, LONG); + writeLongField(val); + } + + /** {@inheritDoc} */ + @Override public void writeLong(long val) throws IgniteObjectException { + doWriteLong(val); + } + + /** {@inheritDoc} */ + @Override public void writeFloat(String fieldName, float val) throws IgniteObjectException { + writeFieldId(fieldName, FLOAT); + writeFloatField(val); + } + + /** {@inheritDoc} */ + @Override public void writeFloat(float val) throws IgniteObjectException { + doWriteFloat(val); + } + + /** {@inheritDoc} */ + @Override public void writeDouble(String fieldName, double val) throws IgniteObjectException { + writeFieldId(fieldName, DOUBLE); + writeDoubleField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDouble(double val) throws IgniteObjectException { + doWriteDouble(val); + } + + /** {@inheritDoc} */ + @Override public void writeChar(String fieldName, char val) throws IgniteObjectException { + writeFieldId(fieldName, CHAR); + writeCharField(val); + } + + /** {@inheritDoc} */ + @Override public void writeChar(char val) throws IgniteObjectException { + doWriteChar(val); + } + + /** {@inheritDoc} */ + @Override public void writeBoolean(String fieldName, boolean val) throws IgniteObjectException { + writeFieldId(fieldName, BOOLEAN); + writeBooleanField(val); + } + + /** {@inheritDoc} */ + @Override public void writeBoolean(boolean val) throws IgniteObjectException { + doWriteBoolean(val); + } + + /** {@inheritDoc} */ + @Override public void writeDecimal(String fieldName, @Nullable BigDecimal val) throws IgniteObjectException { + writeFieldId(fieldName, DECIMAL); + writeDecimalField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDecimal(@Nullable BigDecimal val) throws IgniteObjectException { + doWriteDecimal(val); + } + + /** {@inheritDoc} */ + @Override public void writeString(String fieldName, @Nullable String val) throws IgniteObjectException { + writeFieldId(fieldName, STRING); + writeStringField(val); + } + + /** {@inheritDoc} */ + @Override public void writeString(@Nullable String val) throws IgniteObjectException { + doWriteString(val); + } + + /** {@inheritDoc} */ + @Override public void writeUuid(String fieldName, @Nullable UUID val) throws IgniteObjectException { + writeFieldId(fieldName, UUID); + writeUuidField(val); + } + + /** {@inheritDoc} */ + @Override public void writeUuid(@Nullable UUID val) throws IgniteObjectException { + doWriteUuid(val); + } + + /** {@inheritDoc} */ + @Override public void writeDate(String fieldName, @Nullable Date val) throws IgniteObjectException { + writeFieldId(fieldName, DATE); + writeDateField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDate(@Nullable Date val) throws IgniteObjectException { + doWriteDate(val); + } + + /** {@inheritDoc} */ + @Override public void writeTimestamp(String fieldName, @Nullable Timestamp val) throws IgniteObjectException { + writeFieldId(fieldName, TIMESTAMP); + writeTimestampField(val); + } + + /** {@inheritDoc} */ + @Override public void writeTimestamp(@Nullable Timestamp val) throws IgniteObjectException { + doWriteTimestamp(val); + } + + /** {@inheritDoc} */ + @Override public void writeObject(String fieldName, @Nullable Object obj) throws IgniteObjectException { + writeFieldId(fieldName, OBJ); + writeObjectField(obj); + } + + /** {@inheritDoc} */ + @Override public void writeObject(@Nullable Object obj) throws IgniteObjectException { + doWriteObject(obj, false); + } + + /** {@inheritDoc} */ + @Override public void writeObjectDetached(@Nullable Object obj) throws IgniteObjectException { + doWriteObject(obj, true); + } + + /** {@inheritDoc} */ + @Override public void writeByteArray(String fieldName, @Nullable byte[] val) throws IgniteObjectException { + writeFieldId(fieldName, BYTE_ARR); + writeByteArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeByteArray(@Nullable byte[] val) throws IgniteObjectException { + doWriteByteArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeShortArray(String fieldName, @Nullable short[] val) throws IgniteObjectException { + writeFieldId(fieldName, SHORT_ARR); + writeShortArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeShortArray(@Nullable short[] val) throws IgniteObjectException { + doWriteShortArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeIntArray(String fieldName, @Nullable int[] val) throws IgniteObjectException { + writeFieldId(fieldName, INT_ARR); + writeIntArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeIntArray(@Nullable int[] val) throws IgniteObjectException { + doWriteIntArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeLongArray(String fieldName, @Nullable long[] val) throws IgniteObjectException { + writeFieldId(fieldName, LONG_ARR); + writeLongArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeLongArray(@Nullable long[] val) throws IgniteObjectException { + doWriteLongArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeFloatArray(String fieldName, @Nullable float[] val) throws IgniteObjectException { + writeFieldId(fieldName, FLOAT_ARR); + writeFloatArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeFloatArray(@Nullable float[] val) throws IgniteObjectException { + doWriteFloatArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeDoubleArray(String fieldName, @Nullable double[] val) + throws IgniteObjectException { + writeFieldId(fieldName, DOUBLE_ARR); + writeDoubleArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDoubleArray(@Nullable double[] val) throws IgniteObjectException { + doWriteDoubleArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeCharArray(String fieldName, @Nullable char[] val) throws IgniteObjectException { + writeFieldId(fieldName, CHAR_ARR); + writeCharArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeCharArray(@Nullable char[] val) throws IgniteObjectException { + doWriteCharArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeBooleanArray(String fieldName, @Nullable boolean[] val) + throws IgniteObjectException { + writeFieldId(fieldName, BOOLEAN_ARR); + writeBooleanArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeBooleanArray(@Nullable boolean[] val) throws IgniteObjectException { + doWriteBooleanArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeDecimalArray(String fieldName, @Nullable BigDecimal[] val) + throws IgniteObjectException { + writeFieldId(fieldName, DECIMAL_ARR); + writeDecimalArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDecimalArray(@Nullable BigDecimal[] val) throws IgniteObjectException { + doWriteDecimalArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeStringArray(String fieldName, @Nullable String[] val) + throws IgniteObjectException { + writeFieldId(fieldName, STRING_ARR); + writeStringArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeStringArray(@Nullable String[] val) throws IgniteObjectException { + doWriteStringArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeUuidArray(String fieldName, @Nullable UUID[] val) throws IgniteObjectException { + writeFieldId(fieldName, UUID_ARR); + writeUuidArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeUuidArray(@Nullable UUID[] val) throws IgniteObjectException { + doWriteUuidArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeDateArray(String fieldName, @Nullable Date[] val) throws IgniteObjectException { + writeFieldId(fieldName, DATE_ARR); + writeDateArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeDateArray(@Nullable Date[] val) throws IgniteObjectException { + doWriteDateArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeTimestampArray(String fieldName, @Nullable Timestamp[] val) throws IgniteObjectException { + writeFieldId(fieldName, TIMESTAMP_ARR); + writeTimestampArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeTimestampArray(@Nullable Timestamp[] val) throws IgniteObjectException { + doWriteTimestampArray(val); + } + + /** {@inheritDoc} */ + @Override public void writeObjectArray(String fieldName, @Nullable Object[] val) throws IgniteObjectException { + writeFieldId(fieldName, OBJ_ARR); + writeObjectArrayField(val); + } + + /** {@inheritDoc} */ + @Override public void writeObjectArray(@Nullable Object[] val) throws IgniteObjectException { + doWriteObjectArray(val); + } + + /** {@inheritDoc} */ + @Override public <T> void writeCollection(String fieldName, @Nullable Collection<T> col) + throws IgniteObjectException { + writeFieldId(fieldName, COL); + writeCollectionField(col); + } + + /** {@inheritDoc} */ + @Override public <T> void writeCollection(@Nullable Collection<T> col) throws IgniteObjectException { + doWriteCollection(col); + } + + /** {@inheritDoc} */ + @Override public <K, V> void writeMap(String fieldName, @Nullable Map<K, V> map) + throws IgniteObjectException { + writeFieldId(fieldName, MAP); + writeMapField(map); + } + + /** {@inheritDoc} */ + @Override public <K, V> void writeMap(@Nullable Map<K, V> map) throws IgniteObjectException { + doWriteMap(map); + } + + /** {@inheritDoc} */ + @Override public <T extends Enum<?>> void writeEnum(String fieldName, T val) throws IgniteObjectException { + writeFieldId(fieldName, ENUM); + writeEnumField(val); + } + + /** {@inheritDoc} */ + @Override public <T extends Enum<?>> void writeEnum(T val) throws IgniteObjectException { + doWriteEnum(val); + } + + /** {@inheritDoc} */ + @Override public <T extends Enum<?>> void writeEnumArray(String fieldName, T[] val) throws IgniteObjectException { + writeFieldId(fieldName, ENUM_ARR); + writeEnumArrayField(val); + } + + /** {@inheritDoc} */ + @Override public <T extends Enum<?>> void writeEnumArray(T[] val) throws IgniteObjectException { + doWriteEnumArray(val); + } + + /** {@inheritDoc} */ + @Override public IgniteObjectRawWriter rawWriter() { + if (allowFields) { + wCtx.out.writeInt(start + RAW_DATA_OFF_POS, wCtx.out.position() - start); + + allowFields = false; + } + + return this; + } + + /** {@inheritDoc} */ + @Override public PortableOutputStream out() { + return wCtx.out; + } + + /** {@inheritDoc} */ + @Override public void writeBytes(String s) throws IOException { + int len = s.length(); + + writeInt(len); + + for (int i = 0; i < len; i++) + writeByte(s.charAt(i)); + } + + /** {@inheritDoc} */ + @Override public void writeChars(String s) throws IOException { + int len = s.length(); + + writeInt(len); + + for (int i = 0; i < len; i++) + writeChar(s.charAt(i)); + } + + /** {@inheritDoc} */ + @Override public void writeUTF(String s) throws IOException { + writeString(s); + } + + /** {@inheritDoc} */ + @Override public void writeByte(int v) throws IOException { + doWriteByte((byte)v); + } + + /** {@inheritDoc} */ + @Override public void writeShort(int v) throws IOException { + doWriteShort((short)v); + } + + /** {@inheritDoc} */ + @Override public void writeChar(int v) throws IOException { + doWriteChar((char)v); + } + + /** {@inheritDoc} */ + @Override public void write(int b) throws IOException { + doWriteByte((byte)b); + } + + /** {@inheritDoc} */ + @Override public void flush() throws IOException { + // No-op. + } + + /** {@inheritDoc} */ + @Override public int reserveInt() { + return reserve(LEN_INT); + } + + /** {@inheritDoc} */ + @Override public void writeInt(int pos, int val) throws IgniteObjectException { + wCtx.out.writeInt(pos, val); + } + + /** + * @param fieldName Field name. + * @throws org.apache.ignite.igniteobject.IgniteObjectException If fields are not allowed. + */ + private void writeFieldId(String fieldName, byte fieldType) throws IgniteObjectException { + A.notNull(fieldName, "fieldName"); + + if (!allowFields) + throw new IgniteObjectException("Individual field can't be written after raw writer is acquired " + + "via rawWriter() method. Consider fixing serialization logic for class: " + cls.getName()); + + int id = ctx.fieldId(typeId, fieldName); + + if (metaEnabled) + metaHashSum = 31 * metaHashSum + (id + fieldType); + + doWriteInt(id); + } + + /** + * Attempts to write the object as a handle. + * + * @param obj Object to write. + * @return {@code true} if the object has been written as a handle. + */ + boolean tryWriteAsHandle(Object obj) { + int handle = handle(obj); + + if (handle >= 0) { + doWriteByte(GridPortableMarshaller.HANDLE); + doWriteInt(handle); + + return true; + } + + return false; + } + + /** + * Create new writer with same context. + * @param typeId type + * @return New writer. + */ + public IgniteObjectWriterExImpl newWriter(int typeId) { + IgniteObjectWriterExImpl res = new IgniteObjectWriterExImpl(ctx, wCtx); + + res.typeId = typeId; + + return res; + } + + /** + * @return Portable context. + */ + public PortableContext context() { + return ctx; + } + + /** */ + private static class WriterContext { + /** */ + private Map<Object, Integer> handles = new IdentityHashMap<>(); + + /** Output stream. */ + private PortableOutputStream out; + + /** + * Constructor. + * + * @param out Output stream. + * @param handles Handles. + */ + private WriterContext(PortableOutputStream out, Map<Object, Integer> handles) { + this.out = out; + this.handles = handles == null ? new IdentityHashMap<Object, Integer>() : handles; + } + + /** + * @param obj Object. + * @return Handle. + */ + private int handle(Object obj) { + assert obj != null; + + Integer h = handles.get(obj); + + if (h != null) + return out.position() - h; + else { + handles.put(obj, out.position()); + + return -1; + } + } + + /** + * + */ + private void resetHandles() { + handles = new IdentityHashMap<>(); + } + } +}
http://git-wip-us.apache.org/repos/asf/ignite/blob/35b6d61f/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableClassDescriptor.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableClassDescriptor.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableClassDescriptor.java index 0a9974e..2470837 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableClassDescriptor.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableClassDescriptor.java @@ -41,10 +41,10 @@ import org.apache.ignite.internal.util.typedef.internal.U; import org.apache.ignite.marshaller.MarshallerExclusions; import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.marshaller.portable.PortableMarshaller; -import org.apache.ignite.portable.PortableException; -import org.apache.ignite.portable.PortableIdMapper; -import org.apache.ignite.portable.PortableMarshalAware; -import org.apache.ignite.portable.PortableSerializer; +import org.apache.ignite.igniteobject.IgniteObjectException; +import org.apache.ignite.igniteobject.IgniteObjectIdMapper; +import org.apache.ignite.igniteobject.IgniteObjectMarshalAware; +import org.apache.ignite.igniteobject.IgniteObjectSerializer; import org.jetbrains.annotations.Nullable; import static java.lang.reflect.Modifier.isStatic; @@ -61,7 +61,7 @@ public class PortableClassDescriptor { private final Class<?> cls; /** */ - private final PortableSerializer serializer; + private final IgniteObjectSerializer serializer; /** */ private final Mode mode; @@ -114,7 +114,7 @@ public class PortableClassDescriptor { * @param keepDeserialized Keep deserialized flag. * @param registered Whether typeId has been successfully registered by MarshallerContext or not. * @param predefined Whether the class is predefined or not. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ PortableClassDescriptor( PortableContext ctx, @@ -122,13 +122,13 @@ public class PortableClassDescriptor { boolean userType, int typeId, String typeName, - @Nullable PortableIdMapper idMapper, - @Nullable PortableSerializer serializer, + @Nullable IgniteObjectIdMapper idMapper, + @Nullable IgniteObjectSerializer serializer, boolean metaDataEnabled, boolean keepDeserialized, boolean registered, boolean predefined - ) throws PortableException { + ) throws IgniteObjectException { assert ctx != null; assert cls != null; @@ -220,12 +220,12 @@ public class PortableClassDescriptor { String name = f.getName(); if (!names.add(name)) - throw new PortableException("Duplicate field name: " + name); + throw new IgniteObjectException("Duplicate field name: " + name); int fieldId = idMapper.fieldId(typeId, name); if (!ids.add(fieldId)) - throw new PortableException("Duplicate field ID: " + name); + throw new IgniteObjectException("Duplicate field ID: " + name); FieldInfo fieldInfo = new FieldInfo(f, fieldId); @@ -241,7 +241,7 @@ public class PortableClassDescriptor { default: // Should never happen. - throw new PortableException("Invalid mode: " + mode); + throw new IgniteObjectException("Invalid mode: " + mode); } if (mode == Mode.PORTABLE || mode == Mode.EXTERNALIZABLE || mode == Mode.OBJECT) { @@ -323,9 +323,9 @@ public class PortableClassDescriptor { /** * @param obj Object. * @param writer Writer. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - void write(Object obj, PortableWriterExImpl writer) throws PortableException { + void write(Object obj, IgniteObjectWriterExImpl writer) throws IgniteObjectException { assert obj != null; assert writer != null; @@ -504,7 +504,7 @@ public class PortableClassDescriptor { break; case PORTABLE_OBJ: - writer.doWritePortableObject((PortableObjectImpl)obj); + writer.doWritePortableObject((IgniteObjectImpl)obj); break; @@ -513,19 +513,19 @@ public class PortableClassDescriptor { if (serializer != null) serializer.writePortable(obj, writer); else - ((PortableMarshalAware)obj).writePortable(writer); + ((IgniteObjectMarshalAware)obj).writePortable(writer); writer.writeRawOffsetIfNeeded(); writer.writeLength(); - if (obj.getClass() != PortableMetaDataImpl.class + if (obj.getClass() != IgniteObjectMetaDataImpl.class && ctx.isMetaDataChanged(typeId, writer.metaDataHashSum())) { - PortableMetaDataCollector metaCollector = new PortableMetaDataCollector(typeName); + IgniteObjectMetaDataCollector metaCollector = new IgniteObjectMetaDataCollector(typeName); if (serializer != null) serializer.writePortable(obj, metaCollector); else - ((PortableMarshalAware)obj).writePortable(metaCollector); + ((IgniteObjectMarshalAware)obj).writePortable(metaCollector); ctx.updateMetaData(typeId, typeName, metaCollector.meta()); } @@ -539,7 +539,7 @@ public class PortableClassDescriptor { ((Externalizable)obj).writeExternal(writer); } catch (IOException e) { - throw new PortableException("Failed to write Externalizable object: " + obj, e); + throw new IgniteObjectException("Failed to write Externalizable object: " + obj, e); } writer.writeLength(); @@ -566,9 +566,9 @@ public class PortableClassDescriptor { /** * @param reader Reader. * @return Object. - * @throws PortableException If failed. + * @throws org.apache.ignite.igniteobject.IgniteObjectException If failed. */ - Object read(PortableReaderExImpl reader) throws PortableException { + Object read(IgniteObjectReaderExImpl reader) throws IgniteObjectException { assert reader != null; Object res; @@ -582,7 +582,7 @@ public class PortableClassDescriptor { if (serializer != null) serializer.readPortable(res, reader); else - ((PortableMarshalAware)res).readPortable(reader); + ((IgniteObjectMarshalAware)res).readPortable(reader); break; @@ -595,7 +595,7 @@ public class PortableClassDescriptor { ((Externalizable)res).readExternal(reader); } catch (IOException | ClassNotFoundException e) { - throw new PortableException("Failed to read Externalizable object: " + + throw new IgniteObjectException("Failed to read Externalizable object: " + res.getClass().getName(), e); } @@ -627,10 +627,10 @@ public class PortableClassDescriptor { throw new RuntimeException(e); } catch (InvocationTargetException e) { - if (e.getTargetException() instanceof PortableException) - throw (PortableException)e.getTargetException(); + if (e.getTargetException() instanceof IgniteObjectException) + throw (IgniteObjectException)e.getTargetException(); - throw new PortableException("Failed to execute readResolve() method on " + res, e); + throw new IgniteObjectException("Failed to execute readResolve() method on " + res, e); } } @@ -642,7 +642,7 @@ public class PortableClassDescriptor { * @param writer Writer. * @return Whether further write is needed. */ - private boolean writeHeader(Object obj, PortableWriterExImpl writer) { + private boolean writeHeader(Object obj, IgniteObjectWriterExImpl writer) { if (writer.tryWriteAsHandle(obj)) return false; @@ -674,25 +674,25 @@ public class PortableClassDescriptor { /** * @return Instance. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - private Object newInstance() throws PortableException { + private Object newInstance() throws IgniteObjectException { assert ctor != null; try { return ctor.newInstance(); } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) { - throw new PortableException("Failed to instantiate instance: " + cls, e); + throw new IgniteObjectException("Failed to instantiate instance: " + cls, e); } } /** * @param cls Class. * @return Constructor. - * @throws PortableException If constructor doesn't exist. + * @throws org.apache.ignite.igniteobject.IgniteObjectException If constructor doesn't exist. */ - @Nullable private static Constructor<?> constructor(Class<?> cls) throws PortableException { + @Nullable private static Constructor<?> constructor(Class<?> cls) throws IgniteObjectException { assert cls != null; try { @@ -703,7 +703,7 @@ public class PortableClassDescriptor { return ctor; } catch (IgniteCheckedException e) { - throw new PortableException("Failed to get constructor for class: " + cls.getName(), e); + throw new IgniteObjectException("Failed to get constructor for class: " + cls.getName(), e); } } @@ -795,9 +795,9 @@ public class PortableClassDescriptor { return Mode.TIMESTAMP_ARR; else if (cls.isArray()) return cls.getComponentType().isEnum() ? Mode.ENUM_ARR : Mode.OBJ_ARR; - else if (cls == PortableObjectImpl.class) + else if (cls == IgniteObjectImpl.class) return Mode.PORTABLE_OBJ; - else if (PortableMarshalAware.class.isAssignableFrom(cls)) + else if (IgniteObjectMarshalAware.class.isAssignableFrom(cls)) return Mode.PORTABLE; else if (Externalizable.class.isAssignableFrom(cls)) return Mode.EXTERNALIZABLE; @@ -807,7 +807,7 @@ public class PortableClassDescriptor { return Mode.COL; else if (Map.class.isAssignableFrom(cls)) return Mode.MAP; - else if (cls == PortableObjectImpl.class) + else if (cls == IgniteObjectImpl.class) return Mode.PORTABLE_OBJ; else if (cls.isEnum()) return Mode.ENUM; @@ -853,9 +853,9 @@ public class PortableClassDescriptor { /** * @param obj Object. * @param writer Writer. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - public void write(Object obj, PortableWriterExImpl writer) throws PortableException { + public void write(Object obj, IgniteObjectWriterExImpl writer) throws IgniteObjectException { assert obj != null; assert writer != null; @@ -867,7 +867,7 @@ public class PortableClassDescriptor { val = field.get(obj); } catch (IllegalAccessException e) { - throw new PortableException("Failed to get value for field: " + field, e); + throw new IgniteObjectException("Failed to get value for field: " + field, e); } switch (mode) { @@ -1022,7 +1022,7 @@ public class PortableClassDescriptor { break; case PORTABLE_OBJ: - writer.writePortableObjectField((PortableObjectImpl)val); + writer.writePortableObjectField((IgniteObjectImpl)val); break; @@ -1056,9 +1056,9 @@ public class PortableClassDescriptor { /** * @param obj Object. * @param reader Reader. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - public void read(Object obj, PortableReaderExImpl reader) throws PortableException { + public void read(Object obj, IgniteObjectReaderExImpl reader) throws IgniteObjectException { Object val = null; switch (mode) { @@ -1248,7 +1248,7 @@ public class PortableClassDescriptor { field.set(obj, val); } catch (IllegalAccessException e) { - throw new PortableException("Failed to set value for field: " + field, e); + throw new IgniteObjectException("Failed to set value for field: " + field, e); } } } http://git-wip-us.apache.org/repos/asf/ignite/blob/35b6d61f/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableContext.java ---------------------------------------------------------------------- diff --git a/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableContext.java b/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableContext.java index 9c11ca8..2822441 100644 --- a/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableContext.java +++ b/modules/core/src/main/java/org/apache/ignite/internal/portable/PortableContext.java @@ -50,6 +50,8 @@ import java.util.concurrent.ConcurrentSkipListSet; import java.util.jar.JarEntry; import java.util.jar.JarFile; import org.apache.ignite.IgniteCheckedException; +import org.apache.ignite.cache.CacheKeyConfiguration; +import org.apache.ignite.configuration.IgniteConfiguration; import org.apache.ignite.internal.IgniteKernal; import org.apache.ignite.internal.IgnitionEx; import org.apache.ignite.internal.processors.cache.portable.CacheObjectPortableProcessorImpl; @@ -61,12 +63,12 @@ import org.apache.ignite.lang.IgniteBiTuple; import org.apache.ignite.marshaller.MarshallerContext; import org.apache.ignite.marshaller.optimized.OptimizedMarshaller; import org.apache.ignite.marshaller.portable.PortableMarshaller; -import org.apache.ignite.portable.PortableException; -import org.apache.ignite.portable.PortableIdMapper; -import org.apache.ignite.portable.PortableInvalidClassException; -import org.apache.ignite.portable.PortableMetadata; -import org.apache.ignite.portable.PortableSerializer; -import org.apache.ignite.portable.PortableTypeConfiguration; +import org.apache.ignite.igniteobject.IgniteObjectException; +import org.apache.ignite.igniteobject.IgniteObjectIdMapper; +import org.apache.ignite.igniteobject.IgniteObjectInvalidClassException; +import org.apache.ignite.igniteobject.IgniteObjectMetadata; +import org.apache.ignite.igniteobject.IgniteObjectSerializer; +import org.apache.ignite.igniteobject.IgniteObjectConfiguration; import org.jetbrains.annotations.Nullable; import org.jsr166.ConcurrentHashMap8; @@ -78,10 +80,10 @@ public class PortableContext implements Externalizable { private static final long serialVersionUID = 0L; /** */ - static final PortableIdMapper DFLT_ID_MAPPER = new IdMapperWrapper(null); + static final IgniteObjectIdMapper DFLT_ID_MAPPER = new IdMapperWrapper(null); /** */ - static final PortableIdMapper BASIC_CLS_ID_MAPPER = new BasicClassIdMapper(); + static final IgniteObjectIdMapper BASIC_CLS_ID_MAPPER = new BasicClassIdMapper(); /** */ static final char[] LOWER_CASE_CHARS; @@ -121,10 +123,10 @@ public class PortableContext implements Externalizable { private final Map<Class<? extends Map>, Byte> mapTypes = new HashMap<>(); /** */ - private final Map<Integer, PortableIdMapper> mappers = new ConcurrentHashMap8<>(0); + private final Map<Integer, IgniteObjectIdMapper> mappers = new ConcurrentHashMap8<>(0); /** */ - private final Map<String, PortableIdMapper> typeMappers = new ConcurrentHashMap8<>(0); + private final Map<String, IgniteObjectIdMapper> typeMappers = new ConcurrentHashMap8<>(0); /** */ private Map<Integer, Boolean> metaEnabled = new HashMap<>(0); @@ -139,6 +141,9 @@ public class PortableContext implements Externalizable { private String gridName; /** */ + private IgniteConfiguration igniteCfg; + + /** */ private final OptimizedMarshaller optmMarsh = new OptimizedMarshaller(); /** */ @@ -159,13 +164,14 @@ public class PortableContext implements Externalizable { /** * @param metaHnd Meta data handler. - * @param gridName Grid name. + * @param igniteCfg Ignite configuration. */ - public PortableContext(PortableMetaDataHandler metaHnd, @Nullable String gridName) { + public PortableContext(PortableMetaDataHandler metaHnd, @Nullable IgniteConfiguration igniteCfg) { assert metaHnd != null; this.metaHnd = metaHnd; - this.gridName = gridName; + this.igniteCfg = igniteCfg; + gridName = igniteCfg.getGridName(); colTypes.put(ArrayList.class, GridPortableMarshaller.ARR_LIST); colTypes.put(LinkedList.class, GridPortableMarshaller.LINKED_LIST); @@ -232,15 +238,15 @@ public class PortableContext implements Externalizable { // IDs range [200..1000] is used by Ignite internal APIs. - registerPredefinedType(PortableObjectImpl.class, 200); - registerPredefinedType(PortableMetaDataImpl.class, 201); + registerPredefinedType(IgniteObjectImpl.class, 200); + registerPredefinedType(IgniteObjectMetaDataImpl.class, 201); } /** * @param marsh Portable marshaller. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - public void configure(PortableMarshaller marsh) throws PortableException { + public void configure(PortableMarshaller marsh) throws IgniteObjectException { if (marsh == null) return; @@ -271,20 +277,20 @@ public class PortableContext implements Externalizable { * @param globalKeepDeserialized Keep deserialized flag. * @param clsNames Class names. * @param typeCfgs Type configurations. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ private void configure( - PortableIdMapper globalIdMapper, - PortableSerializer globalSerializer, + IgniteObjectIdMapper globalIdMapper, + IgniteObjectSerializer globalSerializer, boolean globalMetaDataEnabled, boolean globalKeepDeserialized, Collection<String> clsNames, - Collection<PortableTypeConfiguration> typeCfgs - ) throws PortableException { + Collection<IgniteObjectConfiguration> typeCfgs + ) throws IgniteObjectException { TypeDescriptors descs = new TypeDescriptors(); if (clsNames != null) { - PortableIdMapper idMapper = new IdMapperWrapper(globalIdMapper); + IgniteObjectIdMapper idMapper = new IdMapperWrapper(globalIdMapper); for (String clsName : clsNames) { if (clsName.endsWith(".*")) { // Package wildcard @@ -300,21 +306,26 @@ public class PortableContext implements Externalizable { } } + Map<String, String> affFields = new HashMap<>(); + + for (CacheKeyConfiguration keyCfg : igniteCfg.getCacheKeyConfiguration()) + affFields.put(keyCfg.getTypeName(), keyCfg.getAffinityKeyFieldName()); + if (typeCfgs != null) { - for (PortableTypeConfiguration typeCfg : typeCfgs) { + for (IgniteObjectConfiguration typeCfg : typeCfgs) { String clsName = typeCfg.getClassName(); if (clsName == null) - throw new PortableException("Class name is required for portable type configuration."); + throw new IgniteObjectException("Class name is required for portable type configuration."); - PortableIdMapper idMapper = globalIdMapper; + IgniteObjectIdMapper idMapper = globalIdMapper; if (typeCfg.getIdMapper() != null) idMapper = typeCfg.getIdMapper(); idMapper = new IdMapperWrapper(idMapper); - PortableSerializer serializer = globalSerializer; + IgniteObjectSerializer serializer = globalSerializer; if (typeCfg.getSerializer() != null) serializer = typeCfg.getSerializer(); @@ -328,11 +339,11 @@ public class PortableContext implements Externalizable { String pkgName = clsName.substring(0, clsName.length() - 2); for (String clsName0 : classesInPackage(pkgName)) - descs.add(clsName0, idMapper, serializer, typeCfg.getAffinityKeyFieldName(), + descs.add(clsName0, idMapper, serializer, affFields.get(clsName0), metaDataEnabled, keepDeserialized, true); } else - descs.add(clsName, idMapper, serializer, typeCfg.getAffinityKeyFieldName(), + descs.add(clsName, idMapper, serializer, affFields.get(clsName), metaDataEnabled, keepDeserialized, false); } } @@ -414,10 +425,10 @@ public class PortableContext implements Externalizable { /** * @param cls Class. * @return Class descriptor. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ public PortableClassDescriptor descriptorForClass(Class<?> cls) - throws PortableException { + throws IgniteObjectException { assert cls != null; PortableClassDescriptor desc = descByCls.get(cls); @@ -461,10 +472,10 @@ public class PortableContext implements Externalizable { desc = descByCls.get(cls); } catch (ClassNotFoundException e) { - throw new PortableInvalidClassException(e); + throw new IgniteObjectInvalidClassException(e); } catch (IgniteCheckedException e) { - throw new PortableException("Failed resolve class for ID: " + typeId, e); + throw new IgniteObjectException("Failed resolve class for ID: " + typeId, e); } if (desc == null) { @@ -523,7 +534,7 @@ public class PortableContext implements Externalizable { String typeName = typeName(cls.getName()); - PortableIdMapper idMapper = idMapper(typeName); + IgniteObjectIdMapper idMapper = idMapper(typeName); int typeId = idMapper.typeId(typeName); @@ -531,7 +542,7 @@ public class PortableContext implements Externalizable { registered = marshCtx.registerClass(typeId, cls); } catch (IgniteCheckedException e) { - throw new PortableException("Failed to register class.", e); + throw new IgniteObjectException("Failed to register class.", e); } PortableClassDescriptor desc = new PortableClassDescriptor(this, @@ -616,8 +627,8 @@ public class PortableContext implements Externalizable { * @param typeId Type ID. * @return Instance of ID mapper. */ - public PortableIdMapper idMapper(int typeId) { - PortableIdMapper idMapper = mappers.get(typeId); + public IgniteObjectIdMapper idMapper(int typeId) { + IgniteObjectIdMapper idMapper = mappers.get(typeId); if (idMapper != null) return idMapper; @@ -632,15 +643,15 @@ public class PortableContext implements Externalizable { * @param typeName Type name. * @return Instance of ID mapper. */ - private PortableIdMapper idMapper(String typeName) { - PortableIdMapper idMapper = typeMappers.get(typeName); + private IgniteObjectIdMapper idMapper(String typeName) { + IgniteObjectIdMapper idMapper = typeMappers.get(typeName); return idMapper != null ? idMapper : DFLT_ID_MAPPER; } /** {@inheritDoc} */ @Override public void writeExternal(ObjectOutput out) throws IOException { - U.writeString(out, gridName); + U.writeString(out, igniteCfg.getGridName()); } /** {@inheritDoc} */ @@ -703,16 +714,16 @@ public class PortableContext implements Externalizable { * @param affKeyFieldName Affinity key field name. * @param metaDataEnabled Metadata enabled flag. * @param keepDeserialized Keep deserialized flag. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ @SuppressWarnings("ErrorNotRethrown") public void registerUserType(String clsName, - PortableIdMapper idMapper, - @Nullable PortableSerializer serializer, + IgniteObjectIdMapper idMapper, + @Nullable IgniteObjectSerializer serializer, @Nullable String affKeyFieldName, boolean metaDataEnabled, boolean keepDeserialized) - throws PortableException { + throws IgniteObjectException { assert idMapper != null; Class<?> cls = null; @@ -728,10 +739,10 @@ public class PortableContext implements Externalizable { //Workaround for IGNITE-1358 if (predefinedTypes.get(id) != null) - throw new PortableException("Duplicate type ID [clsName=" + clsName + ", id=" + id + ']'); + throw new IgniteObjectException("Duplicate type ID [clsName=" + clsName + ", id=" + id + ']'); if (mappers.put(id, idMapper) != null) - throw new PortableException("Duplicate type ID [clsName=" + clsName + ", id=" + id + ']'); + throw new IgniteObjectException("Duplicate type ID [clsName=" + clsName + ", id=" + id + ']'); String typeName = typeName(clsName); @@ -762,15 +773,15 @@ public class PortableContext implements Externalizable { descByCls.put(cls, desc); } - metaHnd.addMeta(id, new PortableMetaDataImpl(typeName, fieldsMeta, affKeyFieldName)); + metaHnd.addMeta(id, new IgniteObjectMetaDataImpl(typeName, fieldsMeta, affKeyFieldName)); } /** * @param typeId Type ID. * @return Meta data. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - @Nullable public PortableMetadata metaData(int typeId) throws PortableException { + @Nullable public IgniteObjectMetadata metaData(int typeId) throws IgniteObjectException { return metaHnd != null ? metaHnd.metadata(typeId) : null; } @@ -809,18 +820,18 @@ public class PortableContext implements Externalizable { * @param typeId Type ID. * @param typeName Type name. * @param fields Fields map. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - public void updateMetaData(int typeId, String typeName, Map<String, String> fields) throws PortableException { - updateMetaData(typeId, new PortableMetaDataImpl(typeName, fields, null)); + public void updateMetaData(int typeId, String typeName, Map<String, String> fields) throws IgniteObjectException { + updateMetaData(typeId, new IgniteObjectMetaDataImpl(typeName, fields, null)); } /** * @param typeId Type ID. * @param meta Meta data. - * @throws PortableException In case of error. + * @throws org.apache.ignite.igniteobject.IgniteObjectException In case of error. */ - public void updateMetaData(int typeId, PortableMetaDataImpl meta) throws PortableException { + public void updateMetaData(int typeId, IgniteObjectMetaDataImpl meta) throws IgniteObjectException { metaHnd.addMeta(typeId, meta); } @@ -894,14 +905,14 @@ public class PortableContext implements Externalizable { /** */ - private static class IdMapperWrapper implements PortableIdMapper { + private static class IdMapperWrapper implements IgniteObjectIdMapper { /** */ - private final PortableIdMapper mapper; + private final IgniteObjectIdMapper mapper; /** * @param mapper Custom ID mapper. */ - private IdMapperWrapper(@Nullable PortableIdMapper mapper) { + private IdMapperWrapper(@Nullable IgniteObjectIdMapper mapper) { this.mapper = mapper; } @@ -929,7 +940,7 @@ public class PortableContext implements Externalizable { /** * Basic class ID mapper. */ - private static class BasicClassIdMapper implements PortableIdMapper { + private static class BasicClassIdMapper implements IgniteObjectIdMapper { /** {@inheritDoc} */ @Override public int typeId(String clsName) { return clsName.hashCode(); @@ -958,16 +969,16 @@ public class PortableContext implements Externalizable { * @param metadataEnabled Metadata enabled flag. * @param keepDeserialized Keep deserialized flag. * @param canOverride Whether this descriptor can be override. - * @throws PortableException If failed. + * @throws org.apache.ignite.igniteobject.IgniteObjectException If failed. */ private void add(String clsName, - PortableIdMapper idMapper, - PortableSerializer serializer, + IgniteObjectIdMapper idMapper, + IgniteObjectSerializer serializer, String affKeyFieldName, boolean metadataEnabled, boolean keepDeserialized, boolean canOverride) - throws PortableException { + throws IgniteObjectException { TypeDescriptor desc = new TypeDescriptor(clsName, idMapper, serializer, @@ -1002,10 +1013,10 @@ public class PortableContext implements Externalizable { private final String clsName; /** ID mapper. */ - private PortableIdMapper idMapper; + private IgniteObjectIdMapper idMapper; /** Serializer. */ - private PortableSerializer serializer; + private IgniteObjectSerializer serializer; /** Affinity key field name. */ private String affKeyFieldName; @@ -1030,7 +1041,7 @@ public class PortableContext implements Externalizable { * @param keepDeserialized Keep deserialized flag. * @param canOverride Whether this descriptor can be override. */ - private TypeDescriptor(String clsName, PortableIdMapper idMapper, PortableSerializer serializer, + private TypeDescriptor(String clsName, IgniteObjectIdMapper idMapper, IgniteObjectSerializer serializer, String affKeyFieldName, boolean metadataEnabled, boolean keepDeserialized, boolean canOverride) { this.clsName = clsName; @@ -1046,9 +1057,9 @@ public class PortableContext implements Externalizable { * Override portable class descriptor. * * @param other Other descriptor. - * @throws PortableException If failed. + * @throws org.apache.ignite.igniteobject.IgniteObjectException If failed. */ - private void override(TypeDescriptor other) throws PortableException { + private void override(TypeDescriptor other) throws IgniteObjectException { assert clsName.equals(other.clsName); if (canOverride) { @@ -1060,7 +1071,7 @@ public class PortableContext implements Externalizable { canOverride = other.canOverride; } else if (!other.canOverride) - throw new PortableException("Duplicate explicit class definition in configuration: " + clsName); + throw new IgniteObjectException("Duplicate explicit class definition in configuration: " + clsName); } }
