Sets the mimeTypes value for this AssetCreativeTemplateVariable.

@param mimeTypes   * A set of supported mime types. This set can be empty or null
if there's no
constraint, meaning files of any mime types are
allowed.
328113
public void setMimeTypes(com.google.api.ads.admanager.axis.v201902.AssetCreativeTemplateVariableMimeType[] mimeTypes) {
        this.mimeTypes = mimeTypes;
    }
300611
public function setMimeType($mimeType)
    {
        if ($mimeType != $this->getMimeType()) {
            // ensure that we got an internal imagine image
            $this->getImagineImage();
            $this->mimeType = $mimeType;
            $this->binaryContentDirty = true;
        }
    }
955839
private void setMapType(int mapType) {
        final String methodName = "setMapType";
        if (tc.isDebugEnabled())
            Tr.debug(tc, methodName + " " + cache.getCacheName() + " MapTypeOld:" + this.mapType + " MapTypeNew:" + mapType);
        this.mapType = mapType;
    }
646842
public void setNodeTypeSpecificValues(java.util.Collection<NodeTypeSpecificValue> nodeTypeSpecificValues) {
        if (nodeTypeSpecificValues == null) {
            this.nodeTypeSpecificValues = null;
            return;
        }

        this.nodeTypeSpecificValues = new java.util.ArrayList<NodeTypeSpecificValue>(nodeTypeSpecificValues);
    }
748357
public void setFindingStatisticTypes(java.util.Collection<String> findingStatisticTypes) {
        if (findingStatisticTypes == null) {
            this.findingStatisticTypes = null;
            return;
        }

        this.findingStatisticTypes = new java.util.ArrayList<String>(findingStatisticTypes);
    }
113664
public void setCustomTypes(String[] strings) {
        this.customTypes.clear();
        for (String string : strings) {
            CustomType customType = new CustomType();
            customType.setClassName(string);
            this.customTypes.add(customType);
        }
    }
1140601
public void setTypeaheadValues(java.lang.Object _typeaheadValues) {
		getStateHelper().put(PropertyKeys.typeaheadValues, _typeaheadValues);
	}
191694
public void setContentType(MediaType mediaType) {
		Assert.isTrue(!mediaType.isWildcardType(), "'Content-Type' cannot contain wildcard type '*'");
		Assert.isTrue(!mediaType.isWildcardSubtype(), "'Content-Type' cannot contain wildcard subtype '*'");
		set(CONTENT_TYPE, mediaType.toString());
	}
475794
public static boolean hasMimeType(String mimeType) {
        if (mimeType == null || mimeType.isEmpty()) {
            return false;
        }
        return mimeTypeToExtensionMap.containsKey(mimeType);
    }
1264892
public void setResourceTypes(List<String> resourceTypes) {

        if ((resourceTypes != null) && !resourceTypes.isEmpty()) {
            addFilterQuery(CmsSearchField.FIELD_TYPE, resourceTypes, false, false);
        }
    }
318117
public function type($mimeTypes) {
        $types = array();

        foreach ((array) $mimeTypes as $mimeType) {
            switch ($mimeType) {
                case 'application': $types += MimeType::getApplicationList(); break;
                case 'audio':       $types += MimeType::getAudioList(); break;
                case 'image':       $types += MimeType::getImageList(); break;
                case 'text':        $types += MimeType::getTextList(); break;
                case 'video':       $types += MimeType::getVideoList(); break;
                default:            $types += MimeType::getSubTypeList($mimeType); break;
            }
        }

        return in_array($this->getFile()->type(), $types);
    }
1045366
public JDBCAppendTableSinkBuilder setParameterTypes(TypeInformation<?>... types) {
		int[] ty = new int[types.length];
		for (int i = 0; i < types.length; ++i) {
			ty[i] = JDBCTypeUtil.typeInformationToSqlType(types[i]);
		}
		this.parameterTypes = ty;
		return this;
	}
1113377
public void setMimeFilters(HashMap mimeFilters) {
        if (mimeFilters != null && mimeFilters.size() > 0) {
            this.isMimeFilteringEnabled = true;
        }
        this.mimeFilters = mimeFilters;
    }
1306713
public function mimeType($type, $val = '')
    {
        if (is_array($type)) {
            $this->mimeType = array_merge($this->mimeType, $type);
        } else {
            $this->mimeType[$type] = $val;
        }
    }
878289
public void setTypeS(String v) {
    if (Gold_Type.featOkTst && ((Gold_Type)jcasType).casFeat_typeS == null)
      jcasType.jcas.throwFeatMissing("typeS", "ch.epfl.bbp.uima.types.Gold");
    jcasType.ll_cas.ll_setStringValue(addr, ((Gold_Type)jcasType).casFeatCode_typeS, v);}
1283074
public static MimeType parseMimeType(String mimeType) {
        if (Strings.isNullOrEmpty(mimeType)) {
            throw new InvalidMimeTypeException(mimeType, "'mimeType' must not be empty");
        }

        String[] parts = FluentIterable.from(Splitter.on(";").trimResults().split(mimeType)).toArray(String.class);

        String fullType = parts[0].trim();
        // java.net.HttpURLConnection returns a *; q=.2 Accept header
        if (MimeType.WILDCARD_TYPE.equals(fullType)) {
            fullType = "*/*";
        }
        int subIndex = fullType.indexOf('/');
        if (subIndex == -1) {
            throw new InvalidMimeTypeException(mimeType, "does not contain '/'");
        }
        if (subIndex == fullType.length() - 1) {
            throw new InvalidMimeTypeException(mimeType, "does not contain subtype after '/'");
        }
        String type = fullType.substring(0, subIndex);
        String subtype = fullType.substring(subIndex + 1, fullType.length());
        if (MimeType.WILDCARD_TYPE.equals(type) && !MimeType.WILDCARD_TYPE.equals(subtype)) {
            throw new InvalidMimeTypeException(mimeType, "wildcard type is legal only in '*/*' (all mime types)");
        }

        Map<String, String> parameters = null;
        if (parts.length > 1) {
            parameters = new LinkedHashMap<String, String>(parts.length - 1);
            for (int i = 1; i < parts.length; i++) {
                String parameter = parts[i];
                int eqIndex = parameter.indexOf('=');
                if (eqIndex != -1) {
                    String attribute = parameter.substring(0, eqIndex);
                    String value = parameter.substring(eqIndex + 1, parameter.length());
                    parameters.put(attribute, value);
                }
            }
        }

        try {
            return new MimeType(type, subtype, parameters);
        }
        catch (UnsupportedCharsetException ex) {
            throw new InvalidMimeTypeException(mimeType, "unsupported charset '" + ex.getCharsetName() + "'");
        }
        catch (IllegalArgumentException ex) {
            throw new InvalidMimeTypeException(mimeType, ex.getMessage());
        }
    }
1193354
protected void doResponseHeaders(final HttpServletResponse response, final String mimeType) {
        if (mimeType != null) {
            response.setContentType(mimeType);
        }
    }