| /* |
| * 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"); |
| } |