/*
 * Copyright (c) OSGi Alliance (2010, 2012). All Rights Reserved.
 *
 * Licensed 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.osgi.jmx.framework.wiring;

import java.io.IOException;

import javax.management.JMException;
import javax.management.openmbean.ArrayType;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.CompositeType;
import javax.management.openmbean.SimpleType;
import javax.management.openmbean.TabularData;
import javax.management.openmbean.TabularType;

import org.osgi.jmx.Item;
import org.osgi.jmx.JmxConstants;

/**
 * This MBean represents the bundle wiring state.
 * <p>
 * It can be used to retrieve the declared capabilities, declared requirements,
 * and wiring for the current and past revisions of bundles.
 *
 * @ThreadSafe
 */
public interface BundleWiringStateMBean {
	/**
	 * The Object Name prefix for this mbean. The full object name also contains
	 * the framework name and uuid as properties.
	 */
	String			OBJECTNAME							= JmxConstants.OSGI_CORE + ":type=wiringState,version=1.1";

	/**
	 * The key of {@link #KEY_ITEM}.
	 */
	String			KEY									= "Key";

	/**
	 * The item containing the key of a capability or requirement directive.
	 * Used in {@link #DIRECTIVE_TYPE}. The key is {@link #KEY} and the type is
	 * a String.
	 */
	Item			KEY_ITEM							= new Item(KEY, "The directive key", SimpleType.STRING);

	/**
	 * The key of {@link #VALUE}.
	 */
	String			VALUE								= "Value";

	/**
	 * The item containing the value of a capability or requirement directive.
	 * Used in {@link #DIRECTIVE_TYPE}. They key is {@link #VALUE} and the type
	 * is a String.
	 */
	Item			VALUE_ITEM							= new Item(VALUE, "The directive value", SimpleType.STRING);

	/**
	 * The Composite Type that represents a directive for a capability or
	 * requirement. The composite consists of:
	 * <ul>
	 * <li>{@link #KEY}</li>
	 * <li>{@link #VALUE}</li>
	 * </ul>
	 */
	CompositeType	DIRECTIVE_TYPE						= Item.compositeType("DIRECTIVE", "Describes a directive of a capability or requirement", KEY_ITEM, VALUE_ITEM);

	/**
	 * The Tabular Type that holds the directives for a capability or
	 * requirement. The row type is {@link #DIRECTIVE_TYPE} and the index is
	 * {@link #KEY}.
	 */
	TabularType		DIRECTIVES_TYPE						= Item.tabularType("DIRECTIVES", "Describes the directives of a capability or requirement", DIRECTIVE_TYPE, KEY);

	/**
	 * The key of {@link #DIRECTIVES_ITEM}.
	 */
	String			DIRECTIVES							= "Directives";

	/**
	 * The item containing the directives of a capability or requirement. Used
	 * in {@link #BUNDLE_REQUIREMENT_TYPE} and {@link #BUNDLE_CAPABILITY_TYPE}.
	 * The key is {@link #DIRECTIVES} and the type is {@link #DIRECTIVES_TYPE}.
	 */
	Item			DIRECTIVES_ITEM						= new Item(DIRECTIVES, "The directives of a capability or requirement", DIRECTIVES_TYPE);

	/**
	 * The Tabular Type that holds the attributes for a capability or
	 * requirements. The row type is {@link JmxConstants#PROPERTY_TYPE} and the
	 * index is {@link JmxConstants#KEY}.
	 */
	TabularType		ATTRIBUTES_TYPE						= Item.tabularType("ATTRIBUTES", "Describes attributes of a capability or requirement", JmxConstants.PROPERTY_TYPE, JmxConstants.KEY);

	/**
	 * The key of {@link #ATTRIBUTES_ITEM}.
	 */
	String			ATTRIBUTES							= "Attributes";

