View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   https://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  
20  package org.apache.bcel.classfile;
21  
22  import java.io.DataInput;
23  import java.io.DataOutputStream;
24  import java.io.IOException;
25  import java.util.Arrays;
26  
27  import org.apache.bcel.Const;
28  import org.apache.bcel.util.Args;
29  import org.apache.commons.lang3.ArrayUtils;
30  
31  /**
32   * This class is derived from <em>Attribute</em> and represents the list of packages that are exported or opened by the
33   * Module attribute. There may be at most one ModulePackages attribute in a ClassFile structure.
34   *
35   * @see Attribute
36   */
37  public final class ModulePackages extends Attribute {
38  
39      private int[] packageIndexTable;
40  
41      /**
42       * Constructs object from input stream.
43       *
44       * @param nameIndex Index in constant pool
45       * @param length Content length in bytes
46       * @param input Input stream
47       * @param constantPool Array of constants
48       * @throws IOException if an I/O error occurs.
49       */
50      ModulePackages(final int nameIndex, final int length, final DataInput input, final ConstantPool constantPool) throws IOException {
51          this(nameIndex, length, (int[]) null, constantPool);
52          final int packageCount = input.readUnsignedShort();
53          packageIndexTable = new int[packageCount];
54          for (int i = 0; i < packageCount; i++) {
55              packageIndexTable[i] = input.readUnsignedShort();
56          }
57      }
58  
59      /**
60       * @param nameIndex Index in constant pool
61       * @param length Content length in bytes
62       * @param packageIndexTable Table of indices in constant pool
63       * @param constantPool Array of constants
64       */
65      public ModulePackages(final int nameIndex, final int length, final int[] packageIndexTable, final ConstantPool constantPool) {
66          super(Const.ATTR_MODULE_PACKAGES, nameIndex, length, constantPool);
67          this.packageIndexTable = ArrayUtils.nullToEmpty(packageIndexTable);
68          Args.requireU2(this.packageIndexTable.length, "packageIndexTable.length");
69      }
70  
71      /**
72       * Initialize from another object. Note that both objects use the same references (shallow copy). Use copy() for a
73       * physical copy.
74       *
75       * @param c Source to copy.
76       */
77      public ModulePackages(final ModulePackages c) {
78          this(c.getNameIndex(), c.getLength(), c.getPackageIndexTable(), c.getConstantPool());
79      }
80  
81      /**
82       * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
83       * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
84       *
85       * @param v Visitor object
86       */
87      @Override
88      public void accept(final Visitor v) {
89          v.visitModulePackages(this);
90      }
91  
92      /**
93       * @return deep copy of this attribute
94       */
95      @Override
96      public Attribute copy(final ConstantPool constantPool) {
97          final ModulePackages c = (ModulePackages) clone();
98          if (packageIndexTable != null) {
99              c.packageIndexTable = packageIndexTable.clone();
100         }
101         c.setConstantPool(constantPool);
102         return c;
103     }
104 
105     /**
106      * Dump ModulePackages attribute to file stream in binary format.
107      *
108      * @param file Output file stream
109      * @throws IOException if an I/O error occurs.
110      */
111     @Override
112     public void dump(final DataOutputStream file) throws IOException {
113         super.dump(file);
114         file.writeShort(packageIndexTable.length);
115         for (final int index : packageIndexTable) {
116             file.writeShort(index);
117         }
118     }
119 
120     /**
121      * @return Length of package table.
122      */
123     public int getNumberOfPackages() {
124         return packageIndexTable == null ? 0 : packageIndexTable.length;
125     }
126 
127     /**
128      * @return array of indices into constant pool of package names.
129      */
130     public int[] getPackageIndexTable() {
131         return packageIndexTable;
132     }
133 
134     /**
135      * @return string array of package names
136      */
137     public String[] getPackageNames() {
138         final String[] names = new String[packageIndexTable.length];
139         Arrays.setAll(names, i -> Utility.pathToPackage(super.getConstantPool().getConstantString(packageIndexTable[i], Const.CONSTANT_Package)));
140         return names;
141     }
142 
143     /**
144      * @param packageIndexTable the list of package indexes Also redefines number_of_packages according to table length.
145      */
146     public void setPackageIndexTable(final int[] packageIndexTable) {
147         this.packageIndexTable = ArrayUtils.nullToEmpty(packageIndexTable);
148     }
149 
150     /**
151      * @return String representation, i.e., a list of packages.
152      */
153     @Override
154     public String toString() {
155         final StringBuilder buf = new StringBuilder();
156         buf.append("ModulePackages(");
157         buf.append(packageIndexTable.length);
158         buf.append("):\n");
159         for (final int index : packageIndexTable) {
160             final String packageName = super.getConstantPool().getConstantString(index, Const.CONSTANT_Package);
161             buf.append("  ").append(Utility.compactClassName(packageName, false)).append("\n");
162         }
163         return buf.substring(0, buf.length() - 1); // remove the last newline
164     }
165 }