< prev index next >

src/jdk.jlink/share/classes/jdk/tools/jlink/internal/ImagePluginStack.java

Print this page




 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 Set<String> rootModules;
 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, null);
 185     }
 186 
 187     public ImagePluginStack(ImageBuilder imageBuilder,
 188             List<Plugin> plugins,
 189             Plugin lastSorter,
 190             Set<String> rootModules) {
 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.rootModules = rootModules;
 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 (rootModules != null) {
 472             ResourcePoolConfiguration.validate(lastPool, rootModules);
 473         }
 474         imageBuilder.storeFiles(lastPool);
 475     }
 476 
 477     public ExecutableImage getExecutableImage() throws IOException {
 478         return imageBuilder.getExecutableImage();
 479     }
 480 }
< prev index next >