Examples of javax.management.openmbean.TabularDataSupport

javax.management.openmbean.TabularDataSupport
An implementation of TabularData. @author Adrian Brock @version $Revision: 1.1 $

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      data.putAll((CompositeData[]) null);
      assertTrue("Put all null is ok", data.isEmpty());


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);


      HashMap map2 = new HashMap();
      map2.put("name1", "value1");
      map2.put("name2", new Integer(3));
      CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);


      HashMap map3 = new HashMap();
      map3.put("name1", "value1");
      map3.put("name2", new Integer(4));
      CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);


      HashMap toPut = new HashMap();
      toPut.put(new Object(), compData);
      toPut.put(new Object(), compData2);
      toPut.put(new Object(), compData3);
      data.putAll(toPut);


      String toString = data.toString();


      assertTrue("toString() should contain the tabular type",
         toString.indexOf(tabularType.toString()) != -1);
      assertTrue("toString() should contain index=compositeData for compData",
         toString.indexOf(Arrays.asList(data.calculateIndex(compData)) + "=" + compData) != -1);
      assertTrue("toString() should contain index=compositeData for compData2",
         toString.indexOf(Arrays.asList(data.calculateIndex(compData2)) + "=" + compData2) != -1);
      assertTrue("toString() should contain index=compositeData for compData3",
         toString.indexOf(Arrays.asList(data.calculateIndex(compData3)) + "=" + compData3) != -1);
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      data.putAll((CompositeData[]) null);
      assertTrue("Put all null is ok", data.isEmpty());


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);


      HashMap map2 = new HashMap();
      map2.put("name1", "value1");
      map2.put("name2", new Integer(3));
      CompositeDataSupport compData2 = new CompositeDataSupport(rowType, map2);


      HashMap map3 = new HashMap();
      map3.put("name1", "value1");
      map3.put("name2", new Integer(4));
      CompositeDataSupport compData3 = new CompositeDataSupport(rowType, map3);


      HashMap toPut = new HashMap();
      toPut.put(new Object(), compData);
      toPut.put(new Object(), compData2);
      toPut.put(new Object(), compData3);
      data.putAll(toPut);


      // Serialize it
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(baos);
      oos.writeObject(data);

