modelNode.addProjection(new SpecializedModelMapProjection<T, E>(schema.getType(), schema.getElementType(), implementationType, strategyAccessor));
                        modelNode.addProjection(ModelMapModelProjection.managed(schema.getType(), schema.getElementType(), strategyAccessor));
                    }
                }
            ))

  if (!tensorType) return false;
  return tensorType.getElementType().isF32();
}

// Returns true iff the given value is a bf16 tensor.
inline bool TFTypeIsBFloat16Tensor(Value value) {
  auto tensorType = mlir::dyn_cast<TensorType>(value.getType());
  if (!tensorType) return false;
  return tensorType.getElementType().isBF16();
}

// Returns true iff the given value is a f16 tensor.

                           .getElementType()
                           .cast<ResourceType>();
  if (resource_type.getSubtypes().size() == 1)
    return resource_type.getSubtypes().front();

  return UnrankedTensorType::get(element_type);
}

static bool HasResourceSubtype(Value resource) {
  return resource.getType()
             .cast<TensorType>()
             .getElementType()
             .cast<ResourceType>()

    IntegerAttr attr = IntegerAttr::get(int_ty, raw_value);
    return DenseElementsAttr::get(scalar_ty, attr);
  } else if (auto complex_ty = mlir::dyn_cast<ComplexType>(ty)) {
    Type complex_element_ty = complex_ty.getElementType();
    if (complex_element_ty.isF32()) {
      return DenseElementsAttr::get(
          scalar_ty, static_cast<std::complex<float>>(raw_value));
    } else if (complex_element_ty.isF64()) {

                .put(ModelActionRole.Discover, AddProjectionsAction.of(subject, descriptor,
                    TypedModelProjection.of(
                        ModelTypes.modelSet(schema.getElementType()),
                        new ModelSetModelViewFactory<E>(schema.getElementType())
                    )
                ))
                .put(ModelActionRole.Create, DirectNodeInputUsingModelAction.of(subject, descriptor,

    return tflite::TensorType_STRING;
  } else if (auto complex_type = mlir::dyn_cast<mlir::ComplexType>(type)) {
    if (complex_type.getElementType().isF32()) {
      return tflite::TensorType_COMPLEX64;
    } else if (complex_type.getElementType().isF64()) {
      return tflite::TensorType_COMPLEX128;
    }
    llvm_unreachable("invalid complex Type in conversion");

    auto splat_elements_attr =
        mlir::dyn_cast<SplatElementsAttr>(const_op.getValue());
    if (!splat_elements_attr) {
      return;
    }
    auto element_type = splat_elements_attr.getType().getElementType();
    if (!(element_type.isF32() || element_type.isF16() ||
          element_type.isInteger(1) || element_type.isInteger(32) ||
          element_type.isInteger(64))) {
      return;
    }

      func_.getFunctionType().getInput(0));
  if (!image_type || !image_type.getElementType().isF32() ||
      image_type.getRank() != 4) {
    return func_.emitWarning() << "Image should be a 4D float tensor";
  }

  auto flow_type = mlir::dyn_cast_or_null<RankedTensorType>(
      func_.getFunctionType().getInput(1));
  if (!flow_type || !flow_type.getElementType().isF32() ||
      flow_type.getRank() != 4) {

 * limitations under the License.
 */

package org.gradle.api.internal.provider;

public interface CollectionProviderInternal<T, C extends Iterable<T>> extends ProviderInternal<C> {
    Class<? extends T> getElementType();

    int size();

    private ModelSchema<E> elementTypeSchema;

    public CollectionSchema(ModelType<T> type, ModelType<E> elementType) {
        super(type);
        this.elementType = elementType;
    }

    public ModelType<E> getElementType() {
        return elementType;
    }

    public ModelSchema<E> getElementTypeSchema() {
        return elementTypeSchema;
    }

    @Override
    public String toString() {