458 lines
15 KiB
Java
458 lines
15 KiB
Java
/*
|
|
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
import java.util.Arrays;
|
|
import javax.management.openmbean.ArrayType;
|
|
import javax.management.openmbean.CompositeData;
|
|
import javax.management.openmbean.CompositeDataSupport;
|
|
import javax.management.openmbean.CompositeDataView;
|
|
import javax.management.openmbean.CompositeType;
|
|
import javax.management.openmbean.OpenDataException;
|
|
import javax.management.openmbean.OpenType;
|
|
import javax.management.openmbean.SimpleType;
|
|
|
|
public interface MerlinMXBean {
|
|
|
|
int PInt = 59;
|
|
SimpleType PIntType = SimpleType.INTEGER;
|
|
int getPInt();
|
|
void setPInt(int x);
|
|
int opPInt(int x, int y);
|
|
|
|
long PLong = Long.MAX_VALUE;
|
|
SimpleType PLongType = SimpleType.LONG;
|
|
long getPLong();
|
|
void setPLong(long x);
|
|
long opPLong(long x, long y);
|
|
|
|
short PShort = 55;
|
|
SimpleType PShortType = SimpleType.SHORT;
|
|
short getPShort();
|
|
void setPShort(short x);
|
|
short opPShort(short x, short y);
|
|
|
|
byte PByte = 13;
|
|
SimpleType PByteType = SimpleType.BYTE;
|
|
byte getPByte();
|
|
void setPByte(byte x);
|
|
byte opPByte(byte x, byte y);
|
|
|
|
char PChar = 'x';
|
|
SimpleType PCharType = SimpleType.CHARACTER;
|
|
char getPChar();
|
|
void setPChar(char x);
|
|
char opPChar(char x, char y);
|
|
|
|
float PFloat = 1.3f;
|
|
SimpleType PFloatType = SimpleType.FLOAT;
|
|
float getPFloat();
|
|
void setPFloat(float x);
|
|
float opPFloat(float x, float y);
|
|
|
|
double PDouble = Double.MAX_VALUE;
|
|
SimpleType PDoubleType = SimpleType.DOUBLE;
|
|
double getPDouble();
|
|
void setPDouble(double x);
|
|
double opPDouble(double x, double y);
|
|
|
|
boolean PBoolean = true;
|
|
SimpleType PBooleanType = SimpleType.BOOLEAN;
|
|
boolean getPBoolean();
|
|
void setPBoolean(boolean x);
|
|
boolean opPBoolean(boolean x, boolean y);
|
|
|
|
Integer WInteger = new Integer(59);
|
|
SimpleType WIntegerType = SimpleType.INTEGER;
|
|
Integer getWInteger();
|
|
void setWInteger(Integer x);
|
|
Integer opWInteger(Integer x, Integer y);
|
|
|
|
Long WLong = new Long(Long.MAX_VALUE);
|
|
SimpleType WLongType = SimpleType.LONG;
|
|
Long getWLong();
|
|
void setWLong(Long x);
|
|
Long opWLong(Long x, Long y);
|
|
|
|
Short WShort = new Short(Short.MAX_VALUE);
|
|
SimpleType WShortType = SimpleType.SHORT;
|
|
Short getWShort();
|
|
void setWShort(Short x);
|
|
Short opWShort(Short x, Short y);
|
|
|
|
Byte WByte = new Byte(Byte.MAX_VALUE);
|
|
SimpleType WByteType = SimpleType.BYTE;
|
|
Byte getWByte();
|
|
void setWByte(Byte x);
|
|
Byte opWByte(Byte x, Byte y);
|
|
|
|
Character WCharacter = new Character('x');
|
|
SimpleType WCharacterType = SimpleType.CHARACTER;
|
|
Character getWCharacter();
|
|
void setWCharacter(Character x);
|
|
Character opWCharacter(Character x, Character y);
|
|
|
|
Float WFloat = new Float(1.3f);
|
|
SimpleType WFloatType = SimpleType.FLOAT;
|
|
Float getWFloat();
|
|
void setWFloat(Float x);
|
|
Float opWFloat(Float x, Float y);
|
|
|
|
Double WDouble = new Double(Double.MAX_VALUE);
|
|
SimpleType WDoubleType = SimpleType.DOUBLE;
|
|
Double getWDouble();
|
|
void setWDouble(Double x);
|
|
Double opWDouble(Double x, Double y);
|
|
|
|
Boolean WBoolean = Boolean.TRUE;
|
|
SimpleType WBooleanType = SimpleType.BOOLEAN;
|
|
Boolean getWBoolean();
|
|
void setWBoolean(Boolean x);
|
|
Boolean opWBoolean(Boolean x, Boolean y);
|
|
|
|
int[] PIntA = {2, 3, 5, 7, 11, 13};
|
|
ArrayType PIntAType = ArrayTypeMaker.make(SimpleType.INTEGER, true);
|
|
int[] getPIntA();
|
|
void setPIntA(int[] x);
|
|
int[] opPIntA(int[] x, int[] y);
|
|
|
|
int[][] PInt2D = {{1, 2}, {3, 4}};
|
|
ArrayType PInt2DType = ArrayTypeMaker.make(1, PIntAType);
|
|
int[][] getPInt2D();
|
|
void setPInt2D(int[][] x);
|
|
int[][] opPInt2D(int[][] x, int[][] y);
|
|
|
|
Integer[] WIntA = {new Integer(3), new Integer(5)};
|
|
ArrayType WIntAType = ArrayTypeMaker.make(1, SimpleType.INTEGER);
|
|
Integer[] getWIntA();
|
|
void setWIntA(Integer[] x);
|
|
Integer[] opWIntA(Integer[] x, Integer[] y);
|
|
|
|
Integer[][] WInt2D = {{new Integer(3)}, {new Integer(5)}};
|
|
ArrayType WInt2DType = ArrayTypeMaker.make(2, SimpleType.INTEGER);
|
|
Integer[][] getWInt2D();
|
|
void setWInt2D(Integer[][] x);
|
|
Integer[][] opWInt2D(Integer[][] x, Integer[][] y);
|
|
|
|
String XString = "yo!";
|
|
SimpleType XStringType = SimpleType.STRING;
|
|
String getXString();
|
|
void setXString(String x);
|
|
String opXString(String x, String y);
|
|
|
|
String[] XStringA = {"hello", "world"};
|
|
ArrayType XStringAType = ArrayTypeMaker.make(1, SimpleType.STRING);
|
|
String[] getXStringA();
|
|
void setXStringA(String[] x);
|
|
String[] opXStringA(String[] x, String[] y);
|
|
|
|
int[] NoInts = {};
|
|
ArrayType NoIntsType = ArrayTypeMaker.make(SimpleType.INTEGER, true);
|
|
int[] getNoInts();
|
|
void setNoInts(int[] x);
|
|
int[] opNoInts(int[] x, int[] y);
|
|
|
|
GetSetBean GetSet = GetSetBean.make(5, "x", new String[] {"a", "b"});
|
|
CompositeType GetSetType =
|
|
CompositeTypeMaker.make(GetSetBean.class.getName(),
|
|
GetSetBean.class.getName(),
|
|
new String[] {"int", "string", "stringArray"},
|
|
new String[] {"int", "string", "stringArray"},
|
|
new OpenType[] {
|
|
SimpleType.INTEGER,
|
|
SimpleType.STRING,
|
|
ArrayTypeMaker.make(1, SimpleType.STRING),
|
|
});
|
|
GetSetBean getGetSet();
|
|
void setGetSet(GetSetBean bean);
|
|
GetSetBean opGetSet(GetSetBean x, GetSetBean y);
|
|
|
|
GetterInterface Interface = new GetterInterface() {
|
|
public boolean isWhatsit() {
|
|
return true;
|
|
}
|
|
|
|
public int[] getInts() {
|
|
return new int[] {1};
|
|
}
|
|
|
|
public String[] getStrings() {
|
|
return new String[] {"x"};
|
|
}
|
|
|
|
public GetSetBean getGetSet() {
|
|
return GetSetBean.make(3, "a", new String[] {"b"});
|
|
}
|
|
|
|
public boolean equals(Object o) {
|
|
if (!(o instanceof GetterInterface))
|
|
return false;
|
|
GetterInterface i = (GetterInterface) o;
|
|
return isWhatsit() == i.isWhatsit() &&
|
|
Arrays.equals(getInts(), i.getInts()) &&
|
|
Arrays.equals(getStrings(), i.getStrings()) &&
|
|
getGetSet().equals(i.getGetSet());
|
|
}
|
|
};
|
|
CompositeType InterfaceType =
|
|
CompositeTypeMaker.make(GetterInterface.class.getName(),
|
|
GetterInterface.class.getName(),
|
|
new String[] {
|
|
"ints", "getSet", "strings", "whatsit",
|
|
},
|
|
new String[] {
|
|
"ints", "getSet", "strings", "whatsit",
|
|
},
|
|
new OpenType[] {
|
|
ArrayTypeMaker.make(SimpleType.INTEGER, true),
|
|
GetSetType,
|
|
ArrayTypeMaker.make(1, SimpleType.STRING),
|
|
SimpleType.BOOLEAN,
|
|
});
|
|
GetterInterface getInterface();
|
|
void setInterface(GetterInterface i);
|
|
GetterInterface opInterface(GetterInterface x, GetterInterface y);
|
|
|
|
/* Testing that we can use a public no-arg constructor plus a setter
|
|
* for every getter to reconstruct this object. Note that the
|
|
* constructor-guessing logic is no longer valid for this class,
|
|
* so if we can reconstruct it it must be because of the setters.
|
|
*/
|
|
public static class GetSetBean {
|
|
public GetSetBean() {
|
|
this(0, null, null);
|
|
}
|
|
|
|
private GetSetBean(int Int, String string, String[] stringArray) {
|
|
this.Int = Int;
|
|
this.string = string;
|
|
this.stringArray = stringArray;
|
|
}
|
|
|
|
public static GetSetBean
|
|
make(int Int, String string, String[] stringArray) {
|
|
GetSetBean b = new GetSetBean(Int, string, stringArray);
|
|
return b;
|
|
}
|
|
|
|
public int getInt() {
|
|
return Int;
|
|
}
|
|
|
|
public String getString() {
|
|
return this.string;
|
|
}
|
|
|
|
public String[] getStringArray() {
|
|
return this.stringArray;
|
|
}
|
|
|
|
public void setInt(int x) {
|
|
this.Int = x;
|
|
}
|
|
|
|
public void setString(String string) {
|
|
this.string = string;
|
|
}
|
|
|
|
public void setStringArray(String[] stringArray) {
|
|
this.stringArray = stringArray;
|
|
}
|
|
|
|
public boolean equals(Object o) {
|
|
if (!(o instanceof GetSetBean))
|
|
return false;
|
|
GetSetBean b = (GetSetBean) o;
|
|
return (b.Int == Int &&
|
|
b.string.equals(string) &&
|
|
Arrays.equals(b.stringArray, stringArray));
|
|
}
|
|
|
|
String string;
|
|
String[] stringArray;
|
|
int Int;
|
|
}
|
|
|
|
public static interface GetterInterface {
|
|
public String[] getStrings();
|
|
public int[] getInts();
|
|
public boolean isWhatsit();
|
|
public GetSetBean getGetSet();
|
|
|
|
// We uselessly mention the public methods inherited from Object because
|
|
// they should not prevent the interface from being translatable.
|
|
// We could consider encoding the result of hashCode() and toString()
|
|
// on the original object that implements this interface into the
|
|
// generated CompositeData and referencing that in the proxy, but
|
|
// that seems ambitious for now. Doing it only if hashCode() and/or
|
|
// toString() are mentioned in the interface is a possibility but
|
|
// a rather abstruse one.
|
|
public boolean equals(Object o);
|
|
public int hashCode();
|
|
public String toString();
|
|
}
|
|
|
|
public static class ArrayTypeMaker {
|
|
static ArrayType make(int dims, OpenType baseType) {
|
|
try {
|
|
return new ArrayType(dims, baseType);
|
|
} catch (OpenDataException e) {
|
|
throw new Error(e);
|
|
}
|
|
}
|
|
|
|
static ArrayType make(SimpleType baseType, boolean primitiveArray) {
|
|
try {
|
|
return new ArrayType(baseType, primitiveArray);
|
|
} catch (OpenDataException e) {
|
|
throw new Error(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static class CompositeTypeMaker {
|
|
static CompositeType make(String className,
|
|
String description,
|
|
String[] itemNames,
|
|
String[] itemDescriptions,
|
|
OpenType[] itemTypes) {
|
|
try {
|
|
return new CompositeType(className,
|
|
description,
|
|
itemNames,
|
|
itemDescriptions,
|
|
itemTypes);
|
|
} catch (OpenDataException e) {
|
|
throw new Error(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static interface GraphMXBean {
|
|
public NodeMXBean[] getNodes();
|
|
}
|
|
|
|
public static class Graph implements GraphMXBean {
|
|
public Graph(Node... nodes) {
|
|
for (Node node : nodes)
|
|
node.setGraph(this);
|
|
this.nodes = nodes;
|
|
}
|
|
|
|
public NodeMXBean[] getNodes() {
|
|
return nodes;
|
|
}
|
|
|
|
private final Node[] nodes;
|
|
}
|
|
|
|
public static interface NodeMXBean {
|
|
public String getName();
|
|
public GraphMXBean getGraph();
|
|
}
|
|
|
|
public static class Node implements NodeMXBean {
|
|
public Node(String name) {
|
|
this.name = name;
|
|
}
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
public GraphMXBean getGraph() {
|
|
return graph;
|
|
}
|
|
|
|
public void setGraph(Graph graph) {
|
|
this.graph = graph;
|
|
}
|
|
|
|
private final String name;
|
|
private Graph graph;
|
|
}
|
|
|
|
SimpleType GraphType = SimpleType.OBJECTNAME;
|
|
GraphMXBean getGraph();
|
|
void setGraph(GraphMXBean g);
|
|
GraphMXBean opGraph(GraphMXBean x, GraphMXBean y);
|
|
String GraphObjectName = "test:type=GraphMXBean";
|
|
String NodeAObjectName = "test:type=NodeMXBean,name=a";
|
|
String NodeBObjectName = "test:type=NodeMXBean,name=b";
|
|
Node NodeA = new Node("a");
|
|
Node NodeB = new Node("b");
|
|
GraphMXBean Graph = new Graph(NodeA, NodeB);
|
|
|
|
public static class ExoticCompositeData implements CompositeDataView {
|
|
private ExoticCompositeData(String whatsit) {
|
|
this.whatsit = whatsit;
|
|
}
|
|
|
|
public static ExoticCompositeData from(CompositeData cd) {
|
|
String whatsit = (String) cd.get("whatsit");
|
|
if (!whatsit.startsWith("!"))
|
|
throw new IllegalArgumentException(whatsit);
|
|
return new ExoticCompositeData(whatsit.substring(1));
|
|
}
|
|
|
|
public CompositeData toCompositeData(CompositeType ct) {
|
|
try {
|
|
return new CompositeDataSupport(ct, new String[] {"whatsit"},
|
|
new String[] {"!" + whatsit});
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
|
|
public String getWhatsit() {
|
|
return whatsit;
|
|
}
|
|
|
|
public boolean equals(Object o) {
|
|
return ((o instanceof ExoticCompositeData) &&
|
|
((ExoticCompositeData) o).whatsit.equals(whatsit));
|
|
}
|
|
|
|
private final String whatsit;
|
|
|
|
public static final CompositeType type;
|
|
static {
|
|
try {
|
|
type =
|
|
new CompositeType(ExoticCompositeData.class.getName(),
|
|
ExoticCompositeData.class.getName(),
|
|
new String[] {"whatsit"},
|
|
new String[] {"whatsit"},
|
|
new OpenType[] {SimpleType.STRING});
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
}
|
|
}
|
|
CompositeType ExoticType = ExoticCompositeData.type;
|
|
ExoticCompositeData getExotic();
|
|
void setExotic(ExoticCompositeData ecd);
|
|
ExoticCompositeData opExotic(ExoticCompositeData ecd1,
|
|
ExoticCompositeData ecd2);
|
|
ExoticCompositeData Exotic = new ExoticCompositeData("foo");
|
|
}
|