Method Make

cpp/src/parquet/page_index.cc:964–1008

// Public factory functions

std::unique_ptr<ColumnIndex> ColumnIndex::Make(const ColumnDescriptor& descr,
                                               const void* serialized_index,
                                               uint32_t index_len,
                                               const ReaderProperties& properties,
                                               Decryptor* decryptor) {
  format::ColumnIndex column_index;
  ThriftDeserializer deserializer(properties);
  deserializer.DeserializeMessage(reinterpret_cast<const uint8_t*>(serialized_index),
                                  &index_len, &column_index, decryptor);
  if (ARROW_PREDICT_FALSE(LoadEnumSafe(&column_index.boundary_order) ==
                          BoundaryOrder::UNDEFINED)) {
    // Guard against UB when moving column_index
    throw ParquetException("Invalid ColumnIndex boundary_order");
  }
  switch (descr.physical_type()) {
    case Type::BOOLEAN:
      return std::make_unique<TypedColumnIndexImpl<BooleanType>>(descr,
                                                                 std::move(column_index));
    case Type::INT32:
      return std::make_unique<TypedColumnIndexImpl<Int32Type>>(descr,
                                                               std::move(column_index));
    case Type::INT64:
      return std::make_unique<TypedColumnIndexImpl<Int64Type>>(descr,
                                                               std::move(column_index));
    case Type::INT96:
      return std::make_unique<TypedColumnIndexImpl<Int96Type>>(descr,
                                                               std::move(column_index));
    case Type::FLOAT:
      return std::make_unique<TypedColumnIndexImpl<FloatType>>(descr,
                                                               std::move(column_index));
    case Type::DOUBLE:
      return std::make_unique<TypedColumnIndexImpl<DoubleType>>(descr,
                                                                std::move(column_index));
    case Type::BYTE_ARRAY:
      return std::make_unique<TypedColumnIndexImpl<ByteArrayType>>(
          descr, std::move(column_index));
    case Type::FIXED_LEN_BYTE_ARRAY:
      return std::make_unique<TypedColumnIndexImpl<FLBAType>>(descr,
                                                              std::move(column_index));
    case Type::UNDEFINED:
      return nullptr;
  }
  ::arrow::Unreachable("Cannot make ColumnIndex of an unknown type");
  return nullptr;
}

std::unique_ptr<OffsetIndex> OffsetIndex::Make(const void* serialized_index,
                                               uint32_t index_len,