001: /*
002: * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved.
003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004: *
005: * This code is free software; you can redistribute it and/or modify it
006: * under the terms of the GNU General Public License version 2 only, as
007: * published by the Free Software Foundation. Sun designates this
008: * particular file as subject to the "Classpath" exception as provided
009: * by Sun in the LICENSE file that accompanied this code.
010: *
011: * This code is distributed in the hope that it will be useful, but WITHOUT
012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014: * version 2 for more details (a copy is included in the LICENSE file that
015: * accompanied this code).
016: *
017: * You should have received a copy of the GNU General Public License version
018: * 2 along with this work; if not, write to the Free Software Foundation,
019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020: *
021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022: * CA 95054 USA or visit www.sun.com if you need additional information or
023: * have any questions.
024: */
025:
026: package sun.management;
027:
028: import java.io.Serializable;
029: import java.util.*;
030: import javax.management.openmbean.CompositeData;
031: import javax.management.openmbean.CompositeType;
032: import javax.management.openmbean.OpenType;
033: import javax.management.openmbean.TabularType;
034:
035: /**
036: * This abstract class provides the implementation of the CompositeData
037: * interface. A CompositeData object will be lazily created only when
038: * the CompositeData interface is used.
039: *
040: * Classes that extends this abstract class will implement the
041: * getCompositeData() method. The object returned by the
042: * getCompositeData() is an instance of CompositeData such that
043: * the instance serializes itself as the type CompositeDataSupport.
044: */
045: public abstract class LazyCompositeData implements CompositeData,
046: Serializable {
047:
048: private CompositeData compositeData;
049:
050: // Implementation of the CompositeData interface
051: public boolean containsKey(String key) {
052: return compositeData().containsKey(key);
053: }
054:
055: public boolean containsValue(Object value) {
056: return compositeData().containsValue(value);
057: }
058:
059: public boolean equals(Object obj) {
060: return compositeData().equals(obj);
061: }
062:
063: public Object get(String key) {
064: return compositeData().get(key);
065: }
066:
067: public Object[] getAll(String[] keys) {
068: return compositeData().getAll(keys);
069: }
070:
071: public CompositeType getCompositeType() {
072: return compositeData().getCompositeType();
073: }
074:
075: public int hashCode() {
076: return compositeData().hashCode();
077: }
078:
079: public String toString() {
080: /** FIXME: What should this be?? */
081: return compositeData().toString();
082: }
083:
084: public Collection values() {
085: return compositeData().values();
086: }
087:
088: /* Lazy creation of a CompositeData object
089: * only when the CompositeData interface is used.
090: */
091: private synchronized CompositeData compositeData() {
092: if (compositeData != null)
093: return compositeData;
094: compositeData = getCompositeData();
095: return compositeData;
096: }
097:
098: /**
099: * Designate to a CompositeData object when writing to an
100: * output stream during serialization so that the receiver
101: * only requires JMX 1.2 classes but not any implementation
102: * specific class.
103: */
104: protected Object writeReplace()
105: throws java.io.ObjectStreamException {
106: return compositeData();
107: }
108:
109: /**
110: * Returns the CompositeData representing this object.
111: * The returned CompositeData object must be an instance
112: * of javax.management.openmbean.CompositeDataSupport class
113: * so that no implementation specific class is required
114: * for unmarshalling besides JMX 1.2 classes.
115: */
116: protected abstract CompositeData getCompositeData();
117:
118: // Helper methods
119: static String getString(CompositeData cd, String itemName) {
120: if (cd == null)
121: throw new IllegalArgumentException("Null CompositeData");
122:
123: return (String) cd.get(itemName);
124: }
125:
126: static boolean getBoolean(CompositeData cd, String itemName) {
127: if (cd == null)
128: throw new IllegalArgumentException("Null CompositeData");
129:
130: return ((Boolean) cd.get(itemName)).booleanValue();
131: }
132:
133: static long getLong(CompositeData cd, String itemName) {
134: if (cd == null)
135: throw new IllegalArgumentException("Null CompositeData");
136:
137: return ((Long) cd.get(itemName)).longValue();
138: }
139:
140: static int getInt(CompositeData cd, String itemName) {
141: if (cd == null)
142: throw new IllegalArgumentException("Null CompositeData");
143:
144: return ((Integer) cd.get(itemName)).intValue();
145: }
146:
147: /**
148: * Compares two CompositeTypes and returns true if
149: * all items in type1 exist in type2 and their item types
150: * are the same.
151: */
152: protected static boolean isTypeMatched(CompositeType type1,
153: CompositeType type2) {
154: if (type1 == type2)
155: return true;
156:
157: // We can't use CompositeType.isValue() since it returns false
158: // if the type name doesn't match.
159: Set allItems = type1.keySet();
160:
161: // Check all items in the type1 exist in type2
162: if (!type2.keySet().containsAll(allItems))
163: return false;
164:
165: for (Iterator iter = allItems.iterator(); iter.hasNext();) {
166: String item = (String) iter.next();
167: OpenType ot1 = type1.getType(item);
168: OpenType ot2 = type2.getType(item);
169: if (ot1 instanceof CompositeType) {
170: if (!(ot2 instanceof CompositeType))
171: return false;
172: if (!isTypeMatched((CompositeType) ot1,
173: (CompositeType) ot2))
174: return false;
175: } else if (ot1 instanceof TabularType) {
176: if (!(ot2 instanceof TabularType))
177: return false;
178: if (!isTypeMatched((TabularType) ot1, (TabularType) ot2))
179: return false;
180: } else if (!ot1.equals(ot2)) {
181: return false;
182: }
183: }
184: return true;
185: }
186:
187: protected static boolean isTypeMatched(TabularType type1,
188: TabularType type2) {
189: if (type1 == type2)
190: return true;
191:
192: List list1 = type1.getIndexNames();
193: List list2 = type2.getIndexNames();
194:
195: // check if the list of index names are the same
196: if (!list1.equals(list2))
197: return false;
198:
199: return isTypeMatched(type1.getRowType(), type2.getRowType());
200: }
201: }
|