View Full Code Here

      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      boolean caught = false;
      try
      {
         new TabularDataSupport(null);
      }
      catch (IllegalArgumentException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected IllegalArgumentException for null tabular type");


      caught = false;
      try
      {
         new TabularDataSupport(null, 10, .5f);
      }
      catch (IllegalArgumentException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected IllegalArgumentException for null tabular type");


      caught = false;
      try
      {
         new TabularDataSupport(tabularType, -1, .5f);
      }
      catch (IllegalArgumentException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected IllegalArgumentException for negative initial capacity");


      caught = false;
      try
      {
         new TabularDataSupport(tabularType, 10, 0f);
      }
      catch (IllegalArgumentException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected IllegalArgumentException for zero load factor");


      caught = false;
      try
      {
         new TabularDataSupport(tabularType, 10, -0.5f);
      }
      catch (IllegalArgumentException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected IllegalArgumentException for negative load factor");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.calculateIndex(null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for calculate index on null object");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.calculateIndex(compData2);
      }
      catch (InvalidOpenTypeException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for calculate index on wrong composite type");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.get((Object) null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for get((Object) null)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.get(new Object());
      }
      catch (ClassCastException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected ClassCastException for get(new Object())");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.get((Object) new Object[] { "wrong" });
      }
      catch (InvalidKeyException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidKeyException for get(Object) wrong");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.get((Object[]) null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for get((Object[]) null)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.get(new Object[] { "wrong" });
      }
      catch (InvalidKeyException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidKeyException for get(Object[]) wrong");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(new Object(), null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for put(Object, Object) with null value");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(new Object(), new Object());
      }
      catch (ClassCastException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected ClassCastException for put(Object, Object) with none CompositeData");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(new Object(), compData2);
      }
      catch (InvalidOpenTypeException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for put(Object, Object) with wrong CompositeType");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(new Object(), compData);
         data.put(new Object(), compData);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected KeyAlreadyExistsException for put(Object, Object)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for put(CompositeData) with null value");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(compData2);
      }
      catch (InvalidOpenTypeException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for put(CompositeData) with wrong CompositeType");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.put(compData);
         data.put(compData);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected KeyAlreadyExistsException for put(CompositeData)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.remove((Object) null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for remove((Object) null)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.remove(new Object());
      }
      catch (ClassCastException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected ClassCastException for remove(new Object())");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.remove((Object) new Object[] { "wrong" });
      }
      catch (InvalidKeyException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidKeyException for remove(Object) wrong");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.remove((Object[]) null);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for remove((Object[]) null)");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         data.remove(new Object[] { "wrong" });
      }
      catch (InvalidKeyException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidKeyException for remove(Object[]) wrong");


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), null);
         data.putAll(toPut);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for putAll(Map) null");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), null);
         try
         {
            data.putAll(toPut);
         }
         catch (NullPointerException expected)
         {
         }
         assertTrue("Nothing should be added for NullPointerException putAll(Map)", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), new Object());
         data.putAll(toPut);
      }
      catch (ClassCastException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected ClassCastException for putAll(Map) non composite data");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), new Object());
         try
         {
            data.putAll(toPut);
         }
         catch (ClassCastException expected)
         {
         }
         assertTrue("Nothing should be added for ClassCastException putAll(Map)", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), compData2);
         data.putAll(toPut);
      }
      catch (InvalidOpenTypeException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(Map) wrong composite type");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), compData2);
         try
         {
            data.putAll(toPut);
         }
         catch (InvalidOpenTypeException expected)
         {
         }
         assertTrue("Nothing should be added for InvalidOpenTypeException putAll(Map)", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), compData);
         data.putAll(toPut);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(Map) with duplicate data");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         toPut.put(new Object(), compData);
         try
         {
            data.putAll(toPut);
         }
         catch (KeyAlreadyExistsException expected)
         {
         }
         assertTrue("Nothing should be added for KeyAlreadyExistsException duplicates putAll(Map)", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         data.putAll(toPut);
         toPut = new HashMap();
         toPut.put(new Object(), compData);
         data.putAll(toPut);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(Map) adding a duplicate");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         HashMap toPut = new HashMap();
         toPut.put(new Object(), compData);
         data.putAll(toPut);
         toPut = new HashMap();
         toPut.put(new Object(), compData);
         try
         {
            data.putAll(toPut);
         }
         catch (KeyAlreadyExistsException expected)
         {
         }
         assertTrue("Nothing should be added for KeyAlreadyExistsException already put putAll(Map)", data.size() == 1);
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, null };
         data.putAll(toPut);
      }
      catch (NullPointerException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected NullPointerException for putAll(CompositeData[]) null");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, null };
         try
         {
            data.putAll(toPut);
         }
         catch (NullPointerException expected)
         {
         }
         assertTrue("Nothing should be added for NullPointerException putAll(CompositeData[])", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, compData2 };
         data.putAll(toPut);
      }
      catch (InvalidOpenTypeException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(CompositeData[]) wrong composite type");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, compData2 };
         try
         {
            data.putAll(toPut);
         }
         catch (InvalidOpenTypeException expected)
         {
         }
         assertTrue("Nothing should be added for InvalidOpenTypeException putAll(CompositeData[])", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, compData };
         data.putAll(toPut);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(CompositeData[]) with duplicate data");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData, compData };
         try
         {
            data.putAll(toPut);
         }
         catch (KeyAlreadyExistsException expected)
         {
         }
         assertTrue("Nothing should be added for KeyAlreadyExistsException duplicates putAll(CompositeData[])", data.isEmpty());
      }


      caught = false;
      try
      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData };
         data.putAll(toPut);
         data.putAll(toPut);
      }
      catch (KeyAlreadyExistsException e)
      {
         caught = true;
      }
      if (caught == false)
         fail("Expected InvalidOpenTypeException for putAll(CompositeData[]) adding a duplicate");


      {
         TabularDataSupport data = new TabularDataSupport(tabularType);
         CompositeData[] toPut = new CompositeData[] { compData };
         data.putAll(toPut);
         try
         {
            data.putAll(toPut);
         }
         catch (KeyAlreadyExistsException expected)
         {
         }
         assertTrue("Nothing should be added for KeyAlreadyExistsException already put putAll(CompositeData[])", data.size() == 1);
      }
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);
      TabularDataSupport data2 = new TabularDataSupport(tabularType, 100, .5f);
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);
      assertTrue("Expected the same tabular type", data.getTabularType().equals(tabularType));
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
      Object[] index = data.calculateIndex(compData);


      assertTrue("Expected index element 0 to be value1", index[0].equals("value1"));
      assertTrue("Expected index element 1 to be 2", index[1].equals(new Integer(2)));


      map = new HashMap();
      map.put("name1", "value2");
      map.put("name2", new Integer(3));
      compData = new CompositeDataSupport(rowType, map);
      index = data.calculateIndex(compData);


      assertTrue("Expected index element 0 to be value2", index[0].equals("value2"));
      assertTrue("Expected index element 1 to be 3", index[1].equals(new Integer(3)));
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      assertTrue("Didn't expect containsKey null", data.containsKey(null) == false);
      assertTrue("Didn't expect containsKey not an Object array", data.containsKey(new Object()) == false);


      Object[] index = new Object[] { "value1", new Integer(2) };
      assertTrue("Didn't expect containsKey on empty data", data.containsKey((Object) index) == false);


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsKey on index not present", data.containsKey((Object) index) == false);


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      compData = new CompositeDataSupport(rowType, map);
      data.put(compData);
      assertTrue("Expected containsKey", data.containsKey((Object) index));


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsKey on index still not present", 
         data.containsKey((Object) data.calculateIndex(compData)) == false);


      data.remove(index);
      assertTrue("Didn't expect removed data in containsKey", data.containsKey((Object) index) == false);
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      assertTrue("Didn't expect containsKey null", data.containsKey(null) == false);
      assertTrue("Didn't expect containsKey not an Object array", data.containsKey(new Object()) == false);


      Object[] index = new Object[] { "value1", new Integer(2) };
      assertTrue("Didn't expect containsKey on empty data", data.containsKey(index) == false);


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsKey on index not present", data.containsKey(index) == false);


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      compData = new CompositeDataSupport(rowType, map);
      data.put(compData);
      assertTrue("Expected containsKey", data.containsKey(index));


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsKey on index still not present",
         data.containsKey(data.calculateIndex(compData)) == false);


      data.remove(index);
      assertTrue("Didn't expect removed data in containsKey", data.containsKey(index) == false);
   }

