public Object parseValue()

in modules/core/src/main/java/org/apache/ignite/internal/binary/builder/BinaryBuilderReader.java [517:877]
234 lines of code
64 McCabe index (conditional complexity)

    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();

                Object res = objMap.get(objStart);

                if (res != null)
                    return res;

                // Read handle by position
                int savedPos = pos;
                pos = objStart;

                res = parseValue();

                pos = savedPos;

                objMap.put(objStart, res);

                return res;
            }

            case GridBinaryMarshaller.OBJ: {
                pos--;

                Object 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.TIME:
                plainLazyValLen = 8;

                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.TIME_ARR: {
                int size = readInt();

                Time[] res = new Time[size];

                for (int i = 0; i < res.length; i++) {
                    byte flag = arr[pos++];

                    if (flag == GridBinaryMarshaller.NULL) continue;

                    if (flag != GridBinaryMarshaller.TIME)
                        throw new BinaryObjectException("Invalid flag value: " + flag);

                    long time = BinaryPrimitives.readLong(arr, pos);

                    pos += 8;

                    res[i] = new Time(time);
                }

                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++];

                Object res = objMap.get(valPos);
                Object parseRes;

                switch (colType) {
                    case GridBinaryMarshaller.USER_COL:
                    case GridBinaryMarshaller.ARR_LIST:
                        parseRes = new BinaryLazyArrayList(this, size);

                        break;

                    case GridBinaryMarshaller.LINKED_LIST:
                        parseRes = new BinaryLazyLinkedList(this, size);

                        break;

                    case GridBinaryMarshaller.HASH_SET:
                    case GridBinaryMarshaller.LINKED_HASH_SET:
                        parseRes = new BinaryLazySet(this, size);

                        break;

                    default:
                        throw new BinaryObjectException("Unknown collection type: " + colType);
                }

                if (res == null || res instanceof LazyCollection) {
                    objMap.put(valPos, parseRes);

                    res = parseRes;
                }

                return res;
            }

            case GridBinaryMarshaller.MAP: {
                Object res = objMap.get(valPos);
                Object parseRes = BinaryLazyMap.parseMap(this);

                if (res == null || res instanceof LazyCollection) {
                    objMap.put(valPos, parseRes);

                    res = parseRes;
                }

                return res;
            }

            case GridBinaryMarshaller.ENUM:
                return new BinaryBuilderEnum(this);

            case GridBinaryMarshaller.ENUM_ARR:
                return new BinaryEnumArrayLazyValue(this);

            case GridBinaryMarshaller.BINARY_OBJ: {
                int size = readInt();

                pos += size;

                int start = readInt();

                BinaryObject binaryObj = BinaryUtils.binaryObject(ctx, arr, pos - 4 - size + start);

                return new BinaryPlainBinaryObject(binaryObj);
            }

            case GridBinaryMarshaller.OPTM_MARSH: {
                final BinaryInputStream bin = BinaryStreams.inputStream(arr, pos);

                final Object obj = BinaryUtils.doReadOptimized(bin, ctx, U.resolveClassLoader(ctx.configuration()));

                pos = bin.position();

                return obj;
            }

            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;
    }