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 records the classes and interfaces that are authorized to claim
33   * membership in the nest hosted by the current class or interface. There may be at most one NestMembers attribute in a
34   * ClassFile structure.
35   *
36   * @see Attribute
37   */
38  public final class NestMembers extends Attribute {
39  
40      private int[] classes;
41  
42      /**
43       * Constructs object from input stream.
44       *
45       * @param nameIndex Index in constant pool
46       * @param length Content length in bytes
47       * @param input Input stream
48       * @param constantPool Array of constants
49       * @throws IOException if an I/O error occurs.
50       */
51      NestMembers(final int nameIndex, final int length, final DataInput input, final ConstantPool constantPool) throws IOException {
52          this(nameIndex, length, (int[]) null, constantPool);
53          final int classCount = input.readUnsignedShort();
54          classes = new int[classCount];
55          for (int i = 0; i < classCount; i++) {
56              classes[i] = input.readUnsignedShort();
57          }
58      }
59  
60      /**
61       * @param nameIndex Index in constant pool
62       * @param length Content length in bytes
63       * @param classes Table of indices in constant pool
64       * @param constantPool Array of constants
65       */
66      public NestMembers(final int nameIndex, final int length, final int[] classes, final ConstantPool constantPool) {
67          super(Const.ATTR_NEST_MEMBERS, nameIndex, length, constantPool);
68          this.classes = ArrayUtils.nullToEmpty(classes);
69          Args.requireU2(this.classes.length, "classes.length");
70      }
71  
72      /**
73       * Initialize from another object. Note that both objects use the same references (shallow copy). Use copy() for a
74       * physical copy.
75       *
76       * @param c Source to copy.
77       */
78      public NestMembers(final NestMembers c) {
79          this(c.getNameIndex(), c.getLength(), c.getClasses(), c.getConstantPool());
80      }
81  
82      /**
83       * Called by objects that are traversing the nodes of the tree implicitly defined by the contents of a Java class.
84       * I.e., the hierarchy of methods, fields, attributes, etc. spawns a tree of objects.
85       *
86       * @param v Visitor object
87       */
88      @Override
89      public void accept(final Visitor v) {
90          v.visitNestMembers(this);
91      }
92  
93      /**
94       * @return deep copy of this attribute
95       */
96      @Override
97      public Attribute copy(final ConstantPool constantPool) {
98          final NestMembers c = (NestMembers) clone();
99          if (classes.length > 0) {
100             c.classes = classes.clone();
101         }
102         c.setConstantPool(constantPool);
103         return c;
104     }
105 
106     /**
107      * Dump NestMembers attribute to file stream in binary format.
108      *
109      * @param file Output file stream
110      * @throws IOException if an I/O error occurs.
111      */
112     @Override
113     public void dump(final DataOutputStream file) throws IOException {
114         super.dump(file);
115         file.writeShort(classes.length);
116         for (final int index : classes) {
117             file.writeShort(index);
118         }
119     }
120 
121     /**
122      * @return array of indices into constant pool of class names.
123      */
124     public int[] getClasses() {
125         return classes;
126     }
127 
128     /**
129      * @return string array of class names
130      */
131     public String[] getClassNames() {
132         final String[] names = new String[classes.length];
133         Arrays.setAll(names, i -> Utility.pathToPackage(super.getConstantPool().getConstantString(classes[i], Const.CONSTANT_Class)));
134         return names;
135     }
136 
137     /**
138      * @return Length of classes table.
139      */
140     public int getNumberClasses() {
141         return classes.length;
142     }
143 
144     /**
145      * @param classes the list of class indexes Also redefines number_of_classes according to table length.
146      */
147     public void setClasses(final int[] classes) {
148         this.classes = ArrayUtils.nullToEmpty(classes);
149     }
150 
151     /**
152      * @return String representation, i.e., a list of classes.
153      */
154     @Override
155     public String toString() {
156         final StringBuilder buf = new StringBuilder();
157         buf.append("NestMembers(");
158         buf.append(classes.length);
159         buf.append("):\n");
160         for (final int index : classes) {
161             final String className = super.getConstantPool().getConstantString(index, Const.CONSTANT_Class);
162             buf.append("  ").append(Utility.compactClassName(className, false)).append("\n");
163         }
164         return buf.substring(0, buf.length() - 1); // remove the last newline
165     }
166 }