< prev index next >

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

Print this page




  26 
  27 import java.io.DataOutputStream;
  28 import java.io.IOException;
  29 import java.lang.module.ModuleDescriptor;
  30 import java.nio.ByteOrder;
  31 import java.util.ArrayList;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.Comparator;
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Objects;
  39 import java.util.Optional;
  40 import java.util.Set;
  41 import java.util.function.Function;
  42 import java.util.stream.Collectors;
  43 import java.util.stream.Stream;
  44 
  45 import jdk.internal.jimage.decompressor.Decompressor;


  46 import jdk.tools.jlink.plugin.Plugin;
  47 import jdk.tools.jlink.builder.ImageBuilder;
  48 import jdk.tools.jlink.plugin.PluginException;
  49 import jdk.tools.jlink.plugin.ResourcePool;
  50 import jdk.tools.jlink.plugin.ResourcePoolModule;
  51 import jdk.tools.jlink.plugin.ResourcePoolEntry;
  52 import jdk.tools.jlink.internal.ResourcePoolManager.ResourcePoolImpl;
  53 
  54 /**
  55  * Plugins Stack. Plugins entry point to apply transformations onto resources
  56  * and files.
  57  */
  58 public final class ImagePluginStack {
  59 
  60     public interface ImageProvider {
  61 
  62         ExecutableImage retrieve(ImagePluginStack stack) throws IOException;
  63     }
  64 
  65     public static final class OrderedResourcePoolManager extends ResourcePoolManager {


 281                 throw new Exception("Invalid resource pool for plugin " + p);
 282             }
 283             if (resPool instanceof OrderedResourcePoolManager.OrderedResourcePool) {
 284                 frozenOrder = ((OrderedResourcePoolManager.OrderedResourcePool)resPool).getOrderedList();
 285             }
 286         }
 287 
 288         return resPool;
 289     }
 290 
 291     /**
 292      * This pool wrap the original pool and automatically uncompress ResourcePoolEntry
 293      * if needed.
 294      */
 295     private class LastPoolManager extends ResourcePoolManager {
 296         private class LastModule implements ResourcePoolModule {
 297 
 298             final ResourcePoolModule module;
 299             // lazily initialized
 300             ModuleDescriptor descriptor;

 301 
 302             LastModule(ResourcePoolModule module) {
 303                 this.module = module;
 304             }
 305 
 306             @Override
 307             public String name() {
 308                 return module.name();
 309             }
 310 
 311             @Override
 312             public Optional<ResourcePoolEntry> findEntry(String path) {
 313                 Optional<ResourcePoolEntry> d = module.findEntry(path);
 314                 return d.isPresent()? Optional.of(getUncompressed(d.get())) : Optional.empty();
 315             }
 316 
 317             @Override
 318             public ModuleDescriptor descriptor() {
 319                 if (descriptor == null) {
 320                     descriptor = ResourcePoolManager.readModuleDescriptor(this);
 321                 }
 322                 return descriptor;
 323             }
 324 
 325             @Override




















 326             public Set<String> packages() {
 327                 return module.packages();
 328             }
 329 
 330             @Override
 331             public String toString() {
 332                 return name();
 333             }
 334 
 335             @Override
 336             public Stream<ResourcePoolEntry> entries() {
 337                 List<ResourcePoolEntry> lst = new ArrayList<>();
 338                 module.entries().forEach(md -> {
 339                     lst.add(getUncompressed(md));
 340                 });
 341                 return lst.stream();
 342             }
 343 
 344             @Override
 345             public int entryCount() {




  26 
  27 import java.io.DataOutputStream;
  28 import java.io.IOException;
  29 import java.lang.module.ModuleDescriptor;
  30 import java.nio.ByteOrder;
  31 import java.util.ArrayList;
  32 import java.util.Collection;
  33 import java.util.Collections;
  34 import java.util.Comparator;
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Objects;
  39 import java.util.Optional;
  40 import java.util.Set;
  41 import java.util.function.Function;
  42 import java.util.stream.Collectors;
  43 import java.util.stream.Stream;
  44 
  45 import jdk.internal.jimage.decompressor.Decompressor;
  46 import jdk.internal.module.ModuleInfo.Attributes;
  47 import jdk.internal.module.ModuleTarget;
  48 import jdk.tools.jlink.plugin.Plugin;
  49 import jdk.tools.jlink.builder.ImageBuilder;
  50 import jdk.tools.jlink.plugin.PluginException;
  51 import jdk.tools.jlink.plugin.ResourcePool;
  52 import jdk.tools.jlink.plugin.ResourcePoolModule;
  53 import jdk.tools.jlink.plugin.ResourcePoolEntry;
  54 import jdk.tools.jlink.internal.ResourcePoolManager.ResourcePoolImpl;
  55 
  56 /**
  57  * Plugins Stack. Plugins entry point to apply transformations onto resources
  58  * and files.
  59  */
  60 public final class ImagePluginStack {
  61 
  62     public interface ImageProvider {
  63 
  64         ExecutableImage retrieve(ImagePluginStack stack) throws IOException;
  65     }
  66 
  67     public static final class OrderedResourcePoolManager extends ResourcePoolManager {


 283                 throw new Exception("Invalid resource pool for plugin " + p);
 284             }
 285             if (resPool instanceof OrderedResourcePoolManager.OrderedResourcePool) {
 286                 frozenOrder = ((OrderedResourcePoolManager.OrderedResourcePool)resPool).getOrderedList();
 287             }
 288         }
 289 
 290         return resPool;
 291     }
 292 
 293     /**
 294      * This pool wrap the original pool and automatically uncompress ResourcePoolEntry
 295      * if needed.
 296      */
 297     private class LastPoolManager extends ResourcePoolManager {
 298         private class LastModule implements ResourcePoolModule {
 299 
 300             final ResourcePoolModule module;
 301             // lazily initialized
 302             ModuleDescriptor descriptor;
 303             ModuleTarget target;
 304 
 305             LastModule(ResourcePoolModule module) {
 306                 this.module = module;
 307             }
 308 
 309             @Override
 310             public String name() {
 311                 return module.name();
 312             }
 313 
 314             @Override
 315             public Optional<ResourcePoolEntry> findEntry(String path) {
 316                 Optional<ResourcePoolEntry> d = module.findEntry(path);
 317                 return d.isPresent()? Optional.of(getUncompressed(d.get())) : Optional.empty();
 318             }
 319 
 320             @Override
 321             public ModuleDescriptor descriptor() {
 322                 initModuleAttributes();


 323                 return descriptor;
 324             }
 325 
 326             @Override
 327             public String osName() {
 328                 initModuleAttributes();
 329                 return target != null? target.osName() : null;
 330             }
 331 
 332             @Override
 333             public String osArch() {
 334                 initModuleAttributes();
 335                 return target != null? target.osArch() : null;
 336             }
 337 
 338             private void initModuleAttributes() {
 339                 if (this.descriptor == null) {
 340                     Attributes attr = ResourcePoolManager.readModuleAttributes(this);
 341                     this.descriptor = attr.descriptor();
 342                     this.target = attr.target();
 343                 }
 344             }
 345 
 346             @Override
 347             public Set<String> packages() {
 348                 return module.packages();
 349             }
 350 
 351             @Override
 352             public String toString() {
 353                 return name();
 354             }
 355 
 356             @Override
 357             public Stream<ResourcePoolEntry> entries() {
 358                 List<ResourcePoolEntry> lst = new ArrayList<>();
 359                 module.entries().forEach(md -> {
 360                     lst.add(getUncompressed(md));
 361                 });
 362                 return lst.stream();
 363             }
 364 
 365             @Override
 366             public int entryCount() {


< prev index next >