1/*
2 * Copyright (c) 2004, 2015, 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
26package sun.management;
27
28import java.io.Serializable;
29import java.util.*;
30import javax.management.openmbean.ArrayType;
31import javax.management.openmbean.CompositeData;
32import javax.management.openmbean.CompositeType;
33import javax.management.openmbean.OpenType;
34import javax.management.openmbean.TabularType;
35
36/**
37 * This abstract class provides the implementation of the CompositeData
38 * interface.  A CompositeData object will be lazily created only when
39 * the CompositeData interface is used.
40 *
41 * Classes that extends this abstract class will implement the
42 * getCompositeData() method. The object returned by the
43 * getCompositeData() is an instance of CompositeData such that
44 * the instance serializes itself as the type CompositeDataSupport.
45 */
46public abstract class LazyCompositeData
47        implements CompositeData, Serializable {
48
49    private CompositeData compositeData;
50
51    // Implementation of the CompositeData interface
52    @Override
53    public boolean containsKey(String key) {
54        return compositeData().containsKey(key);
55    }
56
57    @Override
58    public boolean containsValue(Object value) {
59        return compositeData().containsValue(value);
60    }
61
62    @Override
63    public boolean equals(Object obj) {
64        return compositeData().equals(obj);
65    }
66
67    @Override
68    public Object get(String key) {
69        return compositeData().get(key);
70    }
71
72    @Override
73    public Object[] getAll(String[] keys) {
74        return compositeData().getAll(keys);
75    }
76
77    @Override
78    public CompositeType getCompositeType() {
79        return compositeData().getCompositeType();
80    }
81
82    @Override
83    public int hashCode() {
84        return compositeData().hashCode();
85    }
86
87    @Override
88    public String toString() {
89        /** FIXME: What should this be?? */
90        return compositeData().toString();
91    }
92
93    @Override
94    public Collection<?> values() {
95        return compositeData().values();
96    }
97
98    /* Lazy creation of a CompositeData object
99     * only when the CompositeData interface is used.
100     */
101    private synchronized CompositeData compositeData() {
102        if (compositeData != null)
103            return compositeData;
104        compositeData = getCompositeData();
105        return compositeData;
106    }
107
108    /**
109     * Designate to a CompositeData object when writing to an
110     * output stream during serialization so that the receiver
111     * only requires JMX 1.2 classes but not any implementation
112     * specific class.
113     */
114    protected Object writeReplace() throws java.io.ObjectStreamException {
115        return compositeData();
116    }
117
118    /**
119     * Returns the CompositeData representing this object.
120     * The returned CompositeData object must be an instance
121     * of javax.management.openmbean.CompositeDataSupport class
122     * so that no implementation specific class is required
123     * for unmarshalling besides JMX 1.2 classes.
124     */
125    protected abstract CompositeData getCompositeData();
126
127    // Helper methods
128    public static String getString(CompositeData cd, String itemName) {
129        if (cd == null)
130            throw new IllegalArgumentException("Null CompositeData");
131
132        return (String) cd.get(itemName);
133    }
134
135    public static boolean getBoolean(CompositeData cd, String itemName) {
136        if (cd == null)
137            throw new IllegalArgumentException("Null CompositeData");
138
139        return ((Boolean) cd.get(itemName));
140    }
141
142    public static long getLong(CompositeData cd, String itemName) {
143        if (cd == null)
144            throw new IllegalArgumentException("Null CompositeData");
145
146        return ((Long) cd.get(itemName));
147    }
148
149    public static int getInt(CompositeData cd, String itemName) {
150        if (cd == null)
151            throw new IllegalArgumentException("Null CompositeData");
152
153        return ((Integer) cd.get(itemName));
154    }
155
156    /**
157     * Compares two CompositeTypes and returns true if
158     * all items in type1 exist in type2 and their item types
159     * are the same.
160     * @param type1 the base composite type
161     * @param type2 the checked composite type
162     * @return {@code true} if all items in type1 exist in type2 and their item
163     *         types are the same.
164     */
165    protected static boolean isTypeMatched(CompositeType type1, CompositeType type2) {
166        if (type1 == type2) return true;
167
168        // We can't use CompositeType.isValue() since it returns false
169        // if the type name doesn't match.
170        Set<String> allItems = type1.keySet();
171
172        // Check all items in the type1 exist in type2
173        if (!type2.keySet().containsAll(allItems))
174            return false;
175
176        return allItems.stream().allMatch(
177            item -> isTypeMatched(type1.getType(item), type2.getType(item))
178        );
179    }
180
181    protected static boolean isTypeMatched(TabularType type1, TabularType type2) {
182        if (type1 == type2) return true;
183
184        List<String> list1 = type1.getIndexNames();
185        List<String> list2 = type2.getIndexNames();
186
187        // check if the list of index names are the same
188        if (!list1.equals(list2))
189            return false;
190
191        return isTypeMatched(type1.getRowType(), type2.getRowType());
192    }
193
194    protected static boolean isTypeMatched(ArrayType<?> type1, ArrayType<?> type2) {
195        if (type1 == type2) return true;
196
197        int dim1 = type1.getDimension();
198        int dim2 = type2.getDimension();
199
200        // check if the array dimensions are the same
201        if (dim1 != dim2)
202            return false;
203
204        return isTypeMatched(type1.getElementOpenType(), type2.getElementOpenType());
205    }
206
207    private static boolean isTypeMatched(OpenType<?> ot1, OpenType<?> ot2) {
208        if (ot1 instanceof CompositeType) {
209            if (! (ot2 instanceof CompositeType))
210                return false;
211            if (!isTypeMatched((CompositeType) ot1, (CompositeType) ot2))
212                return false;
213        } else if (ot1 instanceof TabularType) {
214            if (! (ot2 instanceof TabularType))
215                return false;
216            if (!isTypeMatched((TabularType) ot1, (TabularType) ot2))
217                return false;
218        } else if (ot1 instanceof ArrayType) {
219            if (! (ot2 instanceof ArrayType))
220                return false;
221            if (!isTypeMatched((ArrayType<?>) ot1, (ArrayType<?>) ot2)) {
222                return false;
223            }
224        } else if (!ot1.equals(ot2)) {
225            return false;
226        }
227        return true;
228    }
229
230    private static final long serialVersionUID = -2190411934472666714L;
231}
232