}

    /**
     * Gets the file information from the response cast to the specified type.
     *
     * @param <T> the type of file information to return
     * @param type the class of the file information to return
     * @return the info cast to the specified type
     * @throws CIFSException if the information cannot be cast to the specified type
     */
    @SuppressWarnings("unchecked")

     */
    public static Class<?> getRawClass(final Type type) {
        return switch (type) {
        case Class<?> clazz -> clazz;
        case ParameterizedType paramType -> getRawClass(paramType.getRawType());
        case WildcardType wildcard -> getRawClass(wildcard.getUpperBounds()[0]);
        case GenericArrayType arrayType -> {
            Class<?> rawClass = getRawClass(arrayType.getGenericComponentType());

    }

    /**
     * Gets the file system information from the response cast to the specified type.
     *
     * @param <T> the type of file system information to return
     * @param clazz the class of the file system information to return
     * @return the filesystem info cast to the specified type
     * @throws CIFSException if the information cannot be cast to the specified type
     */
    @SuppressWarnings("unchecked")

	funcName := e.getFunctionName()

	switch funcName {
	case sqlFnCast:
		return e.Cast.Expr.analyze(s)

	case sqlFnExtract:
		return e.Extract.From.analyze(s)

	case sqlFnDateAdd:
		result.combine(e.DateAdd.Quantity.analyze(s))
		result.combine(e.DateAdd.Timestamp.analyze(s))
		return result

	case sqlFnDateDiff:
		result.combine(e.DateDiff.Timestamp1.analyze(s))

		message:    "The SQL expression contains an unsupported use of CASE.",
		statusCode: 400,
		cause:      err,
	}
}

func errParseUnsupportedCaseClause(err error) *s3Error {
	return &s3Error{
		code:       "ParseUnsupportedCaseClause",
		message:    "The SQL expression contains an unsupported use of CASE.",
		statusCode: 400,
		cause:      err,
	}
}

  <K extends T, V> Map<K, V> createMap(int expectedSize) {
    switch (type) {
      case UNORDERED:
        return Maps.newHashMapWithExpectedSize(expectedSize);
      case INSERTION:
      case STABLE:
        return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
      case SORTED:
        return Maps.newTreeMap(comparator());
    }
    throw new AssertionError();
  }

  <K extends T, V> Map<K, V> createMap(int expectedSize) {
    switch (type) {
      case UNORDERED:
        return Maps.newHashMapWithExpectedSize(expectedSize);
      case INSERTION:
      case STABLE:
        return Maps.newLinkedHashMapWithExpectedSize(expectedSize);
      case SORTED:
        return Maps.newTreeMap(comparator());
    }
    throw new AssertionError();
  }

      return 0;
    }
    // The cast is safe because we call this method only if hasLowerBound().
    int cmp =
        comparator()
            .compare(uncheckedCastNullableTToT(range.getLowerEndpoint()), node.getElement());
    if (cmp < 0) {
      return aggregateBelowRange(aggr, node.left);
    } else if (cmp == 0) {
      switch (range.getLowerBoundType()) {
        case OPEN:

      return 0;
    }
    // The cast is safe because we call this method only if hasLowerBound().
    int cmp =
        comparator()
            .compare(uncheckedCastNullableTToT(range.getLowerEndpoint()), node.getElement());
    if (cmp < 0) {
      return aggregateBelowRange(aggr, node.left);
    } else if (cmp == 0) {
      switch (range.getLowerBoundType()) {
        case OPEN:

	case BucketAlreadyExists:
		apiErr = ErrBucketAlreadyExists
	case BucketExists:
		apiErr = ErrBucketAlreadyOwnedByYou
	case ObjectNotFound:
		apiErr = ErrNoSuchKey
	case MethodNotAllowed:
		apiErr = ErrMethodNotAllowed
	case ObjectLocked:
		apiErr = ErrObjectLocked
	case InvalidVersionID:
		apiErr = ErrInvalidVersionID
	case VersionNotFound:
		apiErr = ErrNoSuchVersion
	case ObjectAlreadyExists: