155 = stringsUsage.entrySet().stream();
156 // Remove strings that have a single occurence
157 List<String> result = stream.sorted(Comparator.comparing(e -> e.getValue(),
158 Comparator.reverseOrder())).filter((e) -> {
159 return e.getValue() > 1;
160 }).map(java.util.Map.Entry::getKey).
161 collect(Collectors.toList());
162 return result;
163 }
164
165 @Override
166 public String getString(int id) {
167 return reverseMap.get(id);
168 }
169 }
170
171 private final ImageBuilder imageBuilder;
172 private final Plugin lastSorter;
173 private final List<Plugin> plugins = new ArrayList<>();
174 private final List<ResourcePrevisitor> resourcePrevisitors = new ArrayList<>();
175
176
177 public ImagePluginStack() {
178 this(null, Collections.emptyList(), null);
179 }
180
181 public ImagePluginStack(ImageBuilder imageBuilder,
182 List<Plugin> plugins,
183 Plugin lastSorter) {
184 this.imageBuilder = Objects.requireNonNull(imageBuilder);
185 this.lastSorter = lastSorter;
186 this.plugins.addAll(Objects.requireNonNull(plugins));
187 plugins.stream().forEach((p) -> {
188 Objects.requireNonNull(p);
189 if (p instanceof ResourcePrevisitor) {
190 resourcePrevisitors.add((ResourcePrevisitor) p);
191 }
192 });
193 }
194
195 public void operate(ImageProvider provider) throws Exception {
196 ExecutableImage img = provider.retrieve(this);
197 List<String> arguments = new ArrayList<>();
198 plugins.stream()
199 .filter(PostProcessor.class::isInstance)
200 .map((plugin) -> ((PostProcessor)plugin).process(img))
201 .filter((lst) -> (lst != null))
202 .forEach((lst) -> {
203 arguments.addAll(lst);
204 });
205 img.storeLaunchArgs(arguments);
206 }
207
208 public DataOutputStream getJImageFileOutputStream() throws IOException {
209 return imageBuilder.getJImageOutputStream();
210 }
211
212 public ImageBuilder getImageBuilder() {
251 // Create a special Resource pool to compute the indexes.
252 resMgr = new OrderedResourcePoolManager(resPool.byteOrder(),
253 resources.getStringTable());
254 } else {// If we have an order, inject it
255 if (frozenOrder != null) {
256 resMgr = new CheckOrderResourcePoolManager(resPool.byteOrder(),
257 frozenOrder, resources.getStringTable());
258 } else {
259 resMgr = new ResourcePoolManager(resPool.byteOrder(),
260 resources.getStringTable());
261 }
262 }
263 resPool = p.transform(resPool, resMgr.resourcePoolBuilder());
264 if (resPool.isEmpty()) {
265 throw new Exception("Invalid resource pool for plugin " + p);
266 }
267 if (resPool instanceof OrderedResourcePoolManager.OrderedResourcePool) {
268 frozenOrder = ((OrderedResourcePoolManager.OrderedResourcePool)resPool).getOrderedList();
269 }
270 }
271 return resPool;
272 }
273
274 /**
275 * This pool wrap the original pool and automatically uncompress ResourcePoolEntry
276 * if needed.
277 */
278 private class LastPoolManager extends ResourcePoolManager {
279 private class LastModule implements ResourcePoolModule {
280
281 final ResourcePoolModule module;
282 // lazily initialized
283 ModuleDescriptor descriptor;
284
285 LastModule(ResourcePoolModule module) {
286 this.module = module;
287 }
288
289 @Override
290 public String name() {
441 }
442 }
443 }
444 return res;
445 }
446 }
447
448 /**
449 * Make the imageBuilder to store files.
450 *
451 * @param original
452 * @param transformed
453 * @param writer
454 * @throws java.lang.Exception
455 */
456 public void storeFiles(ResourcePool original, ResourcePool transformed,
457 BasicImageWriter writer)
458 throws Exception {
459 Objects.requireNonNull(original);
460 Objects.requireNonNull(transformed);
461 imageBuilder.storeFiles(new LastPoolManager(transformed).resourcePool());
462 }
463
464 public ExecutableImage getExecutableImage() throws IOException {
465 return imageBuilder.getExecutableImage();
466 }
467 }
|
155 = stringsUsage.entrySet().stream();
156 // Remove strings that have a single occurence
157 List<String> result = stream.sorted(Comparator.comparing(e -> e.getValue(),
158 Comparator.reverseOrder())).filter((e) -> {
159 return e.getValue() > 1;
160 }).map(java.util.Map.Entry::getKey).
161 collect(Collectors.toList());
162 return result;
163 }
164
165 @Override
166 public String getString(int id) {
167 return reverseMap.get(id);
168 }
169 }
170
171 private final ImageBuilder imageBuilder;
172 private final Plugin lastSorter;
173 private final List<Plugin> plugins = new ArrayList<>();
174 private final List<ResourcePrevisitor> resourcePrevisitors = new ArrayList<>();
175 private final boolean validate;
176
177 public ImagePluginStack() {
178 this(null, Collections.emptyList(), null);
179 }
180
181 public ImagePluginStack(ImageBuilder imageBuilder,
182 List<Plugin> plugins,
183 Plugin lastSorter) {
184 this(imageBuilder, plugins, lastSorter, true);
185 }
186
187 public ImagePluginStack(ImageBuilder imageBuilder,
188 List<Plugin> plugins,
189 Plugin lastSorter,
190 boolean validate) {
191 this.imageBuilder = Objects.requireNonNull(imageBuilder);
192 this.lastSorter = lastSorter;
193 this.plugins.addAll(Objects.requireNonNull(plugins));
194 plugins.stream().forEach((p) -> {
195 Objects.requireNonNull(p);
196 if (p instanceof ResourcePrevisitor) {
197 resourcePrevisitors.add((ResourcePrevisitor) p);
198 }
199 });
200 this.validate = validate;
201 }
202
203 public void operate(ImageProvider provider) throws Exception {
204 ExecutableImage img = provider.retrieve(this);
205 List<String> arguments = new ArrayList<>();
206 plugins.stream()
207 .filter(PostProcessor.class::isInstance)
208 .map((plugin) -> ((PostProcessor)plugin).process(img))
209 .filter((lst) -> (lst != null))
210 .forEach((lst) -> {
211 arguments.addAll(lst);
212 });
213 img.storeLaunchArgs(arguments);
214 }
215
216 public DataOutputStream getJImageFileOutputStream() throws IOException {
217 return imageBuilder.getJImageOutputStream();
218 }
219
220 public ImageBuilder getImageBuilder() {
259 // Create a special Resource pool to compute the indexes.
260 resMgr = new OrderedResourcePoolManager(resPool.byteOrder(),
261 resources.getStringTable());
262 } else {// If we have an order, inject it
263 if (frozenOrder != null) {
264 resMgr = new CheckOrderResourcePoolManager(resPool.byteOrder(),
265 frozenOrder, resources.getStringTable());
266 } else {
267 resMgr = new ResourcePoolManager(resPool.byteOrder(),
268 resources.getStringTable());
269 }
270 }
271 resPool = p.transform(resPool, resMgr.resourcePoolBuilder());
272 if (resPool.isEmpty()) {
273 throw new Exception("Invalid resource pool for plugin " + p);
274 }
275 if (resPool instanceof OrderedResourcePoolManager.OrderedResourcePool) {
276 frozenOrder = ((OrderedResourcePoolManager.OrderedResourcePool)resPool).getOrderedList();
277 }
278 }
279
280 return resPool;
281 }
282
283 /**
284 * This pool wrap the original pool and automatically uncompress ResourcePoolEntry
285 * if needed.
286 */
287 private class LastPoolManager extends ResourcePoolManager {
288 private class LastModule implements ResourcePoolModule {
289
290 final ResourcePoolModule module;
291 // lazily initialized
292 ModuleDescriptor descriptor;
293
294 LastModule(ResourcePoolModule module) {
295 this.module = module;
296 }
297
298 @Override
299 public String name() {
450 }
451 }
452 }
453 return res;
454 }
455 }
456
457 /**
458 * Make the imageBuilder to store files.
459 *
460 * @param original
461 * @param transformed
462 * @param writer
463 * @throws java.lang.Exception
464 */
465 public void storeFiles(ResourcePool original, ResourcePool transformed,
466 BasicImageWriter writer)
467 throws Exception {
468 Objects.requireNonNull(original);
469 Objects.requireNonNull(transformed);
470 ResourcePool lastPool = new LastPoolManager(transformed).resourcePool();
471 if (validate) {
472 ResourcePoolConfiguration.validate(lastPool);
473 }
474 imageBuilder.storeFiles(lastPool);
475 }
476
477 public ExecutableImage getExecutableImage() throws IOException {
478 return imageBuilder.getExecutableImage();
479 }
480 }
|