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