Return the media types supported by all provided message converters sorted by specificity via
{@link MediaType#sortBySpecificity(List)}.
779928
protected List<MediaType> getAllSupportedMediaTypes(List<HttpMessageConverter<?>> messageConverters) {
        Set<MediaType> allSupportedMediaTypes = new LinkedHashSet<MediaType>();
        for (HttpMessageConverter<?> messageConverter : messageConverters) {
            allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
        }

        List<MediaType> result = new ArrayList<MediaType>(allSupportedMediaTypes);

        MediaType.sortBySpecificity(result);

        return Collections.unmodifiableList(result);
    }
1052729
private void sortLists(){
		//sort RGBformats
		//if native RGB24 is supported, put it first
		moveToFirstIfNative(RGBformats, V4L4JConstants.IMF_RGB24);
		
		//sort BGRformats
		//if native BGR24 is supported, put it first
		moveToFirstIfNative(BGRformats, V4L4JConstants.IMF_BGR24);
		
		//sort YUV420formats
		//if native YUV420 is supported, put it first
		moveToFirstIfNative(YUV420formats, V4L4JConstants.IMF_YUV420);
		
		//sort YVU420formats
		//if native YVU420 is supported, put it first
		moveToFirstIfNative(YVU420formats, V4L4JConstants.IMF_YVU420);
		
		//sort JPEGformats
		//put native formats first and libvideo converted ones next
		moveNativeFirst(JPEGformats);
		//if native RGB32 is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_RGB32);
		//if native RGB24 is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_RGB24);
		//if native UYVY is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_UYVY);
		//if native YUYV is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_YUYV);
		//if native YUV420P is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_YUV420);
		//if native MJPEG is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_MJPEG);
		//if native JPEG is supported, put it first
		moveToFirstIfNative(JPEGformats, V4L4JConstants.IMF_JPEG);
	}
645872
List<String> generateTypes(List<MessageType> msgTypes) {
        return msgTypes.stream().map(t -> t.accept(stringVisitor, null)).collect(Collectors.toList());
    }
209401
public Collection<Subscription> getSubscriptionsByMessageType(Class messageType) {
        Set<Subscription> subscriptions = new TreeSet<Subscription>(Subscription.SubscriptionByPriorityDesc);
        ReadLock readLock = readWriteLock.readLock();
        try {
            readLock.lock();

            Subscription subscription;
            ArrayList<Subscription> subsPerMessage = subscriptionsPerMessage.get(messageType);

            if (subsPerMessage != null) {
                subscriptions.addAll(subsPerMessage);
            }

            Class[] types = ReflectionUtils.getSuperTypes(messageType);
            for (int i=0, n=types.length; i<n; i++) {
                Class eventSuperType = types[i];
                
                ArrayList<Subscription> subs = subscriptionsPerMessage.get(eventSuperType);
                if (subs != null) {
                    for (int j = 0,m=subs.size(); j<m; j++) {
                        subscription = subs.get(j);

                        if (subscription.handlesMessageType(messageType)) {
                            subscriptions.add(subscription);
                        }
                    }
                }
            }
        }finally{
            readLock.unlock();
        }
        return subscriptions;
    }
701469
def _get_media(media_types):
    """"""
    get_mapped_media = (lambda x: maps.VIRTUAL_MEDIA_TYPES_MAP[x]
                        if x in maps.VIRTUAL_MEDIA_TYPES_MAP else None)
    return list(map(get_mapped_media, media_types))
297445
@SuppressWarnings("unchecked")
  public <S, D> ConditionalConverter<S, D> getFirstSupported(Class<?> sourceType,
      Class<?> destinationType) {
    ConditionalConverter<S, D> firstPartialMatchConverter = null;

    for (ConditionalConverter<?, ?> converter : converters) {
      MatchResult matchResult = converter.match(sourceType, destinationType);
      if (matchResult == MatchResult.FULL)
        return (ConditionalConverter<S, D>) converter;
      if (firstPartialMatchConverter == null
          && matchResult == MatchResult.PARTIAL)
        firstPartialMatchConverter = (ConditionalConverter<S, D>) converter;
    }
    return firstPartialMatchConverter;
  }
463887
public ApiListingBuilder produces(Set<String> mediaTypes) {
    if (mediaTypes != null) {
      this.produces = new HashSet<>(mediaTypes);
    }
    return this;
  }
1302739
public static Set<Type> getTypedTypes(Map<Class<?>, Type> typeClosure, Class<?> rawType, Typed typed) {
        Set<Type> types = new HashSet<Type>();
        for (Class<?> specifiedClass : typed.value()) {
            Type tmp = typeClosure.get(specifiedClass);
            if (tmp != null) {
                types.add(tmp);
            } else {
                throw BeanLogger.LOG.typedClassNotInHierarchy(specifiedClass.getName(), rawType, Formats.formatTypes(typeClosure.values()));
            }
        }
        types.add(Object.class);
        return types;
    }
499168
public java.util.List<String> getAutoScalingNotificationTypes() {
        if (autoScalingNotificationTypes == null) {
            autoScalingNotificationTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return autoScalingNotificationTypes;
    }
111279
def get_items_of_media_type(self, media_type):
        
        return (item for item in self.items if item.media_type == media_type)
1134109
@Override
    public Set<String> getSupportedInputMediaTypes() {
        ImmutableSet.Builder<String> result = ImmutableSet.builder();
        result.addAll(MediaType.NATIVE_MEDIATYPE_SYNTAX_MAP.keySet());
        result.addAll(this.serviceTransformationEngine.getSupportedMediaTypes());
        return result.build();
    }
218342
public java.util.List<ConversionTask> getConversionTasks() {
        if (conversionTasks == null) {
            conversionTasks = new com.amazonaws.internal.SdkInternalList<ConversionTask>();
        }
        return conversionTasks;
    }
1292012
protected static MediaType toMediaType(OggStreamType type) {
       if (type == OggStreamIdentifier.UNKNOWN) {
           // We don't have a specific type available to return
           return OGG_GENERAL;
       } else {
           // Say it's the specific type we found
           return MediaType.parse(type.mimetype);
       }
   }
1266289
private <T> boolean matchesWriterMediaTypes(ProviderInfo<MessageBodyWriter<?>> pi,
                                                MediaType mediaType) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "matchesWriterMediaTypes ",  new Object[]{pi, mediaType});
        }
        MessageBodyWriter<?> ep = pi.getProvider();
        List<MediaType> supportedMediaTypes = JAXRSUtils.getProviderProduceTypes(ep);

        return JAXRSUtils.doMimeTypesIntersect(Collections.singletonList(mediaType), supportedMediaTypes);
    }
