private String[] formatRow(CompositeData row, List<String> header) { String[] text = new String[header.size()]; for(int i = 0; i != text.length; ++i) { String attr = header.get(i); text[i] = formatLine(row.get(attr), row.getCompositeType().getType(attr).getClassName()); } return text; }
new String[]{"startTime", "lastRefresh", "interval", "data"}, new Object[]{ convertToOpenTypeValue(ct.getType("startTime"), ((Profiler) p).START_TIME), convertToOpenTypeValue(ct.getType("lastRefresh"), -1L), convertToOpenTypeValue(ct.getType("interval"), 0L), new CompositeData[0] }); CompositeType at = (CompositeType)((ArrayType)ct.getType("data")).getElementOpenType(); CompositeType rt = (CompositeType)at.getType("value"); CompositeData recordData = new CompositeDataSupport(rt, new String[]{"block", new String[]{"startTime", "lastRefresh", "interval", "data"}, new Object[]{ convertToOpenTypeValue(ct.getType("startTime"), ((Profiler)p).START_TIME), convertToOpenTypeValue(ct.getType("lastRefresh"), snapshot.timeStamp), convertToOpenTypeValue(ct.getType("interval"), snapshot.timeInterval), total }); Map<Object, Object> map = new HashMap((Map<Object, Object>) value); CompositeData[] array = new CompositeData[map.size()]; OpenType keyType = ct.getType("key"); OpenType valueType = ct.getType("value"); int index = 0; for (Map.Entry<Object, Object> entry : map.entrySet()) {
for(String attr: cdata.getCompositeType().keySet()) { sb.append(attr).append("="); sb.append(formatLine(cdata.get(attr), cdata.getCompositeType().getType(attr).getClassName())); sb.append(',');
BitSet present = new BitSet(); for (int i = 0; i < itemNames.length; i++) { if (ct.getType(itemNames[i]) != null) present.set(i);
List<String[]> content = new ArrayList<String[]>(); for(String field: cd.getCompositeType().keySet()) { String val = formatLine(cd.get(field), cd.getCompositeType().getType(field).getClassName()); content.add(new String[]{field + ": ", val});
private Object getKey(CompositeType rowType, String key, String value) { OpenType keyType = rowType.getType(key); if (SimpleType.STRING == keyType) { return value; } else if (SimpleType.INTEGER == keyType) { return Integer.parseInt(value); } else if (SimpleType.LONG == keyType) { return Long.parseLong(value); } else if (SimpleType.SHORT == keyType) { return Short.parseShort(value); } else if (SimpleType.BYTE == keyType) { return Byte.parseByte(value); } else if (SimpleType.OBJECTNAME == keyType) { try { return new ObjectName(value); } catch (MalformedObjectNameException e) { throw new IllegalArgumentException("Can not convert " + value + " to an ObjectName",e); } } else { throw new IllegalArgumentException("All keys must be a string, integer, long, short, byte or ObjectName type for accessing TabularData via a path. " + "This is not the case for '" + key + "' which is of type " + keyType); } }
private boolean checkForMapKey(TabularType pType) { List<String> indexNames = pType.getIndexNames(); return // Single index named "key" indexNames.size() == 1 && indexNames.contains(TD_KEY_KEY) && // Only convert to map for simple types for all others use normal conversion. See #105 for details. pType.getRowType().getType(TD_KEY_KEY) instanceof SimpleType; }
private void completeCompositeValuesWithDefaults(CompositeType pType, Map<String, Object> pCompositeValues) { /* fields that were not given in the JSON must be added with * null for Objects and the default value for primitives */ for (String itemName : pType.keySet()) { if (!pCompositeValues.containsKey(itemName)) { Object itemValue = null; OpenType itemType = pType.getType(itemName); if (itemType instanceof SimpleType) { SimpleType sType = (SimpleType) itemType; itemValue = DEFAULT_PRIMITIVE_VALUES.get(sType.getClassName()); } pCompositeValues.put(itemName, itemValue); } } }
private void fillCompositeWithGivenValues(CompositeType pType, Map<String, Object> pCompositeValues, Map<String, Object> pSourceJson) { for (Map.Entry<String,Object> entry : pSourceJson.entrySet()) { String key = entry.getKey(); Object value = entry.getValue(); if (!pType.containsKey(key)) { throw new IllegalArgumentException( "Conversion to CompositeType failed because " + key + " is not known as composite attribute key."); } if (value != null) { Object convertedValue = getDispatcher().convertToObject(pType.getType(key),value); pCompositeValues.put(key, convertedValue); } } }
private boolean hasComplexKeys(TabularType pType) { List<String> indexes = pType.getIndexNames(); CompositeType rowType = pType.getRowType(); for (String index : indexes) { if ( ! (rowType.getType(index) instanceof SimpleType)) { return true; } } return false; }
List<String> attributeNames = Lists.newArrayList(); for (String itemName : compositeType.keySet()) { OpenType<?> itemType = compositeType.getType(itemName); if (itemType == null) { continue;
private TabularData convertToTabularTypeFromMap(TabularType pType, JSONObject pValue) { CompositeType rowType = pType.getRowType(); // A TabularData is requested for mapping a map for the call to an MXBean // as described in http://download.oracle.com/javase/6/docs/api/javax/management/MXBean.html // This means, we will convert a JSONObject to the required format TabularDataSupport tabularData = new TabularDataSupport(pType); @SuppressWarnings("unchecked") Map<String, String> jsonObj = (Map<String,String>) pValue; for(Map.Entry<String, String> entry : jsonObj.entrySet()) { Map<String, Object> map = new HashMap<String, Object>(); map.put("key", getDispatcher().convertToObject(rowType.getType("key"), entry.getKey())); map.put("value", getDispatcher().convertToObject(rowType.getType("value"), entry.getValue())); try { CompositeData compositeData = new CompositeDataSupport(rowType, map); tabularData.put(compositeData); } catch (OpenDataException e) { throw new IllegalArgumentException(e.getMessage(),e); } } return tabularData; }
/** * Check whether the given tabular type represents a MXBean map. See the * {@link javax.management.MXBean} specification for * details how a map is converted to {@link TabularData} by the MXBean framework. * * @param pType type of tabular data to convert * @return true if this type represents an MXBean map, false otherwise. */ private boolean checkForMxBeanMap(TabularType pType) { CompositeType rowType = pType.getRowType(); return rowType.containsKey("key") && rowType.containsKey("value") && rowType.keySet().size() == 2 // Only convert to map for simple types for all others use normal conversion. See #105 for details. && rowType.getType("key") instanceof SimpleType; }
if (NUMERIC_TYPES.contains(compositeType.getType(key))) { Optional<String> name = statsNameBuilder.name( beanName, attributeInfo.getName(), key
@Nullable protected AttributeDefinition findDefinitionFor(@Nonnull ObjectName objectName, @Nonnull MBeanAttributeInfo info, @Nonnull String name, @Nonnull CompositeType compositeType) { final Set<AttributeDefinition> children = new HashSet<>(); for (String key : compositeType.keySet()) { final OpenType<?> childType = compositeType.getType(key); final AttributeDefinition child = findDefinitionFor(objectName, info, key, childType); if (child != null) { children.add(child); } } return children.isEmpty() ? null : new AttributeDefinition(objectName, name, CompositeData.class, children); }
private boolean checkForMapKey(TabularType pType) { List<String> indexNames = pType.getIndexNames(); return // Single index named "key" indexNames.size() == 1 && indexNames.contains(TD_KEY_KEY) && // Only convert to map for simple types for all others use normal conversion. See #105 for details. pType.getRowType().getType(TD_KEY_KEY) instanceof SimpleType; }
private boolean checkForMapKey(TabularType pType) { List<String> indexNames = pType.getIndexNames(); return // Single index named "key" indexNames.size() == 1 && indexNames.contains(TD_KEY_KEY) && // Only convert to map for simple types for all others use normal conversion. See #105 for details. pType.getRowType().getType(TD_KEY_KEY) instanceof SimpleType; }
private boolean hasComplexKeys(TabularType pType) { List<String> indexes = pType.getIndexNames(); CompositeType rowType = pType.getRowType(); for (String index : indexes) { if ( ! (rowType.getType(index) instanceof SimpleType)) { return true; } } return false; }
private boolean hasComplexKeys(TabularType pType) { List<String> indexes = pType.getIndexNames(); CompositeType rowType = pType.getRowType(); for (String index : indexes) { if ( ! (rowType.getType(index) instanceof SimpleType)) { return true; } } return false; }