| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.apache.aries.jmx.blueprint; |
| |
| import java.util.Arrays; |
| import java.util.LinkedHashSet; |
| import java.util.Set; |
| |
| import javax.management.openmbean.ArrayType; |
| import javax.management.openmbean.CompositeType; |
| import javax.management.openmbean.OpenDataException; |
| import javax.management.openmbean.OpenType; |
| import javax.management.openmbean.TabularType; |
| |
| /** |
| * The item class enables the definition of open types in the appropriate interfaces. |
| * |
| * This class contains a number of methods that make it possible to create open types for {@link CompositeType}, |
| * {@link TabularType}, and {@link ArrayType}. The normal creation throws a checked exception, making it impossible to |
| * use them in a static initializer. They constructors are also not very suitable for static construction. |
| * |
| * |
| * An Item instance describes an item in a Composite Type. It groups the triplet of name, description, and Open Type. |
| * These Item instances allows the definitions of an item to stay together. |
| * |
| * Immutable |
| */ |
| public class Item { |
| |
| /** |
| * The name of this item. |
| */ |
| private final String name; |
| |
| /** |
| * The description of this item. |
| */ |
| private final String description; |
| |
| /** |
| * The type of this item. |
| */ |
| private final OpenType/*<?>*/ type; |
| |
| /** |
| * Create a triple of name, description, and type. This triplet is used in the creation of a Composite Type. |
| * |
| * @param name |
| * The name of the item. |
| * @param description |
| * The description of the item. |
| * @param type |
| * The Open Type of this item. |
| * @param restrictions |
| * Ignored, contains list of restrictions |
| */ |
| public Item(String name, String description, OpenType/*<?>*/ type, String... restrictions) { |
| this.name = name; |
| this.description = description; |
| this.type = type; |
| } |
| |
| /** |
| * Create a Tabular Type. |
| * |
| * @param name |
| * The name of the Tabular Type. |
| * @param description |
| * The description of the Tabular Type. |
| * @param rowType |
| * The Open Type for a row |
| * @param index |
| * The names of the items that form the index . |
| * @return A new Tabular Type composed from the parameters. |
| * @throws RuntimeException |
| * when the Tabular Type throws an OpenDataException |
| */ |
| static public TabularType tabularType(String name, String description, CompositeType rowType, String... index) { |
| try { |
| return new TabularType(name, description, rowType, index); |
| } catch (OpenDataException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /** |
| * Create a Composite Type |
| * |
| * @param name |
| * The name of the Tabular Type. |
| * @param description |
| * The description of the Tabular Type. |
| * @param items |
| * The items that describe the composite type. |
| * @return a new Composite Type |
| * @throws RuntimeException |
| * when the Tabular Type throws an OpenDataException |
| */ |
| static public CompositeType compositeType(String name, String description, Item... items) { |
| return extend(null, name, description, items); |
| } |
| |
| /** |
| * Extend a Composite Type by adding new items. Items can override items in the parent type. |
| * |
| * @param parent |
| * The parent type, can be <code>null</code> |
| * @param name |
| * The name of the type |
| * @param description |
| * The description of the type |
| * @param items |
| * The items that should be added/override to the parent type |
| * @return A new Composite Type that extends the parent type |
| * @throws RuntimeException |
| * when an OpenDataException is thrown |
| */ |
| public static CompositeType extend(CompositeType parent, String name, String description, Item... items) { |
| Set<Item> all = new LinkedHashSet<Item>(); |
| |
| if (parent != null) { |
| for (Object nm : parent.keySet()) { |
| String key = (String) nm; |
| all.add(new Item((String) nm, parent.getDescription(key), parent.getType(key))); |
| } |
| } |
| |
| all.addAll(Arrays.asList(items)); |
| |
| String names[] = new String[all.size()]; |
| String descriptions[] = new String[all.size()]; |
| OpenType types[] = new OpenType[all.size()]; |
| |
| int n = 0; |
| for (Item item : all) { |
| names[n] = item.name; |
| descriptions[n] = item.description; |
| types[n] = item.type; |
| n++; |
| } |
| |
| try { |
| return new CompositeType(name, description, names, descriptions, types); |
| } catch (OpenDataException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /** |
| * Return a new Array Type. |
| * |
| * @param dim |
| * The dimension |
| * @param elementType |
| * The element type |
| * @return A new Array Type |
| */ |
| public static <T> ArrayType<T> arrayType(int dim, OpenType<T> elementType) { |
| try { |
| return new ArrayType<T>(dim, elementType); |
| } catch (OpenDataException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| |
| /** |
| * Return a new primaArray Type. |
| * |
| * @param elementType |
| * The element type |
| * @return A new Array Type |
| */ |
| /* |
| * For the compatibility with java 5, we have to cancel this method temporarily. |
| * |
| * public static ArrayType<?> primitiveArrayType(SimpleType<?> elementType) { |
| try { |
| return new ArrayType(elementType, true); |
| } catch (OpenDataException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| */ |
| } |