	/**
	 * The item containing the attributes of a capability or requirement. Used
	 * in {@link #BUNDLE_REQUIREMENT_TYPE} and {@link #BUNDLE_CAPABILITY_TYPE}.
	 * The key is {@link #ATTRIBUTES} and the type is {@link #ATTRIBUTES_TYPE}.
	 */
	Item			ATTRIBUTES_ITEM						= new Item(ATTRIBUTES, "The attributes of a capability or requirement", ATTRIBUTES_TYPE);

	/**
	 * The key of {@link #NAMESPACE_ITEM}.
	 */
	String			NAMESPACE							= "Namespace";

	/**
	 * The item containing the namespace for a capability or requirement. Used
	 * in {@link #BUNDLE_REQUIREMENT_TYPE} and {@link #BUNDLE_CAPABILITY_TYPE}.
	 * The key is {@link #NAMESPACE} and the type is a String.
	 */
	Item			NAMESPACE_ITEM						= new Item(NAMESPACE, "The namespace of a capability or requirement", SimpleType.STRING);

	/**
	 * The Composite Type that represents the requirement of a bundle.
	 *
	 * The composite consists of:
	 * <ul>
	 * <li>{@link #NAMESPACE}</li>
	 * <li>{@link #ATTRIBUTES}</li>
	 * <li>{@link #DIRECTIVES}</li>
	 * </ul>
	 */
	CompositeType	BUNDLE_REQUIREMENT_TYPE				= Item.compositeType("BUNDLE_REQUIREMENT", "Describes the requirement of a bundle", ATTRIBUTES_ITEM, DIRECTIVES_ITEM, NAMESPACE_ITEM);

	/**
	 * The Composite Type that represents the capability of a bundle.
	 *
	 * The composite consists of:
	 * <ul>
	 * <li>{@link #NAMESPACE}</li>
	 * <li>{@link #ATTRIBUTES}</li>
	 * <li>{@link #DIRECTIVES}</li>
	 * </ul>
	 */
	CompositeType	BUNDLE_CAPABILITY_TYPE				= Item.compositeType("BUNDLE_CAPABILITY", "Describes the capability of a bundle", ATTRIBUTES_ITEM, DIRECTIVES_ITEM, NAMESPACE_ITEM);

	/**
	 * The key of {@link #PROVIDER_BUNDLE_ID_ITEM}.
	 */
	String			PROVIDER_BUNDLE_ID					= "ProviderBundleId";

	/**
	 * The item containing the provider bundle ID in {@link #BUNDLE_WIRE_TYPE}.
	 * The key is {@link #PROVIDER_BUNDLE_ID} and the type is a long.
	 */
	Item			PROVIDER_BUNDLE_ID_ITEM				= new Item(PROVIDER_BUNDLE_ID, "The identifier of the bundle that is the provider of the capability", SimpleType.LONG);

	/**
	 * The key of {@link #REQUIRER_BUNDLE_ID_ITEM}.
	 */
	String			REQUIRER_BUNDLE_ID					= "RequirerBundleId";

	/**
	 * The item containing the requirer bundle ID in {@link #BUNDLE_WIRE_TYPE}.
	 * The key is {@link #REQUIRER_BUNDLE_ID} and the type is long.
	 */
	Item			REQUIRER_BUNDLE_ID_ITEM				= new Item(REQUIRER_BUNDLE_ID, "The identifier of the bundle that is the requirer of the requirement", SimpleType.LONG);

	/**
	 * The key of {@link #BUNDLE_REQUIREMENT_ITEM}.
	 */
	String			BUNDLE_REQUIREMENT					= "BundleRequirement";

	/**
	 * The item containing a requirement for a bundle in
	 * {@link #BUNDLE_WIRE_TYPE}. The key is {@link #BUNDLE_REQUIREMENT} and the
	 * type is {@link #BUNDLE_REQUIREMENT_TYPE}.
	 */
	Item			BUNDLE_REQUIREMENT_ITEM				= new Item(BUNDLE_REQUIREMENT, "The wired requirements of a bundle", BUNDLE_REQUIREMENT_TYPE);