454627
private static List<MediaType> producibleMediaTypes(Method method, Class<?> clazz) {
        List<Produces> produces = findAll(method, Produces.class);
        List<ProduceType> produceTypes = findAll(method, ProduceType.class);

        if (produces.isEmpty() && produceTypes.isEmpty()) {
            produces = findAll(clazz, Produces.class);
            produceTypes = findAll(clazz, ProduceType.class);
        }

        final List<MediaType> types =
                Stream.concat(produces.stream().map(Produces::value),
                              produceTypes.stream().map(ProduceType::value))
                      .map(MediaType::parse)
                      .peek(type -> {
                          if (type.hasWildcard()) {
                              throw new IllegalArgumentException(
                                      "Producible media types must not have a wildcard: " + type);
                          }
                      })
                      .collect(toImmutableList());
        return ensureUniqueTypes(types, Produces.class);
    }
848959
private ImmutableSet<Class<? super T>> getImmediateRawTypes() {
    // Cast from ImmutableSet<Class<?>> to ImmutableSet<Class<? super T>>
    @SuppressWarnings({"unchecked", "rawtypes"})
    ImmutableSet<Class<? super T>> result = (ImmutableSet) getRawTypes(runtimeType);
    return result;
  }
1125592
public List<Converter<OrmDescriptor>> getAllConverter()
   {
      List<Converter<OrmDescriptor>> list = new ArrayList<Converter<OrmDescriptor>>();
      List<Node> nodeList = model.get("converter");
      for(Node node: nodeList)
      {
         Converter<OrmDescriptor>  type = new ConverterImpl<OrmDescriptor>(this, "converter", model, node);
         list.add(type);
      }
      return list;
   }