Method create

bolt/type/Type.cpp:173–222

} // namespace

TypePtr Type::create(const folly::dynamic& obj) {
  std::vector<TypePtr> childTypes;
  if (obj.find("cTypes") != obj.items().end()) {
    childTypes = deserializeChildTypes(obj);
  }

  auto typeName = obj["type"].asString();
  if (isDecimalName(typeName)) {
    return DECIMAL(obj["precision"].asInt(), obj["scale"].asInt());
  }
  // Checks if 'typeName' specifies a custom type.
  if (customTypeExists(typeName)) {
    return getCustomType(typeName);
  }

  // 'typeName' must be a built-in type.
  TypeKind typeKind = mapNameToTypeKind(typeName);
  switch (typeKind) {
    case TypeKind::ROW: {
      BOLT_USER_CHECK(obj["names"].isArray());
      std::vector<std::string> names;
      for (const auto& name : obj["names"]) {
        names.push_back(name.asString());
      }

      return std::make_shared<const RowType>(
          std::move(names), std::move(childTypes));
    }

    case TypeKind::OPAQUE: {
      const auto& persistentName = obj["opaque"].asString();
      const auto& registry = OpaqueSerdeRegistry::get();
      auto it = registry.reverse.find(persistentName);
      BOLT_USER_CHECK(
          it != registry.reverse.end(),
          "Opaque type with persistent name '{}' is not registered",
          persistentName);
      if (auto withExtra = it->second->deserializeExtra(obj)) {
        return withExtra;
      }
      return it->second;
    }
    case TypeKind::VARIANT: {
      return VARIANT();
    }
    default: {
      return createType(typeKind, std::move(childTypes));
    }
  }
}

// static
void Type::registerSerDe() {