void FlatVector::copyValuesAndNulls()

in velox/vector/FlatVector-inl.h [137:212]
76 lines of code
23 McCabe index (conditional complexity)

void FlatVector<T>::copyValuesAndNulls(
    const BaseVector* source,
    const SelectivityVector& rows,
    const vector_size_t* toSourceRow) {
  source = source->loadedVector();
  VELOX_CHECK(
      BaseVector::compatibleKind(BaseVector::typeKind(), source->typeKind()));
  VELOX_CHECK_GE(BaseVector::length_, rows.end());
  SelectivityIterator iter(rows);
  vector_size_t row;
  const uint64_t* sourceNulls = source->rawNulls();
  uint64_t* rawNulls = const_cast<uint64_t*>(BaseVector::rawNulls_);
  if (source->mayHaveNulls()) {
    rawNulls = BaseVector::mutableRawNulls();
  }
  if (source->encoding() == VectorEncoding::Simple::FLAT) {
    auto flat = source->asUnchecked<FlatVector<T>>();
    auto* sourceValues =
        source->typeKind() != TypeKind::UNKNOWN ? flat->rawValues() : nullptr;
    if (toSourceRow) {
      while (iter.next(row)) {
        auto sourceRow = toSourceRow[row];
        if (sourceValues) {
          rawValues_[row] = sourceValues[sourceRow];
        }
        if (rawNulls) {
          bits::setNull(
              rawNulls,
              row,
              sourceNulls && bits::isBitNull(sourceNulls, sourceRow));
        }
      }
    } else {
      VELOX_CHECK_GE(source->size(), rows.end());
      while (iter.next(row)) {
        if (sourceValues) {
          rawValues_[row] = sourceValues[row];
        }
        if (rawNulls) {
          bits::setNull(
              rawNulls, row, sourceNulls && bits::isBitNull(sourceNulls, row));
        }
      }
    }
  } else if (source->isConstantEncoding()) {
    if (source->isNullAt(0)) {
      BaseVector::addNulls(nullptr, rows);
      return;
    }
    auto constant = source->asUnchecked<ConstantVector<T>>();
    T value = constant->valueAt(0);
    while (iter.next(row)) {
      rawValues_[row] = value;
    }
    if (rawNulls) {
      bits::orBits(rawNulls, rows.asRange().bits(), rows.begin(), rows.end());
    }
  } else {
    auto sourceVector = source->typeKind() != TypeKind::UNKNOWN
        ? source->asUnchecked<SimpleVector<T>>()
        : nullptr;
    while (iter.next(row)) {
      auto sourceRow = toSourceRow ? toSourceRow[row] : row;
      if (!source->isNullAt(sourceRow)) {
        if (sourceVector) {
          rawValues_[row] = sourceVector->valueAt(sourceRow);
        }
        if (rawNulls) {
          bits::clearNull(rawNulls, row);
        }
      } else {
        bits::setNull(rawNulls, row);
      }
    }
  }
}