private SegmentInfo parseSegmentInfo()

in lucene/backward-codecs/src/java/org/apache/lucene/backward_codecs/lucene70/Lucene70SegmentInfoFormat.java [128:318]
185 lines of code
46 McCabe index (conditional complexity)

  private SegmentInfo parseSegmentInfo(
      Directory dir, DataInput input, String segment, byte[] segmentID) throws IOException {
    final Version version = Version.fromBits(input.readInt(), input.readInt(), input.readInt());
    byte hasMinVersion = input.readByte();
    final Version minVersion;
    switch (hasMinVersion) {
      case 0:
        minVersion = null;
        break;
      case 1:
        minVersion = Version.fromBits(input.readInt(), input.readInt(), input.readInt());
        break;
      default:
        throw new CorruptIndexException("Illegal boolean value " + hasMinVersion, input);
    }

    final int docCount = input.readInt();
    if (docCount < 0) {
      throw new CorruptIndexException("invalid docCount: " + docCount, input);
    }
    final boolean isCompoundFile = input.readByte() == SegmentInfo.YES;

    final Map<String, String> diagnostics = input.readMapOfStrings();
    final Set<String> files = input.readSetOfStrings();
    final Map<String, String> attributes = input.readMapOfStrings();

    int numSortFields = input.readVInt();
    Sort indexSort;
    if (numSortFields > 0) {
      SortField[] sortFields = new SortField[numSortFields];
      for (int i = 0; i < numSortFields; i++) {
        String fieldName = input.readString();
        int sortTypeID = input.readVInt();
        SortField.Type sortType;
        SortedSetSelector.Type sortedSetSelector = null;
        SortedNumericSelector.Type sortedNumericSelector = null;
        switch (sortTypeID) {
          case 0:
            sortType = SortField.Type.STRING;
            break;
          case 1:
            sortType = SortField.Type.LONG;
            break;
          case 2:
            sortType = SortField.Type.INT;
            break;
          case 3:
            sortType = SortField.Type.DOUBLE;
            break;
          case 4:
            sortType = SortField.Type.FLOAT;
            break;
          case 5:
            sortType = SortField.Type.STRING;
            byte selector = input.readByte();
            if (selector == 0) {
              sortedSetSelector = SortedSetSelector.Type.MIN;
            } else if (selector == 1) {
              sortedSetSelector = SortedSetSelector.Type.MAX;
            } else if (selector == 2) {
              sortedSetSelector = SortedSetSelector.Type.MIDDLE_MIN;
            } else if (selector == 3) {
              sortedSetSelector = SortedSetSelector.Type.MIDDLE_MAX;
            } else {
              throw new CorruptIndexException(
                  "invalid index SortedSetSelector ID: " + selector, input);
            }
            break;
          case 6:
            byte type = input.readByte();
            if (type == 0) {
              sortType = SortField.Type.LONG;
            } else if (type == 1) {
              sortType = SortField.Type.INT;
            } else if (type == 2) {
              sortType = SortField.Type.DOUBLE;
            } else if (type == 3) {
              sortType = SortField.Type.FLOAT;
            } else {
              throw new CorruptIndexException(
                  "invalid index SortedNumericSortField type ID: " + type, input);
            }
            byte numericSelector = input.readByte();
            if (numericSelector == 0) {
              sortedNumericSelector = SortedNumericSelector.Type.MIN;
            } else if (numericSelector == 1) {
              sortedNumericSelector = SortedNumericSelector.Type.MAX;
            } else {
              throw new CorruptIndexException(
                  "invalid index SortedNumericSelector ID: " + numericSelector, input);
            }
            break;
          default:
            throw new CorruptIndexException(
                "invalid index sort field type ID: " + sortTypeID, input);
        }
        byte b = input.readByte();
        boolean reverse;
        if (b == 0) {
          reverse = true;
        } else if (b == 1) {
          reverse = false;
        } else {
          throw new CorruptIndexException("invalid index sort reverse: " + b, input);
        }

        if (sortedSetSelector != null) {
          sortFields[i] = new SortedSetSortField(fieldName, reverse, sortedSetSelector);
        } else if (sortedNumericSelector != null) {
          sortFields[i] =
              new SortedNumericSortField(fieldName, sortType, reverse, sortedNumericSelector);
        } else {
          sortFields[i] = new SortField(fieldName, sortType, reverse);
        }

        Object missingValue;
        b = input.readByte();
        if (b == 0) {
          missingValue = null;
        } else {
          switch (sortType) {
            case STRING:
              if (b == 1) {
                missingValue = SortField.STRING_LAST;
              } else if (b == 2) {
                missingValue = SortField.STRING_FIRST;
              } else {
                throw new CorruptIndexException("invalid missing value flag: " + b, input);
              }
              break;
            case LONG:
              if (b != 1) {
                throw new CorruptIndexException("invalid missing value flag: " + b, input);
              }
              missingValue = input.readLong();
              break;
            case INT:
              if (b != 1) {
                throw new CorruptIndexException("invalid missing value flag: " + b, input);
              }
              missingValue = input.readInt();
              break;
            case DOUBLE:
              if (b != 1) {
                throw new CorruptIndexException("invalid missing value flag: " + b, input);
              }
              missingValue = Double.longBitsToDouble(input.readLong());
              break;
            case FLOAT:
              if (b != 1) {
                throw new CorruptIndexException("invalid missing value flag: " + b, input);
              }
              missingValue = Float.intBitsToFloat(input.readInt());
              break;
            case CUSTOM:
            case DOC:
            case REWRITEABLE:
            case STRING_VAL:
            case SCORE:
            default:
              throw new AssertionError("unhandled sortType=" + sortType);
          }
        }
        if (missingValue != null) {
          sortFields[i].setMissingValue(missingValue);
        }
      }
      indexSort = new Sort(sortFields);
    } else if (numSortFields < 0) {
      throw new CorruptIndexException("invalid index sort field count: " + numSortFields, input);
    } else {
      indexSort = null;
    }

    SegmentInfo si =
        new SegmentInfo(
            dir,
            version,
            minVersion,
            segment,
            docCount,
            isCompoundFile,
            false,
            null,
            diagnostics,
            segmentID,
            attributes,
            indexSort);
    si.setFiles(files);
    return si;
  }