	/**
	 * The key of {@link #BUNDLE_CAPABILITY_ITEM}.
	 */
	String			BUNDLE_CAPABILITY					= "BundleCapability";

	/**
	 * The item containing a capability for a bundle in
	 * {@link #BUNDLE_WIRE_TYPE}. The key is {@link #BUNDLE_CAPABILITY} and the
	 * type is {@link #BUNDLE_CAPABILITY_TYPE}.
	 */
	Item			BUNDLE_CAPABILITY_ITEM				= new Item(BUNDLE_CAPABILITY, "The wired capabilities of a bundle", BUNDLE_CAPABILITY_TYPE);

	/**
	 * The key of {@link #PROVIDER_BUNDLE_REVISION_ID_ITEM}.
	 */
	String			PROVIDER_BUNDLE_REVISION_ID			= "ProviderBundleRevisionId";

	/**
	 * The local ID of a provider revision in {@link #BUNDLE_WIRE_TYPE}. This ID
	 * is local to the result where it resides and has no defined meaning across
	 * multiple invocations. The key is {@link #PROVIDER_BUNDLE_REVISION_ID} and
	 * the type is an int.
	 */
	Item			PROVIDER_BUNDLE_REVISION_ID_ITEM	= new Item(PROVIDER_BUNDLE_REVISION_ID, "A local id for the bundle revision that is the provider of the capability", SimpleType.INTEGER);

	/**
	 * The key of {@link #REQUIRER_BUNDLE_REVISION_ID_ITEM}.
	 */
	String			REQUIRER_BUNDLE_REVISION_ID			= "RequirerBundleRevisionId";

	/**
	 * The local ID of a requirer revision in {@link #BUNDLE_WIRE_TYPE}. This ID
	 * is local to the result where it resides and has no defined meaning across
	 * multiple invocations. The key is {@link #REQUIRER_BUNDLE_REVISION_ID} and
	 * the type is an int.
	 */
	Item			REQUIRER_BUNDLE_REVISION_ID_ITEM	= new Item(REQUIRER_BUNDLE_REVISION_ID, "A local id for the bundle revision that is the requirer of the requirement", SimpleType.INTEGER);

	/**
	 * The Composite type that represents a bundle wire describing the live
	 * association between a provider of a capability and a requirer of the
	 * corresponding requirement.
	 * <p/>
	 * The composite consists of:
	 * <ul>
	 * <li>{@link #BUNDLE_REQUIREMENT}</li>
	 * <li>{@link #BUNDLE_CAPABILITY}</li>
	 * <li>{@link #PROVIDER_BUNDLE_ID}</li>
	 * <li>{@link #PROVIDER_BUNDLE_REVISION_ID}</li>
	 * <li>{@link #REQUIRER_BUNDLE_ID}</li>
	 * <li>{@link #REQUIRER_BUNDLE_REVISION_ID}</li>
	 * </ul>
	 */
	CompositeType	BUNDLE_WIRE_TYPE					= Item.compositeType("BUNDLE_WIRE",
																"Describes the live association between a provider and a requirer",
																BUNDLE_REQUIREMENT_ITEM,
																BUNDLE_CAPABILITY_ITEM,
																PROVIDER_BUNDLE_ID_ITEM,
																PROVIDER_BUNDLE_REVISION_ID_ITEM,
																REQUIRER_BUNDLE_ID_ITEM,
																REQUIRER_BUNDLE_REVISION_ID_ITEM);

	/**
	 * An array of {@link #BUNDLE_WIRE_TYPE}s.
	 */
	ArrayType		BUNDLE_WIRES_TYPE_ARRAY				= Item.arrayType(1, BUNDLE_WIRE_TYPE);

	/**
	 * The key of {@link #BUNDLE_REVISION_ID_ITEM}.
	 */
	String			BUNDLE_REVISION_ID					= "BundleRevisionId";

