## type and loading a model with such a type would fail the Modello validation.
##
#foreach ( $field in $model.getClass("Model", $version).allFields )
  #if ( $field.name == "pomFile" )
    #set ( $dummy = $field.setType("java.nio.file.Path") )
  #end
#end
#set ( $locationTracking = true )
#end

        }
    }

    protected SitemapSet parseTextSitemaps(final InputStream in) {
        final SitemapSet sitemapSet = new SitemapSet();
        sitemapSet.setType(SitemapSet.URLSET);

        try {
            final BufferedReader br = new BufferedReader(new InputStreamReader(in, Constants.UTF_8));
            String line;
            while ((line = br.readLine()) != null) {

      arg.setType(ReplaceElementType(arg.getType(), element_type));
    }

    for (Operation& op : region.getOps()) {
      for (Value operand : op.getOperands()) {
        operand.setType(ReplaceElementType(operand.getType(), element_type));
      }

      for (Value result : op.getResults()) {
        result.setType(ReplaceElementType(result.getType(), element_type));
      }
    }
  }

	}
	if version != testVersion {
		t.Errorf("Unexpected version mismatch, expected: %s, got: %s", testVersion, version)
	}
	// create a set
	set := &ipset.IPSet{
		Name:       "foo",
		SetType:    ipset.HashIPPort,
		HashFamily: ipset.ProtocolFamilyIPV4,
	}
	if err := fake.CreateSet(set, true); err != nil {
		t.Errorf("Unexpected error: %v", err)
	}

	// add two entries

      auto resultType =
          RankedTensorType::get(shape, inputType.getElementType(), extensions);
      arg.setType(resultType);
    }
    llvm::SmallVector<Type, 8> arg_types;
    for (auto arg : func.getArguments()) arg_types.push_back(arg.getType());
    func.setType(
        FunctionType::get(func.getContext(), arg_types,
                          func.front().getTerminator()->getOperandTypes()));

    public ParameterMetaData(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public TypeMetaData getType() {
        return type;
    }

    public void setType(TypeMetaData type) {
        this.type = type;
    }

    public String getSignature() {
        StringBuilder builder = new StringBuilder();

     */
    void setExtension(String extension);

    /**
     * Sets the type of this artifact.
     *
     * @param type The type. Should not be null.
     */
    void setType(String type);

    /**
     * Sets the classifier of this artifact.
     *
     * @param classifier The classifier. May be null.
     */
    void setClassifier(@Nullable String classifier);

    /**

    //    {
    //        setGroupId( af.getGroupId() );
    //        setArtifactId( af.getArtifactId() );
    //        setVersion( af.getVersion() );
    //        setType( af.getType() );
    //        setScope( af.getScope() );
    //        setClassifier( af.getClassifier() );
    //        //setUri( af.getDownloadUrl() );
    //
    //        this.resolved = af.isResolved();
    //    }

  // tensor<x!tf_type.string>.
  auto tensor_string_type =
      RankedTensorType::get({}, TF::StringType::get(builder.getContext()));
  main_func.getArguments().front().setType(tensor_string_type);
  main_func.setType(
      FunctionType::get(builder.getContext(), {tensor_string_type},
                        main_func.getFunctionType().getResults()));

    static {
        Map<Type, String> map = new HashMap<>();
        map.put(Type.BYTE_TYPE, "0");
        map.put(Type.SHORT_TYPE, "0");
        map.put(Type.INT_TYPE, "0");
        map.put(Type.LONG_TYPE, "0L");
        map.put(Type.FLOAT_TYPE, "0.0f");
        map.put(Type.DOUBLE_TYPE, "0.0");
        map.put(Type.CHAR_TYPE, "'\\u0000'");
        map.put(Type.BOOLEAN_TYPE, "false");