java类javax.management.openmbean.CompositeType的实例源码

public CompositeType generateCompositeType()
{
    try
    {
        int nNbItems = m_arrItemDesc.size();
        OpenType [] openTypes = new OpenType [nNbItems];
        String [] itemTypeNames = new String [nNbItems];
        String [] itemTypeDescriptions = new String [nNbItems];
        for(int n=0; n<nNbItems; n++)
        {
            CompositeTypeDescItem itemDesc = m_arrItemDesc.get(n);
            openTypes[n] = itemDesc.m_openType;
            itemTypeNames[n] = itemDesc.m_csName;
            itemTypeDescriptions[n] = itemDesc.m_csDescription;         
        }

        CompositeType compositeType = new CompositeType(
            m_csName,
            m_csDescription,
            itemTypeNames,
            itemTypeDescriptions,
            openTypes);
        return compositeType;
    }
    catch (OpenDataException e)
    {
        e.printStackTrace();
    }
    return null;
}

private void writeObject(JsonGenerator jg, Object value) throws IOException {
  if(value == null) {
    jg.writeNull();
  } else {
    Class<?> c = value.getClass();
    if (c.isArray()) {
      jg.writeStartArray();
      int len = Array.getLength(value);
      for (int j = 0; j < len; j++) {
        Object item = Array.get(value, j);
        writeObject(jg, item);
      }
      jg.writeEndArray();
    } else if(value instanceof Number) {
      Number n = (Number)value;
      jg.writeNumber(n.toString());
    } else if(value instanceof Boolean) {
      Boolean b = (Boolean)value;
      jg.writeBoolean(b);
    } else if(value instanceof CompositeData) {
      CompositeData cds = (CompositeData)value;
      CompositeType comp = cds.getCompositeType();
      Set<String> keys = comp.keySet();
      jg.writeStartObject();
      for(String key: keys) {
        writeAttribute(jg, key, cds.get(key));
      }
      jg.writeEndObject();
    } else if(value instanceof TabularData) {
      TabularData tds = (TabularData)value;
      jg.writeStartArray();
      for(Object entry : tds.values()) {
        writeObject(jg, entry);
      }
      jg.writeEndArray();
    } else {
      jg.writeString(value.toString());
    }
  }
}

static TabularType make(String typeName, String description,
                        CompositeType rowType, String[] indexNames) {
    try {
        return new TabularType(typeName, description, rowType,
                               indexNames);
    } catch (OpenDataException e) {
        throw new Error(e);
    }
}

static CompositeType make(String className,
                          String description,
                          String[] itemNames,
                          String[] itemDescriptions,
                          OpenType[] itemTypes) {
    try {
        return new CompositeType(className,
                                 description,
                                 itemNames,
                                 itemDescriptions,
                                 itemTypes);
    } catch (OpenDataException e) {
        throw new Error(e);
    }
}

public CompositeData toCompositeData(CompositeType ct) {
    try {
        return new CompositeDataSupport(ct, new String[] {"whatsit"},
                                        new String[] {"!" + whatsit});
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public CompositeData getCompositeDataAttribute()
    throws OpenDataException {
    CompositeType ct = new CompositeType("CompositeDataAttribute",
                                         "Composite Data Attribute",
                                         itemNames,
                                         itemDescriptions,
                                         itemTypes);
    Object itemValues[] = { ia, da, sa };
    return new CompositeDataSupport(ct, itemNames, itemValues);
}

private void fillMappingForComposite(final CompositeType openType,
        final Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerMap,
        final Map<String, String> yangToJmxMapping) {
    for (String innerAttributeKey : openType.keySet()) {
        innerMap.put(innerAttributeKey, caseJavaAttribute(openType.getType(innerAttributeKey)));
        yangToJmxMapping.put(innerAttributeKey, innerAttributeKey);
    }
}

public final T caseJavaAttribute(final OpenType<?> openType) {
    if (openType instanceof SimpleType<?>) {
        return caseJavaSimpleAttribute((SimpleType<?>) openType);
    } else if (openType instanceof ArrayType<?>) {
        return caseJavaArrayAttribute((ArrayType<?>) openType);
    } else if (openType instanceof CompositeType) {
        return caseJavaCompositeAttribute((CompositeType) openType);
    }

    throw new UnknownOpenTypeException("Unknown attribute open type " + openType);
}

private OpenType<?> getVersionedType(OpenType<?> type, String version)
    throws OpenDataException
{
    if (type instanceof ArrayType) {
        return getVersionedArrayType((ArrayType)type, version);
    }
    if (type instanceof CompositeType) {
        return getVersionedCompositeType((CompositeType)type, version);
    }
    if (type instanceof TabularType) {
        return getVersionedTabularType((TabularType)type, version);
    }
    return type;
}

@Override
protected AttributeResolvingStrategy<?, ? extends OpenType<?>> caseTOAttribute(final CompositeType openType) {
    Preconditions.checkState(getLastAttribute() instanceof TOAttribute);
    TOAttribute toAttribute = (TOAttribute) getLastAttribute();

    Map<String, AttributeResolvingStrategy<?, ? extends OpenType<?>>> innerMap = Maps.newHashMap();

    for (String innerName : openType.keySet()) {

        AttributeIfc innerAttributeIfc = toAttribute.getJmxPropertiesToTypesMap().get(innerName);
        innerMap.put(innerAttributeIfc.getAttributeYangName(), prepareStrategy(innerAttributeIfc));
    }
    return new CompositeAttributeResolvingStrategy(innerMap, openType, createYangToJmxMapping(toAttribute));
}