import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public RamlResourceSet() {
    final List<URIHandler> uriHandlers = Arrays.asList(
            new PlatformResourceURIHandlerImpl(),
            new FileURIHandlerImpl(),
            new EFSURIHandlerImpl(),
            new ArchiveURIHandlerImpl(),
            new ContentNegotiationURIHandler(ACCEPT_HEADER_VALUE));
    final ExtensibleURIConverterImpl uriConverter =
            new ExtensibleURIConverterImpl(uriHandlers, ContentHandler.Registry.INSTANCE.contentHandlers());
    setURIConverter(uriConverter);

    final Resource.Factory.Registry resourceFactoryRegistry = getResourceFactoryRegistry();
    final RamlResourceFactory resourceFactory = new RamlResourceFactory();
    resourceFactoryRegistry
            .getExtensionToFactoryMap().put("raml", resourceFactory);

    resourceFactoryRegistry.getProtocolToFactoryMap()
            .put("http", resourceFactory);

    final Map<String, Object> contentTypeToFactoryMap = resourceFactoryRegistry.getContentTypeToFactoryMap();
    for (final String contentType : ACCEPTED_MIME_TYPES) {
        contentTypeToFactoryMap
                .put(contentType, resourceFactory);
    }
    addBuiltinTypes();
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public URIHandler getURIHandler(URI uri)
{
  int size = uriHandlers.size();
  if (size > 0)
  {
    URIHandler[] data = uriHandlers.data();
    for (int i = 0; i < size; ++i)
    {
      URIHandler uriHandler = data[i];
      if (uriHandler.canHandle(uri))
      {
        return uriHandler;
      }
    }
  }
  throw new RuntimeException("There is no URIHandler to handle " + uri);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
private boolean registerScheme(URIConverter converter, @SuppressWarnings("hiding") ClassLoader classLoader) {
	URIHandler uriHandler = converter.getURIHandlers().get(0);
	if (uriHandler instanceof MyURIHandler || uriHandler.canHandle(SAMPLE_URI)) {
		return false;
	}
	converter.getURIHandlers().add(0, createURIHandler(classLoader, converter));
	return true;
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
public InputStream getContents() throws CoreException {
	URIHandler handler = schemeHelper.createURIHandler(URIConverter.INSTANCE);
	try {
		return handler.createInputStream(getURI(), Collections.emptyMap());
	} catch (IOException e) {
		throw new CoreException(new Status(IStatus.ERROR, "org.eclipse.n4js.ts.ui", "Cannot load "
				+ getFullPath(), e));
	}
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
public InputStream createInputStream(URI uri, Map<?, ?> options) throws IOException {
	for (URIHandler handler : otherHandlers) {
		if (handler.canHandle(uri))
        {
			return handler.createInputStream(uri, options);
        }
	}
	return super.createInputStream(uri, options);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public void configureConverter(URIConverter converter, IExternalContentProvider contentProvider) {
	List<URIHandler> uriHandlers = converter.getURIHandlers();
	ListIterator<URIHandler> iter = uriHandlers.listIterator();
	while(iter.hasNext()) {
		URIHandler transformed = new ExternalContentAwareURIHandler(iter.next(), contentProvider);
		iter.set(transformed);
	}
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
protected synchronized URIConverter getURIConverter() {
	if (this.uriConverter == null) {
		List<ContentHandler> withoutPlatformDelegate = Lists.newArrayList();
		for (ContentHandler contentHandler : ContentHandler.Registry.INSTANCE.contentHandlers()) {
			if (!isTooEager(contentHandler))
				withoutPlatformDelegate.add(contentHandler);
		}
		this.uriConverter = new ExtensibleURIConverterImpl(URIHandler.DEFAULT_HANDLERS, withoutPlatformDelegate);
	}
	return this.uriConverter;
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public EnsembleResourceSet() {
	super();
	
	for (EnsembleResourceFactory factory : factories) {
		factory.setResourceSet(this);
	}
	
	List<URIHandler> handlers = new ArrayList<URIHandler>(URIHandler.DEFAULT_HANDLERS);
	handlers.addAll(0, getURIHandlerContributions());
	setURIConverter(new ExtensibleURIConverterImpl(handlers, ContentHandler.Registry.INSTANCE.contentHandlers()));
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
/**
 * 
 * {@inheritDoc}
 * 
 * @see org.eclipse.emf.emfstore.mongodb.AbstractMongoDBResourceSetProvider#setURIConverter(org.eclipse.emf.ecore.resource.impl.ResourceSetImpl)
 */
@Override
protected void setURIConverter(ResourceSetImpl resourceSet) {
	// reuse uri handlers set up by resourcesetfactory
	EList<URIHandler> uriHandler = resourceSet.getURIConverter().getURIHandlers();
	URIConverter uriConverter = new MongoServerURIConverter();
	uriConverter.getURIHandlers().clear();
	uriConverter.getURIHandlers().addAll(uriHandler);
	resourceSet.setURIConverter(uriConverter);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
/**
 * 
 * {@inheritDoc}
 * 
 * @see org.eclipse.emf.emfstore.mongodb.AbstractMongoDBResourceSetProvider#setURIConverter(org.eclipse.emf.ecore.resource.impl.ResourceSetImpl)
 */
@Override
protected void setURIConverter(ResourceSetImpl resourceSet) {
	// reuse uri handlers set up by resourcesetfactory
	EList<URIHandler> uriHandler = resourceSet.getURIConverter().getURIHandlers();
	URIConverter uriConverter = new MongoClientURIConverter();
	uriConverter.getURIHandlers().clear();
	uriConverter.getURIHandlers().addAll(uriHandler);
	resourceSet.setURIConverter(uriConverter);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public EList<URIHandler> getURIHandlers()
{
  if (uriHandlers == null)
  {
    uriHandlers = new URIHandlerList();
  }
  return uriHandlers;
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
private URIHandler createURIHandler(ClassLoader theClassLoader, URIConverter converter) {
	return new MyURIHandler(theClassLoader, converter);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public DebugURIHandler(EList<URIHandler> uriHandlers) {
	otherHandlers = new ArrayList<>();
	otherHandlers.addAll(uriHandlers);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
public EList<URIHandler> getURIHandlers() {
	return existing.getURIHandlers();
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
public URIHandler getURIHandler(URI uri) {
	return existing.getURIHandler(uri);
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
public ExternalContentAwareURIHandler(URIHandler delegate, IExternalContentProvider contentProvider) {
	this.delegate = delegate;
	this.contentProvider = contentProvider;
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
private void checkConverter(URIConverter wrapped) {
	assertNotNull(wrapped);
	for(URIHandler handler: wrapped.getURIHandlers()) {
		assertTrue(handler instanceof ExternalContentSupport.ExternalContentAwareURIHandler);
	}
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
protected Object [] newData(int capacity)
{
  return new URIHandler [capacity];
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
@Override
public URIHandler [] data()
{
  return (URIHandler[])data;
}
 

import org.eclipse.emf.ecore.resource.URIHandler; //导入依赖的package包/类
/**
 * Creates an instance.
 */
public ExtensibleURIConverterImpl()
{
  this(URIHandler.DEFAULT_HANDLERS, ContentHandler.Registry.INSTANCE.contentHandlers());
}