	/**
	 * The item containing a bundle revision ID. A bundle revision ID is always
	 * local to the result of a JMX invocation and do not have a defined meaning
	 * across invocation calls. They are used where a result can potentially
	 * contain multiple revisions of the same bundle. The key is
	 * {@link #BUNDLE_REVISION_ID} and the type is an integer.
	 */
	Item			BUNDLE_REVISION_ID_ITEM				= new Item(BUNDLE_REVISION_ID, "The local identifier of the bundle revision", SimpleType.INTEGER);

	/**
	 * The key of {@link #BUNDLE_ID_ITEM}.
	 */
	String			BUNDLE_ID							= "BundleId";

	/**
	 * The item containing a bundle ID. They key is {@link #BUNDLE_ID} and the
	 * type is a long.
	 */
	Item			BUNDLE_ID_ITEM						= new Item(BUNDLE_ID, "The bundle identifier of the bundle revision", SimpleType.LONG);

	/**
	 * An array of {@link #BUNDLE_REQUIREMENT_TYPE}s.
	 */
	ArrayType		REQUIREMENT_TYPE_ARRAY				= Item.arrayType(1, BUNDLE_REQUIREMENT_TYPE);

	/**
	 * An array of {@link #BUNDLE_CAPABILITY_TYPE}s.
	 */
	ArrayType		CAPABILITY_TYPE_ARRAY				= Item.arrayType(1, BUNDLE_CAPABILITY_TYPE);

	/**
	 * The key of {@link #REQUIREMENTS_ITEM}.
	 */
	String			REQUIREMENTS						= "Requirements";

	/**
	 * The item containing the requirements in
	 * {@link #REVISION_REQUIREMENTS_TYPE} and {@link #BUNDLE_WIRING_TYPE}. The
	 * key is {@link #REQUIREMENTS} and the type is
	 * {@link #REQUIREMENT_TYPE_ARRAY}.
	 */
	Item			REQUIREMENTS_ITEM					= new Item(REQUIREMENTS, "The bundle requirements of a bundle revision wiring", REQUIREMENT_TYPE_ARRAY);

	/**
	 * The Composite Type that represents the requirements of a revision. The
	 * composite consists of:
	 * <ul>
	 * <li>{@link #BUNDLE_REVISION_ID}</li>
	 * <li>{@link #REQUIREMENTS}</li>
	 * </ul>
	 */
	CompositeType	REVISION_REQUIREMENTS_TYPE			= Item.compositeType("REVISION_REQUIREMENTS", "Describes the requirements for a bundle revision", BUNDLE_REVISION_ID_ITEM, REQUIREMENTS_ITEM);

	/**
	 * The Tabular Type that hold the requirements of a revision. The row type
	 * is {@link #REVISION_REQUIREMENTS_TYPE} and the index is
	 * {@link #BUNDLE_REVISION_ID}.
	 */
	TabularType		REVISIONS_REQUIREMENTS_TYPE			= Item.tabularType("REVISIONS_REQUIREMENTS", "The bundle requirements for all bundle revisions", REVISION_REQUIREMENTS_TYPE, BUNDLE_REVISION_ID);

	/**
	 * The key of {@link #CAPABILITIES_ITEM}.
	 */
	String			CAPABILITIES						= "Capabilities";

	/**
	 * The item containing the capabilities in
	 * {@link #REVISION_CAPABILITIES_TYPE} and {@link #BUNDLE_WIRING_TYPE}. The
	 * key is {@link #CAPABILITIES} and the type is
	 * {@link #CAPABILITY_TYPE_ARRAY}.
	 */
	Item			CAPABILITIES_ITEM					= new Item(CAPABILITIES, "The bundle capabilities of a bundle revision wiring", CAPABILITY_TYPE_ARRAY);

