jdk-sandbox: comparison src/java.xml/share/classes/com/sun/org/apache/bcel/internal/generic/ClassGen.java

equal deleted inserted replaced

-:badfa812b82a
+:8e0ae3830fca
 /*
-* reserved comment block
+* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
-* DO NOT REMOVE OR ALTER!
 */
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 */
 package com.sun.org.apache.bcel.internal.generic;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import com.sun.org.apache.bcel.internal.Const;
 import com.sun.org.apache.bcel.internal.classfile.AccessFlags;
 import com.sun.org.apache.bcel.internal.classfile.AnnotationEntry;
 import com.sun.org.apache.bcel.internal.classfile.Annotations;
 /**
 * Template class for building up a java class. May be initialized with an
 * existing java class (file).
 *
 * @see JavaClass
-* @version $Id: ClassGen.java 1749603 2016-06-21 20:50:19Z ggregory $
+* @version $Id$
+* @LastModified: Jun 2019
 */
 public class ClassGen extends AccessFlags implements Cloneable {
 /* Corresponds to the fields found in a JavaClass object.
 */
 private final List<AnnotationEntryGen> annotation_vec = new ArrayList<>();
 private static BCELComparator _cmp = new BCELComparator() {
 @Override
-public boolean equals(final Object o1, final Object o2) {
+public boolean equals( final Object o1, final Object o2 ) {
 final ClassGen THIS = (ClassGen) o1;
 final ClassGen THAT = (ClassGen) o2;
-return THIS.getClassName().equals(THAT.getClassName());
+return Objects.equals(THIS.getClassName(), THAT.getClassName());
 }
 @Override
-public int hashCode(final Object o) {
+public int hashCode( final Object o ) {
 final ClassGen THIS = (ClassGen) o;
 return THIS.getClassName().hashCode();
 }
 };
-/**
-* Convenience constructor to set up some important values initially.
+/** Convenience constructor to set up some important values initially.
 *
 * @param class_name fully qualified class name
 * @param super_class_name fully qualified superclass name
 * @param file_name source file name
 * @param access_flags access qualifiers
 addInterface(interface1);
 }
 }
 }
-/**
-* Convenience constructor to set up some important values initially.
+/** Convenience constructor to set up some important values initially.
 *
 * @param class_name fully qualified class name
 * @param super_class_name fully qualified superclass name
 * @param file_name source file name
 * @param access_flags access qualifiers
 final String[] interfaces) {
 this(class_name, super_class_name, file_name, access_flags, interfaces,
 new ConstantPoolGen());
 }
 /**
 * Initialize with existing class.
-*
 * @param clazz JavaClass object (e.g. read from file)
 */
 public ClassGen(final JavaClass clazz) {
 super(clazz.getAccessFlags());
 class_name_index = clazz.getClassNameIndex();
 }
 /**
 * Look for attributes representing annotations and unpack them.
 */
-private AnnotationEntryGen[] unpackAnnotations(final Attribute[] attrs) {
+private AnnotationEntryGen[] unpackAnnotations(final Attribute[] attrs)
+{
 final List<AnnotationEntryGen> annotationGenObjs = new ArrayList<>();
 for (final Attribute attr : attrs) {
-if (attr instanceof RuntimeVisibleAnnotations) {
+if (attr instanceof RuntimeVisibleAnnotations)
+{
 final RuntimeVisibleAnnotations rva = (RuntimeVisibleAnnotations) attr;
 final AnnotationEntry[] annos = rva.getAnnotationEntries();
 for (final AnnotationEntry a : annos) {
 annotationGenObjs.add(new AnnotationEntryGen(a,
 getConstantPool(), false));
 }
-} else if (attr instanceof RuntimeInvisibleAnnotations) {
+}
-final RuntimeInvisibleAnnotations ria = (RuntimeInvisibleAnnotations) attr;
+else
-final AnnotationEntry[] annos = ria.getAnnotationEntries();
+if (attr instanceof RuntimeInvisibleAnnotations)
-for (final AnnotationEntry a : annos) {
+{
-annotationGenObjs.add(new AnnotationEntryGen(a,
+final RuntimeInvisibleAnnotations ria = (RuntimeInvisibleAnnotations) attr;
-getConstantPool(), false));
+final AnnotationEntry[] annos = ria.getAnnotationEntries();
+for (final AnnotationEntry a : annos) {
+annotationGenObjs.add(new AnnotationEntryGen(a,
+getConstantPool(), false));
+}
 }
-}
 }
 return annotationGenObjs.toArray(new AnnotationEntryGen[annotationGenObjs.size()]);
 }
 /**
 * @return the (finally) built up Java class object.
 */
 public JavaClass getJavaClass() {
 final int[] interfaces = getInterfaces();
 final Field[] fields = getFields();
 final Method[] methods = getMethods();
-Attribute[] attributes;
+Attribute[] attributes = null;
 if (annotation_vec.isEmpty()) {
 attributes = getAttributes();
 } else {
 // TODO: Sometime later, trash any attributes called 'RuntimeVisibleAnnotations' or 'RuntimeInvisibleAnnotations'
-final Attribute[] annAttributes = AnnotationEntryGen.getAnnotationAttributes(cp, getAnnotationEntries());
+final Attribute[] annAttributes  = AnnotationEntryGen.getAnnotationAttributes(cp, getAnnotationEntries());
-attributes = new Attribute[attribute_vec.size() + annAttributes.length];
+attributes = new Attribute[attribute_vec.size()+annAttributes.length];
 attribute_vec.toArray(attributes);
-System.arraycopy(annAttributes, 0, attributes, attribute_vec.size(), annAttributes.length);
+System.arraycopy(annAttributes,0,attributes,attribute_vec.size(),annAttributes.length);
 }
 // Must be last since the above calls may still add something to it
 final ConstantPool _cp = this.cp.getFinalConstantPool();
 return new JavaClass(class_name_index, superclass_name_index, file_name, major, minor,
 super.getAccessFlags(), _cp, interfaces, fields, methods, attributes);
 }
 /**
 * Add an interface to this class, i.e., this class has to implement it.
-*
 * @param name interface to implement (fully qualified class name)
 */
-public final void addInterface(final String name) {
+public void addInterface( final String name ) {
 interface_vec.add(name);
 }
 /**
 * Remove an interface from this class.
-*
 * @param name interface to remove (fully qualified name)
 */
-public void removeInterface(final String name) {
+public void removeInterface( final String name ) {
 interface_vec.remove(name);
 }
 /**
 * @return major version number of class file
 */
 public int getMajor() {
 return major;
 }
-/**
-* Set major version number of class file, default value is 45 (JDK 1.1)
+/** Set major version number of class file, default value is 45 (JDK 1.1)
-*
 * @param major major version number
 */
-public void setMajor(final int major) { // TODO could be package-protected - only called by test code
+public void setMajor( final int major ) { // TODO could be package-protected - only called by test code
 this.major = major;
 }
-/**
-* Set minor version number of class file, default value is 3 (JDK 1.1)
+/** Set minor version number of class file, default value is 3 (JDK 1.1)
-*
 * @param minor minor version number
 */
-public void setMinor(final int minor) {  // TODO could be package-protected - only called by test code
+public void setMinor( final int minor ) {  // TODO could be package-protected - only called by test code
 this.minor = minor;
 }
 /**
 * @return minor version number of class file
 */
 public int getMinor() {
 return minor;
 }
 /**
 * Add an attribute to this class.
-*
 * @param a attribute to add
 */
-public final void addAttribute(final Attribute a) {
+public void addAttribute( final Attribute a ) {
 attribute_vec.add(a);
 }
-public final void addAnnotationEntry(final AnnotationEntryGen a) {
+public void addAnnotationEntry(final AnnotationEntryGen a) {
 annotation_vec.add(a);
 }
 /**
 * Add a method to this class.
-*
 * @param m method to add
 */
-public final void addMethod(final Method m) {
+public void addMethod( final Method m ) {
 method_vec.add(m);
 }
 /**
 * Convenience method.
 *
-* Add an empty constructor to this class that does nothing but calling
+* Add an empty constructor to this class that does nothing but calling super().
-* super().
-*
 * @param access_flags rights for constructor
 */
-public void addEmptyConstructor(final int access_flags) {
+public void addEmptyConstructor( final int access_flags ) {
 final InstructionList il = new InstructionList();
 il.append(InstructionConst.THIS); // Push `this'
 il.append(new INVOKESPECIAL(cp.addMethodref(super_class_name, "<init>", "()V")));
 il.append(InstructionConst.RETURN);
 final MethodGen mg = new MethodGen(access_flags, Type.VOID, Type.NO_ARGS, null, "<init>",
 class_name, il, cp);
 mg.setMaxStack(1);
 addMethod(mg.getMethod());
 }
 /**
 * Add a field to this class.
-*
 * @param f field to add
 */
-public final void addField(final Field f) {
+public void addField( final Field f ) {
 field_vec.add(f);
 }
-public boolean containsField(final Field f) {
+public boolean containsField( final Field f ) {
 return field_vec.contains(f);
 }
-/**
-* @return field object with given name, or null
+/** @return field object with given name, or null
 */
-public Field containsField(final String name) {
+public Field containsField( final String name ) {
 for (final Field f : field_vec) {
 if (f.getName().equals(name)) {
 return f;
 }
 }
 return null;
 }
-/**
-* @return method object with given name and signature, or null
+/** @return method object with given name and signature, or null
 */
-public Method containsMethod(final String name, final String signature) {
+public Method containsMethod( final String name, final String signature ) {
 for (final Method m : method_vec) {
 if (m.getName().equals(name) && m.getSignature().equals(signature)) {
 return m;
 }
 }
 return null;
 }
 /**
 * Remove an attribute from this class.
-*
 * @param a attribute to remove
 */
-public void removeAttribute(final Attribute a) {
+public void removeAttribute( final Attribute a ) {
 attribute_vec.remove(a);
 }
 /**
 * Remove a method from this class.
-*
 * @param m method to remove
 */
-public void removeMethod(final Method m) {
+public void removeMethod( final Method m ) {
 method_vec.remove(m);
 }
-/**
-* Replace given method with new one. If the old one does not exist add the
+/** Replace given method with new one. If the old one does not exist
-* new_ method to the class anyway.
+* add the new_ method to the class anyway.
 */
-public void replaceMethod(final Method old, final Method new_) {
+public void replaceMethod( final Method old, final Method new_ ) {
 if (new_ == null) {
 throw new ClassGenException("Replacement method must not be null");
 }
 final int i = method_vec.indexOf(old);
 if (i < 0) {
 } else {
 method_vec.set(i, new_);
 }
 }
-/**
-* Replace given field with new one. If the old one does not exist add the
+/** Replace given field with new one. If the old one does not exist
-* new_ field to the class anyway.
+* add the new_ field to the class anyway.
 */
-public void replaceField(final Field old, final Field new_) {
+public void replaceField( final Field old, final Field new_ ) {
 if (new_ == null) {
 throw new ClassGenException("Replacement method must not be null");
 }
 final int i = field_vec.indexOf(old);
 if (i < 0) {
 } else {
 field_vec.set(i, new_);
 }
 }
 /**
 * Remove a field to this class.
-*
 * @param f field to remove
 */
-public void removeField(final Field f) {
+public void removeField( final Field f ) {
 field_vec.remove(f);
 }
 public String getClassName() {
 return class_name;
 }
 public String getSuperclassName() {
 return super_class_name;
 }
 public String getFileName() {
 return file_name;
 }
-public void setClassName(final String name) {
+public void setClassName( final String name ) {
 class_name = name.replace('/', '.');
 class_name_index = cp.addClass(name);
 }
-public void setSuperclassName(final String name) {
+public void setSuperclassName( final String name ) {
 super_class_name = name.replace('/', '.');
 superclass_name_index = cp.addClass(name);
 }
 public Method[] getMethods() {
 return method_vec.toArray(new Method[method_vec.size()]);
 }
-public void setMethods(final Method[] methods) {
+public void setMethods( final Method[] methods ) {
 method_vec.clear();
 for (final Method method : methods) {
 addMethod(method);
 }
 }
-public void setMethodAt(final Method method, final int pos) {
+public void setMethodAt( final Method method, final int pos ) {
 method_vec.set(pos, method);
 }
-public Method getMethodAt(final int pos) {
+public Method getMethodAt( final int pos ) {
 return method_vec.get(pos);
 }
 public String[] getInterfaceNames() {
 final int size = interface_vec.size();
 final String[] interfaces = new String[size];
 interface_vec.toArray(interfaces);
 return interfaces;
 }
 public int[] getInterfaces() {
 final int size = interface_vec.size();
 final int[] interfaces = new int[size];
 for (int i = 0; i < size; i++) {
 interfaces[i] = cp.addClass(interface_vec.get(i));
 }
 return interfaces;
 }
 public Field[] getFields() {
 return field_vec.toArray(new Field[field_vec.size()]);
 }
 public Attribute[] getAttributes() {
 return attribute_vec.toArray(new Attribute[attribute_vec.size()]);
 }
 //  J5TODO: Should we make calling unpackAnnotations() lazy and put it in here?
 public AnnotationEntryGen[] getAnnotationEntries() {
 return annotation_vec.toArray(new AnnotationEntryGen[annotation_vec.size()]);
 }
 public ConstantPoolGen getConstantPool() {
 return cp;
 }
-public void setConstantPool(final ConstantPoolGen constant_pool) {
+public void setConstantPool( final ConstantPoolGen constant_pool ) {
 cp = constant_pool;
 }
-public void setClassNameIndex(final int class_name_index) {
+public void setClassNameIndex( final int class_name_index ) {
 this.class_name_index = class_name_index;
 class_name = cp.getConstantPool().getConstantString(class_name_index,
 Const.CONSTANT_Class).replace('/', '.');
 }
-public void setSuperclassNameIndex(final int superclass_name_index) {
+public void setSuperclassNameIndex( final int superclass_name_index ) {
 this.superclass_name_index = superclass_name_index;
 super_class_name = cp.getConstantPool().getConstantString(superclass_name_index,
 Const.CONSTANT_Class).replace('/', '.');
 }
 public int getSuperclassNameIndex() {
 return superclass_name_index;
 }
 public int getClassNameIndex() {
 return class_name_index;
 }
 private List<ClassObserver> observers;
-/**
-* Add observer for this object.
+/** Add observer for this object.
 */
-public void addObserver(final ClassObserver o) {
+public void addObserver( final ClassObserver o ) {
 if (observers == null) {
 observers = new ArrayList<>();
 }
 observers.add(o);
 }
-/**
-* Remove observer for this object.
+/** Remove observer for this object.
 */
-public void removeObserver(final ClassObserver o) {
+public void removeObserver( final ClassObserver o ) {
 if (observers != null) {
 observers.remove(o);
 }
 }
-/**
-* Call notify() method on all observers. This method is not called
+/** Call notify() method on all observers. This method is not called
-* automatically whenever the state has changed, but has to be called by the
+* automatically whenever the state has changed, but has to be
-* user after he has finished editing the object.
+* called by the user after he has finished editing the object.
 */
 public void update() {
 if (observers != null) {
 for (final ClassObserver observer : observers) {
 observer.notify(this);
 }
 }
 }
 @Override
 public Object clone() {
 try {
 return super.clone();
 } catch (final CloneNotSupportedException e) {
 throw new Error("Clone Not Supported"); // never happens
 }
 }
 /**
 * @return Comparison strategy object
 */
 public static BCELComparator getComparator() {
 return _cmp;
 }
 /**
 * @param comparator Comparison strategy object
 */
-public static void setComparator(final BCELComparator comparator) {
+public static void setComparator( final BCELComparator comparator ) {
 _cmp = comparator;
 }
-/**
-* Return value as defined by given BCELComparator strategy. By default two
+/**
-* ClassGen objects are said to be equal when their class names are equal.
+* Return value as defined by given BCELComparator strategy.
+* By default two ClassGen objects are said to be equal when
+* their class names are equal.
 *
 * @see java.lang.Object#equals(java.lang.Object)
 */
 @Override
-public boolean equals(final Object obj) {
+public boolean equals( final Object obj ) {
 return _cmp.equals(this, obj);
 }
-/**
-* Return value as defined by given BCELComparator strategy. By default
+/**
-* return the hashcode of the class name.
+* Return value as defined by given BCELComparator strategy.
+* By default return the hashcode of the class name.
 *
 * @see java.lang.Object#hashCode()
 */
 @Override
 public int hashCode() {

changeset 55496	8e0ae3830fca
parent 47216	71c04702a3d5