Registers all mapping files with : ResourceResolver and InMemoryURLStreamHandler

Returns a List containing the names of all InMemoryMappingFiles.
166470
@Trivial
    private List<String> processInMemoryMappingFiles(List<InMemoryMappingFile> immfs) {
        List<String> res = new ArrayList<String>();
        for (InMemoryMappingFile immf : immfs) {
            // Register the file with our ClassLoader
            URL url = _appLoader.registerInMemoryResource(immf);
            // Register the <URL -> File> mapping with the handler so it can return a stream
            // when requested to do so.
            _inMemHandler.register(url, immf);
            // Save a reference to the URL so we can cleanup later.
            _inMemoryMappingFileURLs.add(url);
            res.add(immf.getName());
        }

        return res;
    }
262934
private void updateRegistries(ResourceGenerator generator) {

		resolverRegistry.add(new ResourceGeneratorResolverWrapper(generator, generator.getResolver()));
		GeneratorComparator genComparator = new GeneratorComparator();
		Collections.sort(resolverRegistry);
		if (generator instanceof StreamResourceGenerator) {
			binaryResourceGeneratorRegistry.add(generator);
			Collections.sort(binaryResourceGeneratorRegistry, genComparator);
		}
		if (generator instanceof CssResourceGenerator) {
			if (((CssResourceGenerator) generator).isHandlingCssImage()) {
				cssImageResourceGeneratorRegistry.add(generator);
				Collections.sort(cssImageResourceGeneratorRegistry, genComparator);
			}
		}
		if (generator instanceof BundlingProcessLifeCycleListener) {
			bundlingProcesslifeCycleListeners.add((BundlingProcessLifeCycleListener) generator);
		}
	}
879381
private void register(PathMapping pathMapping) throws IOException {

		GeneratorRegistry generatorRegistry = bundlesHandler.getConfig().getGeneratorRegistry();
		List<PathMapping> mappings = new ArrayList<>();
		if (generatorRegistry.isPathGenerated(pathMapping.getPath())) {
			List<PathMapping> genPathMappings = generatorRegistry.getGeneratedPathMappings(pathMapping.getBundle(),
					pathMapping.getPath(), rsReader);
			if (genPathMappings != null) {
				mappings.addAll(genPathMappings);
			} else {
				mappings.add(pathMapping);
			}
		} else {
			mappings.add(pathMapping);
		}

		for (PathMapping pMapping : mappings) {
			String filePath = rsReader.getFilePath(pMapping.getPath());
			registerPathMapping(pMapping, filePath);
		}
	}
1201358
public UriMappingResolver addResources(String... resources) {
        if (resources.length % 2 == 1) {
            throw new IllegalArgumentException
                    ("Expected even number of arguments");
        }
        for (int i = 0; i < resources.length; i += 2) {
            addSchema(resources[i], resources[i+1]);
        }
        return this;
    }
299032
private List<ResourceBuilderModel> getRegisteredListForResource(ResourceModel resource) {
        if(resourceIDs.containsKey(resource.getResourceID())) {
            return resourceIDs.get(resource.getResourceID());
        } else {
            LinkedList<ResourceBuilderModel> tempList = new LinkedList<>();
            resourceIDs.put(resource.getResourceID(), tempList);
            return tempList;
        }
    }
785653
private void registerExternalLoaders() throws MojoExecutionException {
        if (archiveLoaders != null) {
            for (String entry : archiveLoaders) {
                try {
                    SourceLoader loader = (SourceLoader) Class.forName(entry).newInstance();
                    registerLoader(loader);
                } catch (Exception e) {
                    throw new MojoExecutionException("Error registering archive loader for class: " + entry, e);
                }
            }
        }
    }
707090
public function registerStandardObjects()
	{
		$this->extensionMap = new ExtensionMap();
		$this->extensions = $this->extensionMap->getRegisteredExtensionNames();
		$this->finder->files();
	}
603222
@SuppressWarnings("all")
  private void registerConvertersFromFileSystem(String converterClassResourceName, URL converterClassResourceLocation) {

    try {

      File convertersPackagePath = new File(converterClassResourceLocation.toURI()).getParentFile();

      Assert.isTrue(convertersPackagePath.isDirectory(),
          "Directory for Converters package [%s] does not exist", convertersPackagePath.getAbsolutePath());

      for (File classFile : convertersPackagePath.listFiles(new FileExtensionFilter(CLASS_FILE_EXTENSION))) {

        String converterClassName = CONVERTERS_PACKAGE.getName()
            .concat(StringUtils.DOT_SEPARATOR).concat(FileUtils.getName(classFile));

        register(converterClassName);
      }
    }
    catch (URISyntaxException cause) {
      throw newRuntimeException(cause, "Failed to create File reference to directory [%s] of Converters package",
          converterClassResourceName.substring(0, converterClassResourceName.lastIndexOf(File.separator) + 1));
    }
  }
996360
protected void addFilePathMapping(BundlePathMapping bundlePathMapping, String pathMapping) {
		long timestamp = 0;
		String filePath = resourceReaderHandler.getFilePath(pathMapping);
		if (filePath != null) {
			timestamp = resourceReaderHandler.getLastModified(filePath);
			List<FilePathMapping> filePathMappings = bundlePathMapping.getFilePathMappings();
			boolean found = false;
			for (FilePathMapping filePathMapping : filePathMappings) {
				if (filePathMapping.getPath().equals(filePath)) {
					found = true;
					break;
				}
			}
			if (!found) {
				filePathMappings.add(new FilePathMapping(bundle, filePath, timestamp));
			}
		}

	}
1091762
@Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        String[] staticResourceMappingPath = {"classpath:/static/"};

        registry.addResourceHandler("/**").addResourceLocations(
                staticResourceMappingPath);
    }
1114206
def init_file_mapping_store():
    
    # Make storage directory for restore files if it doesn't already exist
    path = os.path.join(RESTORE_DIRECTORY, FILE_STORE_LOCATION)
    if not os.path.exists(path):
        os.makedirs(path)
646739
def register(self):
        
        os.environ[self.resourceEnvNamePrefix + self.pathHash] = self.pickle()
1009827
void register(URL url, InMemoryMappingFile immf) {
        _data.put(url.getFile(), immf);
    }
323950
def register_directory(self, dirpath, **kwargs):
        

        kwargs['file_extensions'] = kwargs.get("file_extensions",
                                               self.rdf_formats)
        files = list_files(file_directory=dirpath, **kwargs)
        for fileinfo in files:
            self.register_rml(fileinfo[-1], **kwargs)
374189
def MapFile(self, key_path_prefix, registry_file):
    
    self._registry_files[key_path_prefix.upper()] = registry_file
    registry_file.SetKeyPathPrefix(key_path_prefix)
392105
private Object invokeMapper(File source) throws IOException {
        Object[] results;
        String name;
        Reader src;

        name = source.getPath();
        mork.output.verbose("mapping " + name);
        results = run(name);
        mork.output.verbose("finished mapping " + name);
        if (results == null) {
            return null;
        } else {
            return results[0];
        }
    }
865329
private void registerPathMapping(PathMapping pathMapping, String filePath) throws IOException {
		if (filePath != null) {

			Path p = Paths.get(filePath);
			boolean isDir = Files.isDirectory(p);
			if (!isDir) {
				p = p.getParent();
			}

			if (pathMapping.isRecursive()) {
				registerAll(p, Arrays.asList(pathMapping));
			} else {
				register(p, Arrays.asList(pathMapping));
			}
		}
	}