	/**
	 * The Composite Type that represents the capabilities for a revision. The
	 * composite consists of:
	 * <ul>
	 * <li>{@link #BUNDLE_REVISION_ID}</li>
	 * <li>{@link #CAPABILITIES}</li>
	 * </ul>
	 */
	CompositeType	REVISION_CAPABILITIES_TYPE			= Item.compositeType("REVISION_CAPABILITIES", "Describes the capabilities for a bundle revision", BUNDLE_REVISION_ID_ITEM, CAPABILITIES_ITEM);

	/**
	 * The Tabular Type that holds the capabilities of a revision. The row type
	 * is {@link #REVISION_CAPABILITIES_TYPE} and the index is
	 * {@link #BUNDLE_REVISION_ID}.
	 */
	TabularType		REVISIONS_CAPABILITIES_TYPE			= Item.tabularType("REVISIONS_CAPABILITIES", "The bundle capabilities for all bundle revisions", REVISION_CAPABILITIES_TYPE, BUNDLE_REVISION_ID);

	/**
	 * The key of {@link #PROVIDED_WIRES_ITEM}.
	 */
	String			PROVIDED_WIRES						= "ProvidedWires";

	/**
	 * The item containing the provided wires in {@link #BUNDLE_WIRING_TYPE}.
	 * The key is {@link #PROVIDED_WIRES} and the type is
	 * {@link #BUNDLE_WIRES_TYPE_ARRAY}.
	 */
	Item			PROVIDED_WIRES_ITEM					= new Item(PROVIDED_WIRES, "The bundle wires to the capabilities provided by this bundle wiring.", BUNDLE_WIRES_TYPE_ARRAY);

	/**
	 * The key of {@link #REQUIRED_WIRES_ITEM}.
	 */
	String			REQUIRED_WIRES						= "RequiredWires";

	/**
	 * The item containing the required wires in {@link #BUNDLE_WIRING_TYPE}.
	 * The key is {@link #REQUIRED_WIRES} and the type is
	 * {@link #BUNDLE_WIRES_TYPE_ARRAY}.
	 */
	Item			REQUIRED_WIRES_ITEM					= new Item(REQUIRED_WIRES, "The bundle wires to requirements in use by this bundle wiring", BUNDLE_WIRES_TYPE_ARRAY);

	/**
	 * The Composite Type that represents a bundle wiring. The composite
	 * consists of:
	 * <ul>
	 * <li>{@link #BUNDLE_ID}</li>
	 * <li>{@link #BUNDLE_REVISION_ID}</li>
	 * <li>{@link #REQUIREMENTS}</li>
	 * <li>{@link #CAPABILITIES}</li>
	 * <li>{@link #REQUIRED_WIRES}</li>
	 * <li>{@link #PROVIDED_WIRES}</li>
	 * </ul>
	 */
	CompositeType	BUNDLE_WIRING_TYPE					= Item.compositeType("BUNDLE_WIRING",
																"Describes the runtime association between a provider and a requirer",
																BUNDLE_ID_ITEM,
																BUNDLE_REVISION_ID_ITEM,
																REQUIREMENTS_ITEM,
																CAPABILITIES_ITEM,
																REQUIRED_WIRES_ITEM,
																PROVIDED_WIRES_ITEM);

	/**
	 * The Tabular Type to hold the wiring of a number of bundles. The row type
	 * is {@link #BUNDLE_WIRING_TYPE} and the index is the combination of the
	 * {@link #BUNDLE_ID} and the {@link #BUNDLE_REVISION_ID}.
	 */
	TabularType		BUNDLES_WIRING_TYPE					= Item.tabularType("BUNDLES_WIRING", "The bundle wiring for all bundle revisions", BUNDLE_WIRING_TYPE, BUNDLE_ID, BUNDLE_REVISION_ID);