View Full Code Here

         itemNames, itemDescriptions, itemTypes);


      String[] indexNames = new String[] { "name1", "name2" };
      TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);


      TabularDataSupport data = new TabularDataSupport(tabularType);


      assertTrue("Didn't expect containsValue null", data.containsValue(null) == false);


      itemNames = new String[] { "name1", "name2" };
      itemDescriptions = new String[] { "desc1", "desc2" };
      itemTypes = new OpenType[] { SimpleType.STRING, SimpleType.INTEGER };
      CompositeType rowType2 = new CompositeType("rowTypeName2", "rowDescription",
         itemNames, itemDescriptions, itemTypes);


      HashMap map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      CompositeDataSupport compData2 = new CompositeDataSupport(rowType2, map);


      assertTrue("Didn't expect containsValue wrong composite type", data.containsValue((Object) compData2) == false);


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      CompositeDataSupport compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsValue on data not present", data.containsValue((Object) compData) == false);


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(2));
      compData = new CompositeDataSupport(rowType, map);
      data.put(compData);
      assertTrue("Expected containsValue", data.containsValue((Object) compData));


      map = new HashMap();
      map.put("name1", "value1");
      map.put("name2", new Integer(3));
      compData = new CompositeDataSupport(rowType, map);
      assertTrue("Didn't expect containsValue on value still not present", data.containsValue((Object) compData) == false);


      assertTrue("Didn't expect containsValue still wrong composite type", data.containsValue((Object) compData2) == false);


      data.remove(data.calculateIndex(compData));
      assertTrue("Didn't expect removed data in containsValue", data.containsValue((Object) compData) == false);
   }

View Full Code Here

         CompositeType rowType = new CompositeType("rowTypeName", "rowDescription",
            itemNames, itemDescriptions, itemTypes);


         String[] indexNames = new String[] { "name1", "name2" };
         TabularType tabularType = new TabularType("typeName", "description", rowType, indexNames);
         TabularDataSupport data = new TabularDataSupport(tabularType);


         OpenMBeanParameterInfoSupport info = new OpenMBeanParameterInfoSupport(
            "name", "description", tabularType, data);
      }
      catch (OpenDataException e)

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.management.openmbean.TabularDataSupport

com.alibaba.druid.stat.DruidDataSourceStatManager

com.alibaba.druid.stat.JdbcDataSourceStat

com.alibaba.druid.stat.JdbcStatManager

com.googlecode.jmxtrans.jmx.JmxResultProcessor

com.opengamma.engine.management.ViewProcessStatsProcessor

io.fabric8.jolokia.client.OpenTypeGenerator

io.hawt.jmx.JMXSecurity

org.apache.activemq.broker.jmx.AbortSlowConsumerStrategyView

org.apache.activemq.broker.jmx.DestinationView

org.apache.activemq.broker.jmx.HealthView

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.