private void generateMetadataIndexWithOffset()

in tsfile-viewer-core/src/main/java/org/apache/iotdb/tool/core/service/TsFileAnalyserV13.java [1402:1519]
113 lines of code
18 McCabe index (conditional complexity)

    private void generateMetadataIndexWithOffset(
        long startOffset,
        MetadataIndexEntry metadataIndex,
        ByteBuffer buffer,
        String deviceId,
        MetadataIndexNodeType type,
        Map<Long, Pair<Path, ITimeSeriesMetadata>> timeseriesMetadataMap,
        TimeSeriesMetadataNode tsNode,
        boolean needChunkMetadata)
        throws IOException {
      try {
        if (type.equals(MetadataIndexNodeType.LEAF_MEASUREMENT)) {
          TimeseriesMetadata alignedTime = null;
          List<TimeseriesMetadata> alignedValues = new ArrayList<>();
          AlignedTimeSeriesMetadata alignedTimeSeriesMetadata = null;
          boolean aligned = true;
          while (buffer.hasRemaining()) {
            long pos = startOffset + buffer.position();
            TimeseriesMetadata timeseriesMetadata =
                TimeseriesMetadata.deserializeFrom(buffer, needChunkMetadata);
            // 判断是否对其时间序列
            if ((timeseriesMetadata.getTimeSeriesMetadataType() & TsFileConstant.TIME_COLUMN_MASK)
                == TsFileConstant.TIME_COLUMN_MASK) {
              if (aligned && alignedTime != null && alignedValues.size() > 0) {
                leafNodeWithAligned(
                    alignedTime,
                    alignedValues,
                    startOffset + buffer.position(),
                    deviceId,
                    tsNode,
                    type,
                    timeseriesMetadataMap);
              }
              aligned = true;
              alignedTime = new TimeseriesMetadata(timeseriesMetadata);
            } else if ((timeseriesMetadata.getTimeSeriesMetadataType()
                    & TsFileConstant.VALUE_COLUMN_MASK)
                == TsFileConstant.VALUE_COLUMN_MASK) {
              alignedValues.add(timeseriesMetadata);
            } else {

              if (aligned && alignedTime != null && alignedValues.size() > 0) {
                leafNodeWithAligned(
                    alignedTime,
                    alignedValues,
                    startOffset + buffer.position(),
                    deviceId,
                    tsNode,
                    type,
                    timeseriesMetadataMap);
              }

              timeseriesMetadataMap.put(
                  pos,
                  new Pair<>(
                      new Path(deviceId, timeseriesMetadata.getMeasurementId()),
                      timeseriesMetadata));
              TimeSeriesMetadataNode leafNode = new TimeSeriesMetadataNode();
              leafNode.setChildren(new ArrayList<>());
              leafNode.setPosition(pos);
              leafNode.setDeviceId(deviceId);
              leafNode.setMeasurementId(timeseriesMetadata.getMeasurementId());
              leafNode.setTimeseriesMetadata(timeseriesMetadata);
              allCount += timeseriesMetadata.getStatistics().getCount();
              leafNode.setNodeType(type);
              tsNode.getChildren().add(leafNode);
              aligned = false;
            }
          }
          if (aligned && alignedTime != null && alignedValues.size() > 0) {
            leafNodeWithAligned(
                alignedTime,
                alignedValues,
                startOffset + buffer.position(),
                deviceId,
                tsNode,
                type,
                timeseriesMetadataMap);
          }

          tsNode.setNodeType(type);
          tsNode.setPosition(startOffset + buffer.position());
          tsNode.setDeviceId(deviceId);
        } else {
          // deviceId should be determined by LEAF_DEVICE node
          if (type.equals(MetadataIndexNodeType.LEAF_DEVICE)) {
            deviceId = metadataIndex.getName();
          }
          MetadataIndexNode metadataIndexNode = MetadataIndexNode.deserializeFrom(buffer);
          int metadataIndexListSize = metadataIndexNode.getChildren().size();
          for (int i = 0; i < metadataIndexListSize; i++) {
            long endOffset = metadataIndexNode.getEndOffset();
            if (i != metadataIndexListSize - 1) {
              endOffset = metadataIndexNode.getChildren().get(i + 1).getOffset();
            }
            ByteBuffer nextBuffer =
                readData(metadataIndexNode.getChildren().get(i).getOffset(), endOffset);
            TimeSeriesMetadataNode tsChildNode = new TimeSeriesMetadataNode();
            generateMetadataIndexWithOffset(
                metadataIndexNode.getChildren().get(i).getOffset(),
                metadataIndexNode.getChildren().get(i),
                nextBuffer,
                deviceId,
                metadataIndexNode.getNodeType(),
                timeseriesMetadataMap,
                tsChildNode,
                needChunkMetadata);
            tsNode.getChildren().add(tsChildNode);
          }
          tsNode.setDeviceId(deviceId);
          tsNode.setPosition(startOffset + buffer.position());
          tsNode.setNodeType(type);
        }
      } catch (BufferOverflowException e) {
        logger.error("Unrecognized metadataIndexNode type, type:{}", type);
        throw e;
      }
    }