	/**
	 * Returns the requirements for the current bundle revision.
	 *
	 * @see #REQUIREMENT_TYPE_ARRAY for the details of the CompositeData.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the requirements to be returned by this
	 *        operation.
	 * @return the declared requirements for the current revision of
	 *         {@code bundleId} and {@code namespace}.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	CompositeData[] getCurrentRevisionDeclaredRequirements(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the capabilities for the current bundle revision.
	 *
	 * @see #CAPABILITY_TYPE_ARRAY for the details of the CompositeData.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the capabilities to be returned by this
	 *        operation.
	 * @return the declared capabilities for the current revision of
	 *         {@code bundleId} and {@code namespace}.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	CompositeData[] getCurrentRevisionDeclaredCapabilities(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the bundle wiring for the current bundle revision.
	 *
	 * @see #BUNDLE_WIRING_TYPE for the details of the CompositeData.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the requirements and capabilities for
	 *        which to return information.
	 * @return the wiring information for the current revision of
	 *         {@code bundleId} and {@code namespace}.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	CompositeData getCurrentWiring(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the bundle wiring closure for the current revision of the
	 * specified bundle. The wiring closure contains all the wirings from the
	 * root bundle revision to all bundle revisions it is wired to and all their
	 * transitive wirings.
	 *
	 * @see #BUNDLES_WIRING_TYPE for the details of the TabularData.
	 *
	 * @param rootBundleId the root bundle of the closure.
	 * @param namespace The namespace of the requirements and capabilities for
	 *        which to return information.
	 * @return a tabular representation of all the wirings in the closure. The
	 *         bundle revision IDs only have meaning in the context of the
	 *         current result. The revision of the rootBundle is set to 0.
	 *         Therefore the root bundle of the closure can be looked up in the
	 *         table by its bundle ID and revision 0.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	TabularData getCurrentWiringClosure(long rootBundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the requirements for all revisions of the bundle.
	 *
	 * @see #REVISIONS_REQUIREMENTS_TYPE for the details of TabularData.
	 *
	 *      The requirements are in no particular order, and may change in
	 *      subsequent calls to this operation.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the requirements to be returned by this
	 *        operation.
	 * @return the declared requirements for all revisions of {@code bundleId}.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	TabularData getRevisionsDeclaredRequirements(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the capabilities for all revisions of the bundle.
	 *
	 * @see #REVISIONS_CAPABILITIES_TYPE for the details of TabularData.
	 *
	 *      The capabilities are in no particular order, and may change in
	 *      subsequent calls to this operation.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the capabilities to be returned by this
	 *        operation.
	 * @return the declared capabilities for all revisions of {@code bundleId}
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	TabularData getRevisionsDeclaredCapabilities(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the bundle wirings for all revisions of the bundle.
	 *
	 * @see #BUNDLES_WIRING_TYPE for the details of TabularData.
	 *
	 *      The bundle wirings are in no particular order, and may change in
	 *      subsequent calls to this operations.
	 *
	 * @param bundleId The bundle ID.
	 * @param namespace The namespace of the requirements and capabilities for
	 *        which to return information.
	 * @return the wiring information for all revisions of {@code bundleId} and
	 *         {@code namespace}.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	TabularData getRevisionsWiring(long bundleId, String namespace) throws IOException, JMException;

	/**
	 * Returns the bundle wiring closure for all revisions of the specified
	 * bundle. The wiring closure contains all the wirings from the root bundle
	 * revision to all bundle revisions it is wired to and all their transitive
	 * wirings.
	 *
	 * @see #BUNDLES_WIRING_TYPE for the details of TabularData.
	 *
	 *      The bundle wirings are in no particular order, and may change in
	 *      subsequent calls to this operation. Furthermore, the bundle revision
	 *      IDs are local and cannot be reused across invocations.
	 *
	 * @param rootBundleId The root bundle ID.
	 * @param namespace The namespace of the requirements and capabilities for
	 *        which to return information.
	 * @return a tabular representation of all the wirings in the closure. The
	 *         bundle revision IDs only have meaning in the context of the
	 *         current result.
	 * @throws JMException if there is a JMX problem.
	 * @throws IOException if the connection could not be made because of a
	 *         communication problem.
	 */
	TabularData getRevisionsWiringClosure(long rootBundleId, String namespace) throws IOException, JMException;

}
