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 

    26 package sun.management;

    27 

    28 import java.io.Serializable;

    29 import java.util.*;

    30 import javax.management.openmbean.ArrayType;

    31 import javax.management.openmbean.CompositeData;

    32 import javax.management.openmbean.CompositeType;

    33 import javax.management.openmbean.OpenType;

    34 import 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  */

    46 public 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 }