001: /**
002: * The XMOJO Project 5
003: * Copyright © 2003 XMOJO.org. All rights reserved.
004:
005: * NO WARRANTY
006:
007: * BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR
008: * THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
009: * OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
010: * PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
011: * OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
012: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
013: * TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE
014: * LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
015: * REPAIR OR CORRECTION.
016:
017: * IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
018: * ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE
019: * THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
020: * GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
021: * USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF
022: * DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
023: * PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE),
024: * EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
025: * SUCH DAMAGES.
026: **/package javax.management;
027:
028: import java.lang.reflect.Method;
029: import java.io.Serializable;
030: import java.io.ObjectInputStream;
031: import java.io.ObjectInputStream.GetField;
032: import java.io.ObjectOutputStream;
033: import java.io.ObjectOutputStream.PutField;
034: import java.io.ObjectStreamField;
035: import java.io.IOException;
036:
037: /**
038: * Describes a management operation exposed by an MBean.
039: */
040: public class MBeanOperationInfo extends MBeanFeatureInfo implements
041: Serializable, Cloneable {
042: /**
043: * Indicates that the operation is a write-like in nature, and would
044: * modify the MBean in some way, typically by writing some value or
045: * changing a configuration.
046: */
047: public static final int ACTION = 1;
048:
049: /**
050: * Indicates that the operation is a read/write-like in nature.
051: **/
052: public static final int ACTION_INFO = 2;
053: /**
054: * Indicates that the operation is a read-like in nature, it basically returns some information.
055: **/
056: public static final int INFO = 3;
057: /**
058: * Indicates that the operation has an "unknown" nature.
059: **/
060: public static final int UNKNOWN = 4;
061:
062: //checkout the default values...
063:
064: private transient java.lang.reflect.Method method = null;
065: private MBeanParameterInfo[] signature = null;
066: private String type = "void";
067: private int impact = INFO;
068:
069: /* Serial version UID */
070: private static final long serialVersionUID = 0xaa40472295fe839eL;
071:
072: /**
073: * Constructs an <CODE>MBeanOperationInfo</CODE> object.
074: *
075: * @param description A human readable description of the operation.
076: *
077: * @param method The <CODE>java.lang.reflect.Method</CODE> object
078: * describing the MBean operation.
079: */
080: public MBeanOperationInfo(String description, Method method) {
081: super (method.getName(), description);
082:
083: this .method = method;
084: this .name = method.getName();
085: this .type = method.getReturnType().getName();
086:
087: Class[] parameterTypes = method.getParameterTypes();
088:
089: if (parameterTypes.length == 0)
090: this .signature = new MBeanParameterInfo[0];
091: else {
092: this .signature = new MBeanParameterInfo[parameterTypes.length];
093: for (int i = 0; i < parameterTypes.length; i++) {
094: String paramName = "param" + i;
095: String paramDesc = "";
096: signature[i] = new MBeanParameterInfo(paramName,
097: parameterTypes[i].getName(), paramDesc);
098: }
099: }
100: }
101:
102: /**
103: * Constructs an <CODE>MBeanOperationInfo</CODE> object.
104: *
105: * @param name The name of the method.
106: *
107: * @param description A human readable description of the operation.
108: *
109: * @param signature <CODE>MBeanParameterInfo</CODE> objects describing
110: * the parameters(arguments) of the method.
111: *
112: * @param type The type of the method's return value.
113: *
114: * @param impact The impact of the method, one of
115: * <CODE>INFO, ACTION, ACTION_INFO, UNKNOWN</CODE>.
116: */
117: public MBeanOperationInfo(String name, String description,
118: MBeanParameterInfo[] signature, String type, int impact) {
119: super (name, description);
120:
121: if (signature != null)
122: this .signature = signature;
123: else
124: this .signature = new MBeanParameterInfo[0];
125:
126: this .type = type;
127: this .impact = impact;
128: }
129:
130: /**
131: * Returns the impact of the method, one of
132: * <CODE>INFO</CODE>, <CODE>ACTION</CODE>, <CODE>ACTION_INFO</CODE>,
133: * <CODE>UNKNOWN</CODE>.
134: *
135: * @return This returns the impact of the method
136: */
137: public int getImpact() {
138: return impact;
139: }
140:
141: /**
142: * Returns the signature of the method, that is, information on
143: * the operations arguments.
144: *
145: * @return This returs an array of MBeanParameterInfo that is,
146: * information on the operations arguments.
147: */
148: public MBeanParameterInfo[] getSignature() {
149: return signature;
150: }
151:
152: /**
153: * Returns the description of the method's return value.
154: *
155: * @return The return type of the method is returned as a String
156: */
157: public String getReturnType() {
158: return type;
159: }
160:
161: /**
162: * Creates and returns a copy of this object.
163: *
164: * @return A duplicate copy of this object is created
165: */
166: public Object clone() {
167: MBeanParameterInfo[] clonedSig = new MBeanParameterInfo[signature.length];
168:
169: for (int i = 0; i < signature.length; i++)
170: clonedSig[i] = (MBeanParameterInfo) signature[i].clone();
171:
172: return new MBeanOperationInfo(getName(), getDescription(),
173: clonedSig, type, impact);
174: }
175:
176: /**
177: * Returns a human readable version of the MBeanOperationInfo instance
178: *
179: * @return Human readable version of the MBeanOperationInfo instance is returned
180: */
181: public String toString() {
182: return (super .toString() + "\n Type = " + type + "\n Impact = "
183: + convertImpact(impact) + "\n Signature = " + getSignatureString());
184: }
185:
186: //------------------------- Private methods ---------------------------//
187:
188: private String convertImpact(int impact) {
189: if (impact == ACTION)
190: return "ACTION";
191: else if (impact == ACTION_INFO)
192: return "ACTION_INFO";
193: else if (impact == INFO)
194: return "INFO";
195: else if (impact == UNKNOWN)
196: return "UNKNOWN";
197:
198: return "inValid";
199: }
200:
201: private String getSignatureString() {
202: if (signature == null)
203: return "null";
204:
205: String toRet = "";
206:
207: for (int i = 0; i < signature.length; i++)
208: toRet = (toRet + " [param" + (i + 1) + " = "
209: + signature[i].toString() + "]\n");
210:
211: return toRet;
212: }
213: }
|