View Javadoc
1   /*
2    * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package javax.management;
27  
28  import com.sun.jmx.mbeanserver.Introspector;
29  import java.lang.annotation.Annotation;
30  import java.lang.reflect.Constructor;
31  import java.util.Arrays;
32  import java.util.Objects;
33  
34  /**
35   * Describes a constructor exposed by an MBean.  Instances of this
36   * class are immutable.  Subclasses may be mutable but this is not
37   * recommended.
38   *
39   * @since 1.5
40   */
41  public class MBeanConstructorInfo extends MBeanFeatureInfo implements Cloneable {
42  
43      /* Serial version */
44      static final long serialVersionUID = 4433990064191844427L;
45  
46      static final MBeanConstructorInfo[] NO_CONSTRUCTORS =
47          new MBeanConstructorInfo[0];
48  
49      /** @see MBeanInfo#arrayGettersSafe */
50      private final transient boolean arrayGettersSafe;
51  
52      /**
53       * @serial The signature of the method, that is, the class names of the arguments.
54       */
55      private final MBeanParameterInfo[] signature;
56  
57      /**
58       * Constructs an <CODE>MBeanConstructorInfo</CODE> object.  The
59       * {@link Descriptor} of the constructed object will include
60       * fields contributed by any annotations on the {@code
61       * Constructor} object that contain the {@link DescriptorKey}
62       * meta-annotation.
63       *
64       * @param description A human readable description of the operation.
65       * @param constructor The <CODE>java.lang.reflect.Constructor</CODE>
66       * object describing the MBean constructor.
67       */
68      public MBeanConstructorInfo(String description, Constructor<?> constructor) {
69          this(constructor.getName(), description,
70               constructorSignature(constructor),
71               Introspector.descriptorForElement(constructor));
72      }
73  
74      /**
75       * Constructs an <CODE>MBeanConstructorInfo</CODE> object.
76       *
77       * @param name The name of the constructor.
78       * @param signature <CODE>MBeanParameterInfo</CODE> objects
79       * describing the parameters(arguments) of the constructor.  This
80       * may be null with the same effect as a zero-length array.
81       * @param description A human readable description of the constructor.
82       */
83      public MBeanConstructorInfo(String name,
84                                  String description,
85                                  MBeanParameterInfo[] signature) {
86          this(name, description, signature, null);
87      }
88  
89      /**
90       * Constructs an <CODE>MBeanConstructorInfo</CODE> object.
91       *
92       * @param name The name of the constructor.
93       * @param signature <CODE>MBeanParameterInfo</CODE> objects
94       * describing the parameters(arguments) of the constructor.  This
95       * may be null with the same effect as a zero-length array.
96       * @param description A human readable description of the constructor.
97       * @param descriptor The descriptor for the constructor.  This may be null
98       * which is equivalent to an empty descriptor.
99       *
100      * @since 1.6
101      */
102     public MBeanConstructorInfo(String name,
103                                 String description,
104                                 MBeanParameterInfo[] signature,
105                                 Descriptor descriptor) {
106         super(name, description, descriptor);
107 
108         if (signature == null || signature.length == 0)
109             signature = MBeanParameterInfo.NO_PARAMS;
110         else
111             signature = signature.clone();
112         this.signature = signature;
113         this.arrayGettersSafe =
114             MBeanInfo.arrayGettersSafe(this.getClass(),
115                                        MBeanConstructorInfo.class);
116     }
117 
118 
119     /**
120      * <p>Returns a shallow clone of this instance.  The clone is
121      * obtained by simply calling <tt>super.clone()</tt>, thus calling
122      * the default native shallow cloning mechanism implemented by
123      * <tt>Object.clone()</tt>.  No deeper cloning of any internal
124      * field is made.</p>
125      *
126      * <p>Since this class is immutable, cloning is chiefly of
127      * interest to subclasses.</p>
128      */
129      public Object clone () {
130          try {
131              return super.clone() ;
132          } catch (CloneNotSupportedException e) {
133              // should not happen as this class is cloneable
134              return null;
135          }
136      }
137 
138     /**
139      * <p>Returns the list of parameters for this constructor.  Each
140      * parameter is described by an <CODE>MBeanParameterInfo</CODE>
141      * object.</p>
142      *
143      * <p>The returned array is a shallow copy of the internal array,
144      * which means that it is a copy of the internal array of
145      * references to the <CODE>MBeanParameterInfo</CODE> objects but
146      * that each referenced <CODE>MBeanParameterInfo</CODE> object is
147      * not copied.</p>
148      *
149      * @return  An array of <CODE>MBeanParameterInfo</CODE> objects.
150      */
151     public MBeanParameterInfo[] getSignature() {
152         if (signature.length == 0)
153             return signature;
154         else
155             return signature.clone();
156     }
157 
158     private MBeanParameterInfo[] fastGetSignature() {
159         if (arrayGettersSafe)
160             return signature;
161         else
162             return getSignature();
163     }
164 
165     public String toString() {
166         return
167             getClass().getName() + "[" +
168             "description=" + getDescription() + ", " +
169             "name=" + getName() + ", " +
170             "signature=" + Arrays.asList(fastGetSignature()) + ", " +
171             "descriptor=" + getDescriptor() +
172             "]";
173     }
174 
175     /**
176      * Compare this MBeanConstructorInfo to another.
177      *
178      * @param o the object to compare to.
179      *
180      * @return true if and only if <code>o</code> is an MBeanConstructorInfo such
181      * that its {@link #getName()}, {@link #getDescription()},
182      * {@link #getSignature()}, and {@link #getDescriptor()}
183      * values are equal (not necessarily
184      * identical) to those of this MBeanConstructorInfo.  Two
185      * signature arrays are equal if their elements are pairwise
186      * equal.
187      */
188     public boolean equals(Object o) {
189         if (o == this)
190             return true;
191         if (!(o instanceof MBeanConstructorInfo))
192             return false;
193         MBeanConstructorInfo p = (MBeanConstructorInfo) o;
194         return (Objects.equals(p.getName(), getName()) &&
195                 Objects.equals(p.getDescription(), getDescription()) &&
196                 Arrays.equals(p.fastGetSignature(), fastGetSignature()) &&
197                 Objects.equals(p.getDescriptor(), getDescriptor()));
198     }
199 
200     /* Unlike attributes and operations, it's quite likely we'll have
201        more than one constructor with the same name and even
202        description, so we include the parameter array in the hashcode.
203        We don't include the description, though, because it could be
204        quite long and yet the same between constructors.  Likewise for
205        the descriptor.  */
206     public int hashCode() {
207         return Objects.hash(getName()) ^ Arrays.hashCode(fastGetSignature());
208     }
209 
210     private static MBeanParameterInfo[] constructorSignature(Constructor<?> cn) {
211         final Class<?>[] classes = cn.getParameterTypes();
212         final Annotation[][] annots = cn.getParameterAnnotations();
213         return MBeanOperationInfo.parameters(classes, annots);
214     }
215 }