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  
26  import org.apache.bcel.Const;
27  
28  /**
29   * This class represents an entry in the requires table of the Module attribute. Each entry describes a module on which
30   * the parent module depends.
31   *
32   * @see Module
33   * @since 6.4.0
34   */
35  public final class ModuleRequires implements Cloneable, Node {
36  
37      private final int requiresIndex; // points to CONSTANT_Module_info
38      private final int requiresFlags;
39      private final int requiresVersionIndex; // either 0 or points to CONSTANT_Utf8_info
40  
41      /**
42       * Constructs object from file stream.
43       *
44       * @param file Input stream
45       * @throws IOException if an I/O Exception occurs in readUnsignedShort
46       */
47      ModuleRequires(final DataInput file) throws IOException {
48          requiresIndex = file.readUnsignedShort();
49          requiresFlags = file.readUnsignedShort();
50          requiresVersionIndex = file.readUnsignedShort();
51      }
52  
53      /**
54       * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
55       * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
56       *
57       * @param v Visitor object
58       */
59      @Override
60      public void accept(final Visitor v) {
61          v.visitModuleRequires(this);
62      }
63  
64      /**
65       * @return deep copy of this object
66       */
67      public ModuleRequires copy() {
68          try {
69              return (ModuleRequires) clone();
70          } catch (final CloneNotSupportedException e) {
71              // TODO should this throw?
72          }
73          return null;
74      }
75  
76      /**
77       * Dump table entry to file stream in binary format.
78       *
79       * @param file Output file stream
80       * @throws IOException if an I/O Exception occurs in writeShort
81       */
82      public void dump(final DataOutputStream file) throws IOException {
83          file.writeShort(requiresIndex);
84          file.writeShort(requiresFlags);
85          file.writeShort(requiresVersionIndex);
86      }
87  
88      /**
89       * Gets the module name from the constant pool.
90       * @param constantPool Array of constants usually obtained from the ClassFile object
91       * @return module name
92       * @since 6.10.0
93       */
94      public String getModuleName(final ConstantPool constantPool) {
95          return constantPool.constantToString(requiresIndex, Const.CONSTANT_Module);
96      }
97  
98      /**
99       * Gets the flags for this ModuleRequires.
100      * @return the requiresFlags
101      * @since 6.10.0
102      */
103     public int getRequiresFlags() {
104         return requiresFlags;
105     }
106 
107     /**
108      * Gets the required version from the constant pool.
109      * @param constantPool Array of constants usually obtained from the ClassFile object
110      * @return required version, "0" if version index is 0.
111      * @since 6.10.0
112      */
113     public String getVersion(final ConstantPool constantPool) {
114         return requiresVersionIndex == 0 ? "0" : constantPool.getConstantString(requiresVersionIndex, Const.CONSTANT_Utf8);
115     }
116 
117     /**
118      * @return String representation
119      */
120     @Override
121     public String toString() {
122         return "requires(" + requiresIndex + ", " + String.format("%04x", requiresFlags) + ", " + requiresVersionIndex + ")";
123     }
124 
125     /**
126      * @return Resolved string representation
127      */
128     public String toString(final ConstantPool constantPool) {
129         final StringBuilder buf = new StringBuilder();
130         final String moduleName = getModuleName(constantPool);
131         buf.append(moduleName);
132         buf.append(", ").append(String.format("%04x", requiresFlags));
133         final String version = getVersion(constantPool);
134         buf.append(", ").append(version);
135         return buf.toString();
136     }
137 }