1/*
2 * Copyright (c) 2005, 2006, 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.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24import java.util.Arrays;
25import javax.management.openmbean.ArrayType;
26import javax.management.openmbean.CompositeData;
27import javax.management.openmbean.CompositeDataSupport;
28import javax.management.openmbean.CompositeDataView;
29import javax.management.openmbean.CompositeType;
30import javax.management.openmbean.OpenDataException;
31import javax.management.openmbean.OpenType;
32import javax.management.openmbean.SimpleType;
33
34public interface MerlinMXBean {
35
36    int PInt = 59;
37    SimpleType PIntType = SimpleType.INTEGER;
38    int getPInt();
39    void setPInt(int x);
40    int opPInt(int x, int y);
41
42    long PLong = Long.MAX_VALUE;
43    SimpleType PLongType = SimpleType.LONG;
44    long getPLong();
45    void setPLong(long x);
46    long opPLong(long x, long y);
47
48    short PShort = 55;
49    SimpleType PShortType = SimpleType.SHORT;
50    short getPShort();
51    void setPShort(short x);
52    short opPShort(short x, short y);
53
54    byte PByte = 13;
55    SimpleType PByteType = SimpleType.BYTE;
56    byte getPByte();
57    void setPByte(byte x);
58    byte opPByte(byte x, byte y);
59
60    char PChar = 'x';
61    SimpleType PCharType = SimpleType.CHARACTER;
62    char getPChar();
63    void setPChar(char x);
64    char opPChar(char x, char y);
65
66    float PFloat = 1.3f;
67    SimpleType PFloatType = SimpleType.FLOAT;
68    float getPFloat();
69    void setPFloat(float x);
70    float opPFloat(float x, float y);
71
72    double PDouble = Double.MAX_VALUE;
73    SimpleType PDoubleType = SimpleType.DOUBLE;
74    double getPDouble();
75    void setPDouble(double x);
76    double opPDouble(double x, double y);
77
78    boolean PBoolean = true;
79    SimpleType PBooleanType = SimpleType.BOOLEAN;
80    boolean getPBoolean();
81    void setPBoolean(boolean x);
82    boolean opPBoolean(boolean x, boolean y);
83
84    Integer WInteger = new Integer(59);
85    SimpleType WIntegerType = SimpleType.INTEGER;
86    Integer getWInteger();
87    void setWInteger(Integer x);
88    Integer opWInteger(Integer x, Integer y);
89
90    Long WLong = new Long(Long.MAX_VALUE);
91    SimpleType WLongType = SimpleType.LONG;
92    Long getWLong();
93    void setWLong(Long x);
94    Long opWLong(Long x, Long y);
95
96    Short WShort = new Short(Short.MAX_VALUE);
97    SimpleType WShortType = SimpleType.SHORT;
98    Short getWShort();
99    void setWShort(Short x);
100    Short opWShort(Short x, Short y);
101
102    Byte WByte = new Byte(Byte.MAX_VALUE);
103    SimpleType WByteType = SimpleType.BYTE;
104    Byte getWByte();
105    void setWByte(Byte x);
106    Byte opWByte(Byte x, Byte y);
107
108    Character WCharacter = new Character('x');
109    SimpleType WCharacterType = SimpleType.CHARACTER;
110    Character getWCharacter();
111    void setWCharacter(Character x);
112    Character opWCharacter(Character x, Character y);
113
114    Float WFloat = new Float(1.3f);
115    SimpleType WFloatType = SimpleType.FLOAT;
116    Float getWFloat();
117    void setWFloat(Float x);
118    Float opWFloat(Float x, Float y);
119
120    Double WDouble = new Double(Double.MAX_VALUE);
121    SimpleType WDoubleType = SimpleType.DOUBLE;
122    Double getWDouble();
123    void setWDouble(Double x);
124    Double opWDouble(Double x, Double y);
125
126    Boolean WBoolean = Boolean.TRUE;
127    SimpleType WBooleanType = SimpleType.BOOLEAN;
128    Boolean getWBoolean();
129    void setWBoolean(Boolean x);
130    Boolean opWBoolean(Boolean x, Boolean y);
131
132    int[] PIntA = {2, 3, 5, 7, 11, 13};
133    ArrayType PIntAType = ArrayTypeMaker.make(SimpleType.INTEGER, true);
134    int[] getPIntA();
135    void setPIntA(int[] x);
136    int[] opPIntA(int[] x, int[] y);
137
138    int[][] PInt2D = {{1, 2}, {3, 4}};
139    ArrayType PInt2DType = ArrayTypeMaker.make(1, PIntAType);
140    int[][] getPInt2D();
141    void setPInt2D(int[][] x);
142    int[][] opPInt2D(int[][] x, int[][] y);
143
144    Integer[] WIntA = {new Integer(3), new Integer(5)};
145    ArrayType WIntAType = ArrayTypeMaker.make(1, SimpleType.INTEGER);
146    Integer[] getWIntA();
147    void setWIntA(Integer[] x);
148    Integer[] opWIntA(Integer[] x, Integer[] y);
149
150    Integer[][] WInt2D = {{new Integer(3)}, {new Integer(5)}};
151    ArrayType WInt2DType = ArrayTypeMaker.make(2, SimpleType.INTEGER);
152    Integer[][] getWInt2D();
153    void setWInt2D(Integer[][] x);
154    Integer[][] opWInt2D(Integer[][] x, Integer[][] y);
155
156    String XString = "yo!";
157    SimpleType XStringType = SimpleType.STRING;
158    String getXString();
159    void setXString(String x);
160    String opXString(String x, String y);
161
162    String[] XStringA = {"hello", "world"};
163    ArrayType XStringAType = ArrayTypeMaker.make(1, SimpleType.STRING);
164    String[] getXStringA();
165    void setXStringA(String[] x);
166    String[] opXStringA(String[] x, String[] y);
167
168    int[] NoInts = {};
169    ArrayType NoIntsType = ArrayTypeMaker.make(SimpleType.INTEGER, true);
170    int[] getNoInts();
171    void setNoInts(int[] x);
172    int[] opNoInts(int[] x, int[] y);
173
174    GetSetBean GetSet = GetSetBean.make(5, "x", new String[] {"a", "b"});
175    CompositeType GetSetType =
176        CompositeTypeMaker.make(GetSetBean.class.getName(),
177                                GetSetBean.class.getName(),
178                                new String[] {"int", "string", "stringArray"},
179                                new String[] {"int", "string", "stringArray"},
180                                new OpenType[] {
181                                    SimpleType.INTEGER,
182                                    SimpleType.STRING,
183                                    ArrayTypeMaker.make(1, SimpleType.STRING),
184                                });
185    GetSetBean getGetSet();
186    void setGetSet(GetSetBean bean);
187    GetSetBean opGetSet(GetSetBean x, GetSetBean y);
188
189    GetterInterface Interface = new GetterInterface() {
190        public boolean isWhatsit() {
191            return true;
192        }
193
194        public int[] getInts() {
195            return new int[] {1};
196        }
197
198        public String[] getStrings() {
199            return new String[] {"x"};
200        }
201
202        public GetSetBean getGetSet() {
203            return GetSetBean.make(3, "a", new String[] {"b"});
204        }
205
206        public boolean equals(Object o) {
207            if (!(o instanceof GetterInterface))
208                return false;
209            GetterInterface i = (GetterInterface) o;
210            return isWhatsit() == i.isWhatsit() &&
211                   Arrays.equals(getInts(), i.getInts()) &&
212                   Arrays.equals(getStrings(), i.getStrings()) &&
213                   getGetSet().equals(i.getGetSet());
214        }
215     };
216     CompositeType InterfaceType =
217        CompositeTypeMaker.make(GetterInterface.class.getName(),
218                                GetterInterface.class.getName(),
219                                new String[] {
220                                    "ints", "getSet", "strings", "whatsit",
221                                },
222                                new String[] {
223                                    "ints", "getSet", "strings", "whatsit",
224                                },
225                                new OpenType[] {
226                                    ArrayTypeMaker.make(SimpleType.INTEGER, true),
227                                    GetSetType,
228                                    ArrayTypeMaker.make(1, SimpleType.STRING),
229                                    SimpleType.BOOLEAN,
230                                });
231     GetterInterface getInterface();
232     void setInterface(GetterInterface i);
233     GetterInterface opInterface(GetterInterface x, GetterInterface y);
234
235    /* Testing that we can use a public no-arg constructor plus a setter
236     * for every getter to reconstruct this object.  Note that the
237     * constructor-guessing logic is no longer valid for this class,
238     * so if we can reconstruct it it must be because of the setters.
239     */
240    public static class GetSetBean {
241        public GetSetBean() {
242            this(0, null, null);
243        }
244
245        private GetSetBean(int Int, String string, String[] stringArray) {
246            this.Int = Int;
247            this.string = string;
248            this.stringArray = stringArray;
249        }
250
251        public static GetSetBean
252                make(int Int, String string, String[] stringArray) {
253            GetSetBean b = new GetSetBean(Int, string, stringArray);
254            return b;
255        }
256
257        public int getInt() {
258            return Int;
259        }
260
261        public String getString() {
262            return this.string;
263        }
264
265        public String[] getStringArray() {
266            return this.stringArray;
267        }
268
269        public void setInt(int x) {
270            this.Int = x;
271        }
272
273        public void setString(String string) {
274            this.string = string;
275        }
276
277        public void setStringArray(String[] stringArray) {
278            this.stringArray = stringArray;
279        }
280
281        public boolean equals(Object o) {
282            if (!(o instanceof GetSetBean))
283                return false;
284            GetSetBean b = (GetSetBean) o;
285            return (b.Int == Int &&
286                    b.string.equals(string) &&
287                    Arrays.equals(b.stringArray, stringArray));
288        }
289
290        String string;
291        String[] stringArray;
292        int Int;
293    }
294
295    public static interface GetterInterface {
296        public String[] getStrings();
297        public int[] getInts();
298        public boolean isWhatsit();
299        public GetSetBean getGetSet();
300
301        // We uselessly mention the public methods inherited from Object because
302        // they should not prevent the interface from being translatable.
303        // We could consider encoding the result of hashCode() and toString()
304        // on the original object that implements this interface into the
305        // generated CompositeData and referencing that in the proxy, but
306        // that seems ambitious for now.  Doing it only if hashCode() and/or
307        // toString() are mentioned in the interface is a possibility but
308        // a rather abstruse one.
309        public boolean equals(Object o);
310        public int hashCode();
311        public String toString();
312    }
313
314    public static class ArrayTypeMaker {
315        static ArrayType make(int dims, OpenType baseType) {
316            try {
317                return new ArrayType(dims, baseType);
318            } catch (OpenDataException e) {
319                throw new Error(e);
320            }
321        }
322
323        static ArrayType make(SimpleType baseType, boolean primitiveArray) {
324            try {
325                return new ArrayType(baseType, primitiveArray);
326            } catch (OpenDataException e) {
327                throw new Error(e);
328            }
329        }
330    }
331
332    public static class CompositeTypeMaker {
333        static CompositeType make(String className,
334                                  String description,
335                                  String[] itemNames,
336                                  String[] itemDescriptions,
337                                  OpenType[] itemTypes) {
338            try {
339                return new CompositeType(className,
340                                         description,
341                                         itemNames,
342                                         itemDescriptions,
343                                         itemTypes);
344            } catch (OpenDataException e) {
345                throw new Error(e);
346            }
347        }
348    }
349
350    public static interface GraphMXBean {
351        public NodeMXBean[] getNodes();
352    }
353
354    public static class Graph implements GraphMXBean {
355        public Graph(Node... nodes) {
356            for (Node node : nodes)
357                node.setGraph(this);
358            this.nodes = nodes;
359        }
360
361        public NodeMXBean[] getNodes() {
362            return nodes;
363        }
364
365        private final Node[] nodes;
366    }
367
368    public static interface NodeMXBean {
369        public String getName();
370        public GraphMXBean getGraph();
371    }
372
373    public static class Node implements NodeMXBean {
374        public Node(String name) {
375            this.name = name;
376        }
377
378        public String getName() {
379            return name;
380        }
381
382        public GraphMXBean getGraph() {
383            return graph;
384        }
385
386        public void setGraph(Graph graph) {
387            this.graph = graph;
388        }
389
390        private final String name;
391        private Graph graph;
392    }
393
394    SimpleType GraphType = SimpleType.OBJECTNAME;
395    GraphMXBean getGraph();
396    void setGraph(GraphMXBean g);
397    GraphMXBean opGraph(GraphMXBean x, GraphMXBean y);
398    String GraphObjectName = "test:type=GraphMXBean";
399    String NodeAObjectName = "test:type=NodeMXBean,name=a";
400    String NodeBObjectName = "test:type=NodeMXBean,name=b";
401    Node NodeA = new Node("a");
402    Node NodeB = new Node("b");
403    GraphMXBean Graph = new Graph(NodeA, NodeB);
404
405    public static class ExoticCompositeData implements CompositeDataView {
406        private ExoticCompositeData(String whatsit) {
407            this.whatsit = whatsit;
408        }
409
410        public static ExoticCompositeData from(CompositeData cd) {
411            String whatsit = (String) cd.get("whatsit");
412            if (!whatsit.startsWith("!"))
413                throw new IllegalArgumentException(whatsit);
414            return new ExoticCompositeData(whatsit.substring(1));
415        }
416
417        public CompositeData toCompositeData(CompositeType ct) {
418            try {
419                return new CompositeDataSupport(ct, new String[] {"whatsit"},
420                                                new String[] {"!" + whatsit});
421            } catch (Exception e) {
422                throw new RuntimeException(e);
423            }
424        }
425
426        public String getWhatsit() {
427            return whatsit;
428        }
429
430        public boolean equals(Object o) {
431            return ((o instanceof ExoticCompositeData) &&
432                    ((ExoticCompositeData) o).whatsit.equals(whatsit));
433        }
434
435        private final String whatsit;
436
437        public static final CompositeType type;
438        static {
439            try {
440                type =
441                    new CompositeType(ExoticCompositeData.class.getName(),
442                                      ExoticCompositeData.class.getName(),
443                                      new String[] {"whatsit"},
444                                      new String[] {"whatsit"},
445                                      new OpenType[] {SimpleType.STRING});
446            } catch (Exception e) {
447                throw new RuntimeException(e);
448            }
449        }
450    }
451    CompositeType ExoticType = ExoticCompositeData.type;
452    ExoticCompositeData getExotic();
453    void setExotic(ExoticCompositeData ecd);
454    ExoticCompositeData opExotic(ExoticCompositeData ecd1,
455                                 ExoticCompositeData ecd2);
456    ExoticCompositeData Exotic = new ExoticCompositeData("foo");
457}
458