private int copyObjectField()

in hollow/src/main/java/com/netflix/hollow/core/write/objectmapper/flatrecords/FlatRecordDumper.java [186:284]
81 lines of code
27 McCabe index (conditional complexity)

    private int copyObjectField(HollowObjectWriteRecord rec, String fieldName, FieldType fieldType, int currentRecordPointer) {
        switch(fieldType) {
        case BOOLEAN:
            if(!VarInt.readVNull(record.data, currentRecordPointer)) {
                boolean value = record.data.get(currentRecordPointer) == 1;
                if(rec != null)
                    rec.setBoolean(fieldName, value);
            }
            
            return currentRecordPointer + 1;
        case INT:
            if(VarInt.readVNull(record.data, currentRecordPointer))
                return currentRecordPointer + 1;

            int ivalue = VarInt.readVInt(record.data, currentRecordPointer);
            currentRecordPointer += VarInt.sizeOfVInt(ivalue);
            if(rec != null)
                rec.setInt(fieldName, ZigZag.decodeInt(ivalue));
            
            return currentRecordPointer;
        case LONG:
            if(VarInt.readVNull(record.data, currentRecordPointer))
                return currentRecordPointer + 1;

            long lvalue = VarInt.readVLong(record.data, currentRecordPointer);
            currentRecordPointer += VarInt.sizeOfVLong(lvalue);
            if(rec != null)
                rec.setLong(fieldName, ZigZag.decodeLong(lvalue));
            
            return currentRecordPointer;
        case FLOAT:
            int intBits = record.data.readIntBits(currentRecordPointer);
            if(intBits != HollowObjectWriteRecord.NULL_FLOAT_BITS) {
                float fvalue = Float.intBitsToFloat(intBits);
                if(rec != null)
                    rec.setFloat(fieldName, fvalue);
            }
            
            return currentRecordPointer + 4;
        case DOUBLE:
            long longBits = record.data.readLongBits(currentRecordPointer);
            if(longBits != HollowObjectWriteRecord.NULL_DOUBLE_BITS) {
                double dvalue = Double.longBitsToDouble(longBits);
                if(rec != null)
                    rec.setDouble(fieldName, dvalue);
            }
            
            return currentRecordPointer + 8;
        case STRING:
            if(VarInt.readVNull(record.data, currentRecordPointer))
                return currentRecordPointer + 1;
            
            int length = VarInt.readVInt(record.data, currentRecordPointer);
            currentRecordPointer += VarInt.sizeOfVInt(length);
            
            int cLength = VarInt.countVarIntsInRange(record.data, currentRecordPointer, length);
            char[] s = new char[cLength];
            
            for(int i=0;i<cLength;i++) {
                int charValue = VarInt.readVInt(record.data, currentRecordPointer); 
                s[i] = (char)charValue;
                currentRecordPointer += VarInt.sizeOfVInt(charValue);
            }
            
            if(rec != null)
                rec.setString(fieldName, new String(s));
            return currentRecordPointer;
        case BYTES:
            if(VarInt.readVNull(record.data, currentRecordPointer))
                return currentRecordPointer + 1;
            
            length = VarInt.readVInt(record.data, currentRecordPointer);
            currentRecordPointer += VarInt.sizeOfVInt(length);
            byte[] b = new byte[length];
            
            for(int i=0;i<length;i++) {
                b[i] = record.data.get(currentRecordPointer++);
            }

            if(rec != null)
                rec.setBytes(fieldName, b);
            return currentRecordPointer;
        case REFERENCE:
            if(VarInt.readVNull(record.data, currentRecordPointer))
                return currentRecordPointer + 1;
            
            int unmappedOrdinal = VarInt.readVInt(record.data, currentRecordPointer);
            
            if(rec != null) {
                int mappedOrdinal = ordinalMapping.get(unmappedOrdinal);
                rec.setReference(fieldName, mappedOrdinal);
            }
            
            return currentRecordPointer + VarInt.sizeOfVInt(unmappedOrdinal);
        default:
            throw new IllegalArgumentException("Unknown field type: " + fieldType);
        }
        
    }