content: /*
   * 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.io.IOException;
  import javax.management.openmbean.ArrayType;
  import javax.management.openmbean.CompositeData;
  import javax.management.openmbean.CompositeType;
  import javax.management.openmbean.SimpleType;
  
  
  public interface BlueprintMetadataMBean {
  
      /**
       * The object name for this MBean.
       */
      String OBJECTNAME = JmxConstants.ARIES_BLUEPRINT+":service=blueprintMetadata,version=1.0";
      
      
      ///////////////////////////////////////////////////////////////
      // Define <value>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key STRING_VALUE, used in {@link #STRING_VALUE_ITEM}.
       */
      String          STRING_VALUE            = "StringValue";
      
      /**
       * The item containing the un-converted string representation of the value.
       * The key is {@link #STRING_VALUE}, and the type is {@link SimpleType#STRING}.
       */
      Item            STRING_VALUE_ITEM       = new Item(
                                                      STRING_VALUE, 
                                                      "The un-converted string representation of a value", 
                                                      SimpleType.STRING);
      
      /**
       * The key TYPE, used in {@link #TYPE_ITEM}.
       */
      String          TYPE                    = "Type";
      
      /**
       * The item containing the name of the type to which the value should be converted.
       * The key is {@link #TYPE}, and the type is {@link SimpleType#STRING}.
       */
      Item            TYPE_ITEM               = new Item(
                                                      TYPE, 
                                                      "The type of a value", 
                                                      SimpleType.STRING);
      
      /**
       * The name of CompositeType for ValueMetadata objects, used in {@link #VALUE_METADATA_TYPE}.
       */
      String          VALUE_METADATA          = "ValueMetadata";
      
      
      /**
       * The CompositeType encapsulates ValueMetadata objects. It contains the following items:
       * <ul>
       * <li>{@link #STRING_VALUE}</li>
       * <li>{@link #TYPE}</li>
       * </ul>
       */
      CompositeType   VALUE_METADATA_TYPE     = Item.compositeType(
                                                      VALUE_METADATA, 
                                                      "This type encapsulates ValueMetadata objects", 
                                                      STRING_VALUE_ITEM, 
                                                      TYPE_ITEM);                  
      
      ///////////////////////////////////////////////////////////////
      // Define <null>'s CompositeType
      ///////////////////////////////////////////////////////////////  
      
      /**
       * The key PLACEHOLDER, used in {@link #PLACEHOLDER_ITEM}.
       */ 
      String          PLACEHOLDER             = "Placeholder";
      
      /**
       * The item is a placeholder in the null metadata type.
       * The key is {@link #PLACEHOLDER}, and the type is {@link SimpleType#STRING}.
       */
      Item            PLACEHOLDER_ITEM        = new Item(
                                                      PLACEHOLDER, 
                                                      "This is a placeholder", 
                                                      SimpleType.VOID);
      
      /**
       * The name of CompositeType for NullMetadata objects, used in {@link #NULL_METADATA_TYPE}.
       */
      String          NULL_METADATA          = "NullMetadata";
      
      /**
       * The CompositeType for NullMetadata objects. A composite type requires at least one item, so we add a placeholder item.
       */
      CompositeType   NULL_METADATA_TYPE      = Item.compositeType(
                                                      NULL_METADATA, 
                                                      "This type encapsulates NullMetadata objects", 
                                                      PLACEHOLDER_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <ref>'s CompositeType
      ///////////////////////////////////////////////////////////////      
      
      /**
       * The key COMPONENT_ID, used in {@link #COMPONENT_ID_ITEM}.
       */
      String          COMPONENT_ID            = "ComponentId";
      
      /**
       * The item containing the component id to which the "ref" associates.
       * The key is {@link #COMPONENT_ID}, and the type is {@link SimpleType#STRING}.
       */
      Item            COMPONENT_ID_ITEM       = new Item(
                                                      COMPONENT_ID,
                                                      "The component id",
                                                      SimpleType.STRING);
      /**
       * The name of CompositeType for RefMetadata objects, used in {@link #REF_METADATA_TYPE}.
       */
      String          REF_METADATA          = "RefMetadata";
      
      /**
       * The CompositeType for a RefMetadata object. It contains the following items:
       * <ul>
       * <li>{@link #COMPONENT_ID}</li>
       * </ul>
       */
      CompositeType   REF_METADATA_TYPE       = Item.compositeType(
                                                      REF_METADATA, 
                                                      "This type encapsulates RefMetadata objects", 
                                                      COMPONENT_ID_ITEM);
  
      ///////////////////////////////////////////////////////////////
      // Define <idref>'s CompositeType
      // COMPONENT_ID_ITEM defined in <ref>'s definition
      ///////////////////////////////////////////////////////////////  
      /**
       * The name of CompositeType for IdRefMetadata objects, used in {@link #ID_REF_METADATA_TYPE}.
       */
      String          ID_REF_METADATA          = "IdRefMetadata";
      
      /**
       * The CompositeType for an IdRefMetadata object. It contains the following items:
       * <ul>
       * <li>{@link #COMPONENT_ID}</li>
       * </ul>
       */
      CompositeType   ID_REF_METADATA_TYPE    = Item.compositeType(
                                                      ID_REF_METADATA, 
                                                      "This type encapsulates IdRefMetadata objects", 
                                                      COMPONENT_ID_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <entry>'s CompositeType, 
      // used by MapMetadata, PropsMetadata, and Service properties
      ///////////////////////////////////////////////////////////////    
      
      /**
       * The key KEY, used in {@link #KEY_ITEM}.
       */    
      String          KEY                     = "Key";
      
      /**
       * The item containing the key of an entry.
       * The key is {@link #KEY}, and the type is {@link SimpleType#STRING}.
       */
      Item            KEY_ITEM                = new Item(
                                                      KEY,
                                                      "The key of an entry",
                                                      JmxConstants.BYTE_ARRAY_TYPE);
      
      /**
      * The key VALUE, used in {@link #VALUE_ITEM}.
      */
      String          VALUE                   = "Value";
         
      /**
      * The item containing a value and this will be used by 
      * BeanArgument, BeanProperty, MapEntry and CollectionMetadata.
      * The key is {@link #VALUE}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}.
      */
      Item            VALUE_ITEM              = new Item(
                                                     VALUE, 
                                                     "A value", 
                                                     JmxConstants.BYTE_ARRAY_TYPE);  
  
      /**
       * The name of CompositeType for MapEntry objects, used in {@link #MAP_ENTRY_TYPE}.
       */
      String          MAP_ENTRY          = "MapEntry";
      
      /**
       * The CompositeType for a MapEntry object. It contains the following items:
       * <ul>
       * <li>{@link #KEY}</li>
       * <li>{@link #VALUE}</li>
       * </ul>
       */
      CompositeType   MAP_ENTRY_TYPE          = Item.compositeType(
                                                     MAP_ENTRY, 
                                                     "This type encapsulates MapEntry objects",
                                                     KEY_ITEM,
                                                     VALUE_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <map>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key ENTRIES, used in {@link #ENTRIES_ITEM}.
       */
      String          ENTRIES                 = "Entries";
      
      /**
       * The item containing an array of entries
       * The key is {@link #ENTRIES}, and the type is {@link ArrayType}.
       */
      Item            ENTRIES_ITEM            = new Item(
                                                      ENTRIES,
                                                      "An array of entries",
                                                      Item.arrayType(1, MAP_ENTRY_TYPE));
      
      /**
       * The key KEY_TYPE, used in {@link #KEY_TYPE_ITEM}.
       */
      String          KEY_TYPE                = "KeyType";
      
      /**
       * The item containing the key type of the entries.
       * The key is {@link #KEY_TYPE}, and the type is {@link SimpleType#STRING}.
       */
      Item            KEY_TYPE_ITEM           = new Item(
                                                      KEY_TYPE,
                                                      "The key type of the entries",
                                                      SimpleType.STRING);
      
      /**
       * The key VALUE_TYPE, used in {@link #VALUE_TYPE_ITEM}.
       */
      String          VALUE_TYPE              = "ValueType";
      
      /**
       * The item containing the value type that the value should be
       * The key is {@link #VALUE_TYPE}, and the type is {@link SimpleType#STRING}.
       */
      Item            VALUE_TYPE_ITEM         = new Item(
                                                      VALUE_TYPE, 
                                                      "The value type", 
                                                      SimpleType.STRING);
      
      /**
       * The name of CompositeType for MapMetadata objects, used in {@link #MAP_METADATA_TYPE}.
       */
      String          MAP_METADATA          = "MapMetadata";
      
      /**
       * The CompositeType for a MapMetadata object. It contains the following items:
       * <ul>
       * <li>{@link #ENTRIES}</li>
       * <li>{@link #KEY_TYPE}</li>
       * <li>{@link #VALUE_TYPE}</li>
       * </ul>
       */
      CompositeType   MAP_METADATA_TYPE       = Item.compositeType(
                                                      MAP_METADATA, 
                                                      "This type encapsulates MapMetadata objects",
                                                      ENTRIES_ITEM,
                                                      KEY_TYPE_ITEM,
                                                      VALUE_TYPE_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <props>'s CompositeType
      // ENTRIES_ITEM defined in <map>'s definition
      ///////////////////////////////////////////////////////////////
  
      /**
       * The name of CompositeType for PropsMetadata objects, used in {@link #PROPS_METADATA_TYPE}.
       */
      String          PROPS_METADATA          = "PropsMetadata";    
      
      /**
       * The CompositeType for a PropsMetadata object. It contains the following items:
       * <ul>
       * <li>{@link #ENTRIES}</li>
       * </ul>
       */
      CompositeType   PROPS_METADATA_TYPE     = Item.compositeType(
                                                      PROPS_METADATA, 
                                                      "This type encapsulates PropsMetadata objects",
                                                      ENTRIES_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <collection>'s CompositeType
      // VALUE_TYPE_ITEM defined in <map>'s definition
      ///////////////////////////////////////////////////////////////   
      
      /**
       * The key COLLECTION_CLASS, used in {@link #KEY_TYPE_ITEM}.
       */
      String          COLLECTION_CLASS        = "CollectionClass";    
      
      /**
       * The item containing the type of this collection
       * The key is {@link #COLLECTION_CLASS}, and the type is {@link SimpleType#STRING}.
       */
      Item            COLLECTION_CLASS_ITEM   = new Item(
                                                      COLLECTION_CLASS,
                                                      "The type of this collection",
                                                      SimpleType.STRING);
      
      /**
       * The key VALUES, used in {@link #VALUES_ITEM}.
       */
      String          VALUES                  = "Values";
      
      /**
       * The item containing all the values
       * The key is {@link #VALUES}, and the type is {@link ArrayType}.
       */
      Item            VALUES_ITEM             = new Item(
                                                      VALUES,
                                                      "All the values",
                                                      Item.arrayType(2, SimpleType.BYTE));
      
  
      /**
       * The name of CompositeType for CollectionMetadata objects, used in {@link #COLLECTION_METADATA_TYPE}.
       */
      String          COLLECTION_METADATA          = "CollectionMetadata";    
      
      /**
       * The CompositeType for a CollectionMetadata object. It contains the following items:
       * <ul>
       * <li>{@link #COLLECTION_CLASS}</li>
       * <li>{@link #VALUES}</li>
       * <li>{@link #VALUE_TYPE}</li>
       * </ul>
       */
      CompositeType   COLLECTION_METADATA_TYPE= Item.compositeType(
                                                      COLLECTION_METADATA, 
                                                      "This type encapsulates CollectionMetadata objects",
                                                      COLLECTION_CLASS_ITEM,
                                                      VALUES_ITEM,
                                                      VALUE_TYPE_ITEM);
     
      ///////////////////////////////////////////////////////////////
      // Define <argument>'s CompositeType
      // VALUE_TYPE_ITEM defined in <map>'s definition
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key INDEX, used in {@link #INDEX_ITEM}.
       */
      String          INDEX                   = "Index";
      
      /**
       * The item containing the zero-based index into the parameter list of
       * the factory method or constructor to be invoked for this argument.
       * The key is {@link #INDEX}, and the type is {@link SimpleType#INTEGER}.
       */
      Item            INDEX_ITEM              = new Item(
                                                      INDEX, 
                                                      "The zero-based index", 
                                                      SimpleType.INTEGER);
  
      /**
       * The name of CompositeType for BeanArgument objects, used in {@link #BEAN_ARGUMENT_TYPE}.
       */
      String          BEAN_ARGUMENT               = "BeanArgument";    
  
      
      /**
       * The CompositeType for a Argument object. It contains the following items:
       * <ul>
       * <li>{@link #INDEX}</li>
       * <li>{@link #VALUE_TYPE}</li>
       * <li>{@link #VALUE}</li>
       * </ul>
       */
      CompositeType   BEAN_ARGUMENT_TYPE          = Item.compositeType(
                                                      BEAN_ARGUMENT,
                                                      "This type encapsulates BeanArgument objects",
                                                      INDEX_ITEM,
                                                      VALUE_TYPE_ITEM,
                                                      VALUE_ITEM);
         
      ///////////////////////////////////////////////////////////////
      // Define <property>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key NAME, used in {@link #NAME_ITEM}.
       */
      String          NAME                    = "Name";
      
      /**
       * The item containing the name of the property to be injected.
       * The key is {@link #NAME}, and the type is {@link SimpleType#STRING}.
       */
      Item            NAME_ITEM               = new Item(
                                                      NAME,
                                                      "The name of the property",
                                                      SimpleType.STRING);
      
      /**
       * The name of CompositeType for BeanProperty objects, used in {@link #BEAN_PROPERTY_TYPE}.
       */
      String          BEAN_PROPERTY               = "BeanProperty";    
      
      /**
       * The CompositeType for property type. It contains the following items:
       * <ul>
       * <li>{@link #NAME}</li>
       * <li>{@link #VALUE}</li>
       * </ul>
       */
      CompositeType   BEAN_PROPERTY_TYPE           = Item.compositeType(
                                                      BEAN_PROPERTY, 
                                                      "This type encapsulates BeanProperty objects",
                                                      NAME_ITEM,
                                                      VALUE_ITEM);
          
      ///////////////////////////////////////////////////////////////
      // Define Component's CompositeType
      // <bean>, <service> & Service Reference's CompositeType will 
      // extend this.
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key ID, used in {@link #ID_ITEM}.
       */
      String          ID                    = "Id";
  
      /**
       * The item containing the component id of a component. 
       * The key is {@link #ID}, and the type is {@link SimpleType#STRING}.
       */
      Item            ID_ITEM       = new Item(
                                                      ID,
                                                      "The id of the component",
                                                      SimpleType.STRING);
      /**
       * The key ACTIVATION, used in {@link #ACTIVATION_ITEM}.
       */
      String          ACTIVATION              = "Activation";
      
      /**
       * The item containing the activation strategy for a component. 
       * The key is {@link #ACTIVATION}, and the type is {@link SimpleType#INTEGER}.
       */
      Item            ACTIVATION_ITEM         = new Item(
                                                      ACTIVATION,
                                                      "The activation strategy for a component",
                                                      SimpleType.INTEGER);
      
      /**
       * The key DEPENDS_ON, used in {@link #DEPENDS_ON_ITEM}.
       */
      String          DEPENDS_ON              = "DependsOn";
      
      /**
       * The item containing the ids of any components listed in a <code>depends-on</code> attribute for the component. 
       * The key is {@link #DEPENDS_ON}, and the type is {@link JmxConstants#STRING_ARRAY_TYPE}.
       */
      Item            DEPENDS_ON_ITEM         = new Item(
                                                      DEPENDS_ON,
                                                      "The ids of any components listed in a depends-on attribute",
                                                      JmxConstants.STRING_ARRAY_TYPE);
      
      /**
       * The name of CompositeType for ComponentMetadata objects, used in {@link #COMPONENT_METADATA_TYPE}.
       */
      String          COMPONENT_METADATA               = "ComponentMetadata";    
      
      /**
       * The CompositeType for a ComponentMetadata object, it contains 
       * the following items:
       * <ul>
       * <li>{@link #ID}</li>
       * <li>{@link #ACTIVATION}</li>
       * <li>{@link #DEPENDS_ON}</li>
       * </ul>
       */
      CompositeType   COMPONENT_METADATA_TYPE     = Item.compositeType(
                                                      COMPONENT_METADATA,
                                                      "This type encapsulates ComponentMetadata objects",
                                                      ID_ITEM,
                                                      ACTIVATION_ITEM,
                                                      DEPENDS_ON_ITEM);
                              
      ///////////////////////////////////////////////////////////////
      // Define <bean>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key CLASS_NAME, used in {@link #CLASS_NAME_ITEM}.
       */
      String          CLASS_NAME              = "ClassName";
      
      /**
       * The item containing the name of the class specified for the bean. 
       * The key is {@link #CLASS_NAME}, and the type is {@link SimpleType#STRING}.
       */
      Item            CLASS_NAME_ITEM         = new Item(
                                                      CLASS_NAME,
                                                      "The name of the class specified for the bean",
                                                      SimpleType.STRING
                                                      );
      
      /**
       * The key INIT_METHOD, used in {@link #INIT_METHOD_ITEM}.
       */
      String          INIT_METHOD             = "InitMethod";
      
      /**
       * The item containing the name of the init method specified for the bean.
       * The key is {@link #INIT_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            INIT_METHOD_ITEM        = new Item(
                                                      INIT_METHOD, 
                                                      "The name of the init method specified for the bean", 
                                                      SimpleType.STRING);
      
      /**
       * The key DESTROY_METHOD, used in {@link #DESTROY_METHOD_ITEM}.
       */
      String          DESTROY_METHOD          = "DestroyMethod";
      
      /**
       * The item containing the name of the destroy method specified for the bean.
       * The key is {@link #DESTROY_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            DESTROY_METHOD_ITEM     = new Item(
                                                      DESTROY_METHOD, 
                                                      "The name of the destroy method specified for the bean", 
                                                      SimpleType.STRING);
  
      /**
       * The key FACTORY_METHOD, used in {@link #FACTORY_METHOD_ITEM}.
       */
      String          FACTORY_METHOD          = "FactoryMethod";
      
      /**
       * The item containing the name of the factory method specified for the bean.
       * The key is {@link #FACTORY_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            FACTORY_METHOD_ITEM     = new Item(
                                                      FACTORY_METHOD, 
                                                      "The name of the factory method specified for the bean", 
                                                      SimpleType.STRING);
      
      /**
       * The key FACTORY_COMPONENT, used in {@link #FACTORY_COMPONENT_ITEM}.
       */
      String          FACTORY_COMPONENT       = "FactoryComponent";
      
      /**
       * The item containing the id of the factory component on which to invoke the factory method for the bean.
       * The key is {@link #FACTORY_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}.
       */
      Item            FACTORY_COMPONENT_ITEM  = new Item(
                                                      FACTORY_COMPONENT, 
                                                      "The factory component on which to invoke the factory method for the bean", 
                                                      JmxConstants.BYTE_ARRAY_TYPE);
      
      /**
       * The key SCOPE, used in {@link #SCOPE_ITEM}.
       */
      String          SCOPE                   = "Scope";
      
      /**
       * The item containing the scope for the bean.
       * The key is {@link #SCOPE}, and the type is {@link SimpleType#STRING}.
       */
      Item            SCOPE_ITEM              = new Item(
                                                      SCOPE, 
                                                      "The scope for the bean", 
                                                      SimpleType.STRING);
  
      /**
       * The key ARGUMENT, used in {@link #ARGUMENTS_ITEM}.
       */
      String          ARGUMENTS                   = "Arguments";
          
      /**
       * The item containing the bean argument for the bean's compositeType.
       * The key is {@link #ARGUMENTS}, and the type is {@link #BEAN_ARGUMENT_TYPE}.
       */
      Item           ARGUMENTS_ITEM     = new Item(
                                                      ARGUMENTS, 
                                                      "The bean argument", 
                                                      Item.arrayType(1, BEAN_ARGUMENT_TYPE));
      
      /**
       * The key PROPERTY, used in {@link #PROPERTIES_ITEM}.
       */
      String          PROPERTIES         = "Properties";
          
      /**
       * The item containing the bean property for the bean's compositeType.
       * The key is {@link #PROPERTIES}, and the type is {@link #BEAN_PROPERTY_TYPE}.
       */
      Item            PROPERTIES_ITEM    = new Item(
                                                      PROPERTIES, 
                                                      "The bean property", 
                                                      Item.arrayType(1, BEAN_PROPERTY_TYPE));
      
      /**
       * The name of CompositeType for BeanMetadata objects, used in {@link #BEAN_METADATA_TYPE}.
       */
      String          BEAN_METADATA               = "BeanMetadata";    
      
      /**
       * The CompositeType for a BeanMetadata object, it extends {@link #COMPONENT_METADATA_TYPE} 
       * and adds the following items:
       * <ul>
       * <li>{@link #CLASS_NAME}</li>
       * <li>{@link #INIT_METHOD}</li>
       * <li>{@link #DESTROY_METHOD}</li>
       * <li>{@link #FACTORY_METHOD}</li>
       * <li>{@link #FACTORY_COMPONENT}</li>
       * <li>{@link #SCOPE}</li>
       * <li>{@link #ARGUMENTS}</li>
       * <li>{@link #PROPERTIES}</li>
       * </ul>
       */
      CompositeType   BEAN_METADATA_TYPE      = Item.extend(
                                                      COMPONENT_METADATA_TYPE, 
                                                      BEAN_METADATA, 
                                                      "This type encapsulates BeanMetadata objects",
                                                      CLASS_NAME_ITEM,
                                                      INIT_METHOD_ITEM,
                                                      DESTROY_METHOD_ITEM, 
                                                      FACTORY_METHOD_ITEM,
                                                      FACTORY_COMPONENT_ITEM,
                                                      SCOPE_ITEM,
                                                      ARGUMENTS_ITEM,
                                                      PROPERTIES_ITEM);
  
      ///////////////////////////////////////////////////////////////
      // Define <registration-listener>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key LISTENER_COMPONENT, used in {@link #LISTENER_COMPONENT_ITEM}.
       */
      String          LISTENER_COMPONENT      = "ListenerComponent";
      
      /**
       * The item containing the listener component.
       * The key is {@link #LISTENER_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}.
       */
      Item            LISTENER_COMPONENT_ITEM = new Item(
                                                      LISTENER_COMPONENT, 
                                                      "The listener component", 
                                                      JmxConstants.BYTE_ARRAY_TYPE);
      
      /**
       * The key REGISTRATION_METHOD, used in {@link #REGISTRATION_METHOD_ITEM}.
       */
      String          REGISTRATION_METHOD     = "RegistrationMethod";
      
      /**
       * The item containing the name of the registration method.
       * The key is {@link #REGISTRATION_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            REGISTRATION_METHOD_ITEM    = new Item(
                                                      REGISTRATION_METHOD, 
                                                      "The name of the registration method", 
                                                      SimpleType.STRING);
      
      /**
       * The key UNREGISTRATION_METHOD, used in {@link #UNREGISTRATION_METHOD_ITEM}.
       */
      String          UNREGISTRATION_METHOD       = "UnregistrationMethod";
      
      /**
       * The item containing the name of the unregistration method.
       * The key is {@link #UNREGISTRATION_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            UNREGISTRATION_METHOD_ITEM  = new Item(
                                                      UNREGISTRATION_METHOD, 
                                                      "The name of the unregistration method", 
                                                      SimpleType.STRING);
      
      /**
       * The name of CompositeType for RegistrationListener objects, used in {@link #REGISTRATION_LISTENER_TYPE}.
       */
      String          REGISTRATION_LISTENER               = "RegistrationListener";    
      
      /**
       * The CompositeType for a registration listener, and it contains the following items:
       * <ul>
       * <li>{@link #LISTENER_COMPONENT}</li>
       * <li>{@link #REGISTRATION_METHOD}</li>
       * <li>{@link #UNREGISTRATION_METHOD}</li>
       * </ul>
       */
      CompositeType   REGISTRATION_LISTENER_TYPE  = Item.compositeType(
                                                      REGISTRATION_LISTENER, 
                                                      "This type encapsulates RegistrationListener objects",
                                                      LISTENER_COMPONENT_ITEM,
                                                      REGISTRATION_METHOD_ITEM,
                                                      UNREGISTRATION_METHOD_ITEM);
      
      
      ///////////////////////////////////////////////////////////////
      // Define <service>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key INTERFACES, used in {@link #INTERFACES_ITEM}.
       */
      String          INTERFACES              = "Interfaces";
      
      /**
       * The item containing the type names of the interfaces that the service should be advertised as supporting.
       * The key is {@link #INTERFACES}, and the type is {@link JmxConstants#STRING_ARRAY_TYPE}.
       */
      Item            INTERFACES_ITEM         = new Item(
                                                      INTERFACES, 
                                                      "The type names of the interfaces", 
                                                      JmxConstants.STRING_ARRAY_TYPE);
      /**
       * The key AUTO_EXPORT, used in {@link #AUTO_EXPORT_ITEM}.
       */
      String          AUTO_EXPORT             = "AutoExport";
      
      /**
       * The item containing the auto-export mode for the service.
       * The key is {@link #AUTO_EXPORT}, and the type is {@link SimpleType#INTEGER}.
       */
      //TODO describe integer
      Item            AUTO_EXPORT_ITEM        = new Item(
                                                      AUTO_EXPORT, 
                                                      "The auto-export mode for the service", 
                                                      SimpleType.INTEGER);
  
      /**
       * The key RANKING, used in {@link #RANKING_ITEM}.
       */
      String          RANKING                 = "Ranking";
      
      /**
       * The item containing the ranking value to use when advertising the service.
       * The key is {@link #RANKING}, and the type is {@link SimpleType#INTEGER}.
       */
      Item            RANKING_ITEM            = new Item(
                                                      RANKING, 
                                                      "The ranking value when advertising the service", 
                                                      SimpleType.INTEGER);
  
      /**
       * The key SERVICE_COMPONENT, used in {@link #SERVICE_COMPONENT_ITEM}.
       */
      String          SERVICE_COMPONENT       = "ServiceComponent";
      
      /**
       * The item containing the id of the component to be exported as a service.
       * The key is {@link #SERVICE_COMPONENT}, and the type is {@link JmxConstants#BYTE_ARRAY_TYPE}.
       */
      Item            SERVICE_COMPONENT_ITEM  = new Item(
                                                      SERVICE_COMPONENT, 
                                                      "The component to be exported as a service", 
                                                      JmxConstants.BYTE_ARRAY_TYPE);
      
      /**
       * The key SERVICE_PROPERTIES, used in {@link #SERVICE_PROPERTIES_ITEM}.
       */
      String          SERVICE_PROPERTIES      = "ServiceProperties";
      
      /**
       * The item containing the user declared properties to be advertised with the service.
       * The key is {@link #SERVICE_COMPONENT}, and the type is {@link SimpleType#STRING}.
       */
      Item            SERVICE_PROPERTIES_ITEM = new Item(
                                                      SERVICE_PROPERTIES,
                                                      "The user declared properties to be advertised with the service",
                                                      Item.arrayType(1, MAP_ENTRY_TYPE));
      
      /**
       * The key REGISTRATION_LISTENERS, used in {@link #REGISTRATION_LISTENERS_ITEM}.
       */
      String          REGISTRATION_LISTENERS  = "RegistrationListeners";
      
      /**
       * The item containing all the registration listeners.
       * The key is {@link #REGISTRATION_LISTENERS}, and the type is {@link ArrayType}.
       */
      Item            REGISTRATION_LISTENERS_ITEM = new Item(
                                                      REGISTRATION_LISTENERS,
                                                      "All the registration listeners",
                                                      Item.arrayType(1, REGISTRATION_LISTENER_TYPE));
      
      /**
       * The name of CompositeType for ServiceMetadata objects, used in {@link #SERVICE_METADATA_TYPE}.
       */
      String          SERVICE_METADATA               = "ServiceMetadata";    
      
      /**
       * The CompositeType for a ServiceMetadata object, it extends {@link #COMPONENT_METADATA_TYPE}
       * and adds the following items:
       * <ul>
       * <li>{@link #INTERFACES}</li>
       * <li>{@link #AUTO_EXPORT}</li>
       * <li>{@link #RANKING}</li>
       * <li>{@link #SERVICE_COMPONENT}</li>
       * <li>{@link #SERVICE_PROPERTIES}</li>
       * <li>{@link #REGISTRATION_LISTENERS}</li>
       * </ul>
       */
      CompositeType   SERVICE_METADATA_TYPE   = Item.extend(
                                                      COMPONENT_METADATA_TYPE, 
                                                      SERVICE_METADATA, 
                                                      "This type encapsulates ServiceMetadata objects",
                                                      INTERFACES_ITEM,
                                                      AUTO_EXPORT_ITEM,
                                                      RANKING_ITEM,
                                                      SERVICE_COMPONENT_ITEM,
                                                      SERVICE_PROPERTIES_ITEM,
                                                      REGISTRATION_LISTENERS_ITEM);
  
      ///////////////////////////////////////////////////////////////
      // Define <reference-listener>'s CompositeType
      // LISTENER_COMPONENT_ITEM defined in the <registration-listener>
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key BIND_METHOD, used in {@link #BIND_METHOD_ITEM}.
       */
      String          BIND_METHOD                 = "BindMethod";
      
      /**
       * The item containing the name of the bind method.
       * The key is {@link #BIND_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            BIND_METHOD_ITEM            = new Item(
                                                      BIND_METHOD, 
                                                      "The name of the bind method", 
                                                      SimpleType.STRING);
      
      /**
       * The key UNBIND_METHOD, used in {@link #UNBIND_METHOD_ITEM}.
       */
      String          UNBIND_METHOD               = "UnbindMethod";
      
      /**
       * The item containing the name of the unbind method.
       * The key is {@link #UNBIND_METHOD}, and the type is {@link SimpleType#STRING}.
       */
      Item            UNBIND_METHOD_ITEM          = new Item(
                                                      UNBIND_METHOD, 
                                                      "The name of the unbind method", 
                                                      SimpleType.STRING);
      
      /**
       * The name of CompositeType for ReferenceListener objects, used in {@link #REFERENCE_LISTENER_TYPE}.
       */
      String          REFERENCE_LISTENER               = "ReferenceListener"; 
      
      /**
       * The CompositeType for a reference listener, and it contains the following items:
       * <ul>
       * <li>{@link #LISTENER_COMPONENT}</li>
       * <li>{@link #BIND_METHOD}</li>
       * <li>{@link #UNBIND_METHOD}</li>
       * </ul>
       */
      CompositeType   REFERENCE_LISTENER_TYPE  = Item.compositeType(
                                                      REFERENCE_LISTENER, 
                                                      "This type encapsulates ReferenceListener objects",
                                                      LISTENER_COMPONENT_ITEM,
                                                      BIND_METHOD_ITEM,
                                                      UNBIND_METHOD_ITEM);
      
      
      ///////////////////////////////////////////////////////////////
      // Define Service Reference's CompositeType, 
      // <reference> & <reference-list> will extend this
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key AVAILABILITY, used in {@link #AVAILABILITY_ITEM}.
       */
      String          AVAILABILITY            = "Availability";
      
      /**
       * The item specify whether or not a matching service is required at all times.
       * The key is {@link #AVAILABILITY}, and the type is {@link SimpleType#INTEGER}.
       * 
       */
      //TODO add description for each int
      Item            AVAILABILITY_ITEM       = new Item(
                                                      AVAILABILITY, 
                                                      "To specify whether or not a matching service is required at all times", 
                                                      SimpleType.INTEGER);
      
      /**
       * The key INTERFACE, used in {@link #INTERFACE_ITEM}.
       */
      String          INTERFACE               = "Interface";
      
      /**
       * The item containing the name of the interface type that a matching service must support.
       * The key is {@link #INTERFACE}, and the type is {@link SimpleType#STRING}.
       */
      Item            INTERFACE_ITEM          = new Item(
                                                      INTERFACE, 
                                                      "the name of the interface type", 
                                                      SimpleType.STRING);
      
      /**
       * The key COMPONENT_NAME, used in {@link #COMPONENT_NAME_ITEM}.
       */
      String          COMPONENT_NAME          = "ComponentName";
      
      /**
       * The item containing the value of the <code>component-name</code> attribute of the service reference.
       * The key is {@link #INTERFACE}, and the type is {@link SimpleType#STRING}.
       */
      Item            COMPONENT_NAME_ITEM     = new Item(
                                                      COMPONENT_NAME, 
                                                      "The value of the component-name attribute of the service reference", 
                                                      SimpleType.STRING);
      /**
       * The key FILTER, used in {@link #FILTER_ITEM}.
       */
      String          FILTER                  = "Filter";
      
      /**
       * The item containing the filter expression that a matching service must match.
       * The key is {@link #FILTER}, and the type is {@link SimpleType#STRING}.
       */
      Item            FILTER_ITEM             = new Item(
                                                      FILTER, 
                                                      "The filter expression that a matching service must match", 
                                                      SimpleType.STRING);
      
      /**
       * The key REFERENCE_LISTENERS, used in {@link #REFERENCE_LISTENERS_ITEM}.
       */
      String          REFERENCE_LISTENERS     = "ReferenceListeners";
      
      /**
       * The item containing all the reference listeners.
       * The key is {@link #REFERENCE_LISTENERS}, and the type is {@link ArrayType}.
       */
      Item            REFERENCE_LISTENERS_ITEM= new Item(
                                                      REFERENCE_LISTENERS,
                                                      "All the reference listeners",
                                                      Item.arrayType(1, REFERENCE_LISTENER_TYPE));
      
      /**
       * The name of CompositeType for ServiceReferenceMetadata objects, used in {@link #SERVICE_REFERENCE_METADATA_TYPE}.
       */
      String          SERVICE_REFERENCE_METADATA               = "ServiceReferenceMetadata"; 
      
      /**
       * The CompositeType for a ServiceReferenceMetadata object, it extends 
       * {@link #COMPONENT_METADATA_TYPE} and adds the following items:
       * <ul>
       * <li>{@link #AVAILABILITY}</li>
       * <li>{@link #INTERFACE}</li>
       * <li>{@link #COMPONENT_NAME}</li>
       * <li>{@link #FILTER}</li>
       * <li>{@link #REFERENCE_LISTENERS}</li>
       * </ul>
       */
      CompositeType   SERVICE_REFERENCE_METADATA_TYPE  = Item.extend(
                                                      COMPONENT_METADATA_TYPE, 
                                                      SERVICE_REFERENCE_METADATA, 
                                                      "This type encapsulates ServiceReferenceMetadata objects",
                                                      AVAILABILITY_ITEM,
                                                      INTERFACE_ITEM,
                                                      COMPONENT_NAME_ITEM,
                                                      FILTER_ITEM,
                                                      REFERENCE_LISTENERS_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <reference>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key TIME_OUT, used in {@link #TIMEOUT_ITEM}.
       */
      String          TIMEOUT                = "TimeOut";
      
      /**
       * The item containing the timeout for service invocations when a backing service is is unavailable.
       * The key is {@link #TIMEOUT}, and the type is {@link SimpleType#LONG}.
       */
      Item            TIMEOUT_ITEM           = new Item(
                                                      TIMEOUT, 
                                                      "The timeout for service invocations when a backing service is is unavailable", 
                                                      SimpleType.LONG);
      
      /**
       * The name of CompositeType for ReferenceMetadata objects, used in {@link #REFERENCE_METADATA_TYPE}.
       */
      String          REFERENCE_METADATA        = "ReferenceMetadata"; 
      
      /**
       * The CompositeType for a ReferenceMetadata object, it extends 
       * {@link #SERVICE_REFERENCE_METADATA_TYPE} and adds the following items:
       * <ul>
       * <li>{@link #TIMEOUT}</li>
       * </ul>
       */
      CompositeType   REFERENCE_METADATA_TYPE = Item.extend(
                                                      SERVICE_REFERENCE_METADATA_TYPE, 
                                                      REFERENCE_METADATA, 
                                                      "This type encapsulates ReferenceMetadata objects",
                                                      TIMEOUT_ITEM);
      
      ///////////////////////////////////////////////////////////////
      // Define <reference-list>'s CompositeType
      ///////////////////////////////////////////////////////////////
      
      /**
       * The key MEMBER_TYPE, used in {@link #MEMBER_TYPE_ITEM}.
       */
      String          MEMBER_TYPE             = "MemberType";
      
      /**
       * The item specify whether the List will contain service object proxies or ServiceReference objects.
       * The key is {@link #MEMBER_TYPE}, and the type is {@link SimpleType#INTEGER}.
       */
      Item            MEMBER_TYPE_ITEM        = new Item(
                                                      MEMBER_TYPE, 
                                                      "To specify whether the List will contain service object proxies or ServiceReference objects", 
                                                      SimpleType.INTEGER);
      
      /**
       * The name of CompositeType for ReferenceListMetadata objects, used in {@link #REFERENCE_LIST_METADATA_TYPE}.
       */
      String          REFERENCE_LIST_METADATA        = "ReferenceListMetadata"; 
      
      /**
       * The CompositeType for a ReferenceListMetadata object, it extends 
       * {@link #SERVICE_REFERENCE_METADATA_TYPE} and adds the following items:
       * <ul>
       * <li>{@link #MEMBER_TYPE}</li>
       * </ul>
       */
      CompositeType   REFERENCE_LIST_METADATA_TYPE = Item.extend(
                                                      SERVICE_REFERENCE_METADATA_TYPE, 
                                                      REFERENCE_LIST_METADATA, 
                                                      "This type encapsulates ReferenceListMetadata objects",
                                                      MEMBER_TYPE_ITEM);
  
  
      /**
       * Returns the list of component id.
       * 
       * @param containerServiceId The blueprint container service id
       * @return the array of component id
       * @throws IOException if the operation fails
       */
      String[] getComponentIds(long containerServiceId) throws IOException;
      
      /**
       * Returns all component ids of the specified component type
       * 
       * @param containerServiceId The blueprint container service id
       * @param type The string used to specify the type of component
       * @return the array of component id
       * @throws IOException if the operation fails
       */
      String[] getComponentIdsByType(long containerServiceId, String type) throws IOException;
      
      /**
       * Returns the ComponentMetadata according to the its component id.
       * The returned Composite Data's type is actually one of {@link #BEAN_METADATA_TYPE}, 
       * {@link #SERVICE_METADATA_TYPE}, {@link #REFERENCE_METADATA_TYPE}, REFERENCE_LIST_METADATA_TYPE.
       * 
       * @param containerServiceId The blueprint container service id
       * @param componentId The component id
       * @return the ComponentMetadata
       * @throws IOException if the operation fails
       */
      CompositeData getComponentMetadata(long containerServiceId, String componentId) throws IOException;
          
      /**
       * Returns all the blueprint containers' service IDs, which successfully
       * created from blueprint bundles.
       * 
       * @return the list of all the service IDs of the blueprint containers created by current extender 
       * @throws IOException if the operation fails
       */
      long[] getBlueprintContainerServiceIds() throws IOException;
      
      /**
       * Returns the blueprint container's service id if the bundle specified 
       * by the bundle id is a blueprint bundle.
       * 
       * @param bundleId The bundle id of a blueprint bundle
       * @return the blueprint container's service id, or null if the blueprint bundle initialed failed.
       * @throws IOException if the operation fails
       * @throws IllegalArgumentException if the bundle is not a blueprint bundle
       */
      long getBlueprintContainerServiceId(long bundleId) throws IOException;
  }
  