public ServiceDynamicMBeanSupport() 
{
      super();
}

 public ServiceDynamicMBeanSupport(Class type) 
{
      super(type);
}

 public ServiceDynamicMBeanSupport(String category) 
{
      super(category);
}

 public ServiceDynamicMBeanSupport(Logger log) 
{
      super(log);
}

 public Object getAttribute(String attribute) throws ReflectionException, AttributeNotFoundException, MBeanException 
{
      // locally managed attributes!
      //
      if("State".equals(attribute))
      {
         return new Integer(getState());
      }
      if("StateString".equals(attribute))
      {
         return getStateString();
      }
      if("Name".equals(attribute))
      {
         return getName();
      }
      // Wrapped attributes?
      //
      return getInternalAttribute (attribute);
}

 public AttributeList getAttributes(String[] attributes) 
{
      AttributeList list = new AttributeList();
      if (attributes == null)
         return list;
      for (int i = 0; i <  attributes.length; ++i)
      {
         try
         {
            Object value = getAttribute(attributes[i]);
            list.add(new Attribute(attributes[i], value));
         }
         catch (Throwable t)
         {
            log.debug("Error getting attribute " + attributes[i], t);
         }
      }
      return list;
}

 protected Object getInternalAttribute(String attribute) throws ReflectionException, AttributeNotFoundException, MBeanException 
{
      throw new AttributeNotFoundException ("Attribute not found " + attribute);
}

 protected MBeanAttributeInfo[] getInternalAttributeInfo() 
{
      return new MBeanAttributeInfo[0];
}

 protected MBeanConstructorInfo[] getInternalConstructorInfo() 
{
      return new MBeanConstructorInfo[0];
}

 protected String getInternalDescription() 
{
      return "DynamicMBean Service";
}

 protected MBeanNotificationInfo[] getInternalNotificationInfo() 
{
      return new MBeanNotificationInfo[0];
}

 protected MBeanOperationInfo[] getInternalOperationInfo() 
{
      return new MBeanOperationInfo[0];
}

 public MBeanInfo getMBeanInfo() 
{
      MBeanParameterInfo[] noParams = new MBeanParameterInfo[] {};
      MBeanConstructorInfo[] ctorInfo = getInternalConstructorInfo();
      MBeanAttributeInfo[] attrs = getInternalAttributeInfo();
      MBeanAttributeInfo[] attrInfo = new MBeanAttributeInfo[3 + attrs.length];
      attrInfo[0] = new MBeanAttributeInfo("Name",
            "java.lang.String",
            "Return the service name",
            true,
            false,
            false);
      attrInfo[1] = new MBeanAttributeInfo("State",
            "int",
            "Return the service state",
            true,
            false,
            false);
      attrInfo[2] = new MBeanAttributeInfo("StateString",
               "java.lang.String",
               "Return the service's state as a String",
               true,
               false,
               false);
      System.arraycopy(attrs, 0, attrInfo, 3, attrs.length);
      MBeanParameterInfo[] jbossInternalLifecycleParms = new MBeanParameterInfo[1];
      jbossInternalLifecycleParms[0] = new MBeanParameterInfo("method", String.class.getName(), "The lifecycle method");
      MBeanOperationInfo[] ops = getInternalOperationInfo();
      MBeanOperationInfo[] opInfo = new MBeanOperationInfo[5 + ops.length];
      opInfo[0] = new MBeanOperationInfo("create",
                                "create service lifecycle operation",
                                noParams,
                                "void",
                                MBeanOperationInfo.ACTION);
      opInfo[1] = new MBeanOperationInfo("start",
                                "start service lifecycle operation",
                                noParams,
                                "void",
                                MBeanOperationInfo.ACTION);
      opInfo[2] = new MBeanOperationInfo("stop",
                                "stop service lifecycle operation",
                                noParams,
                                "void",
                                MBeanOperationInfo.ACTION);
      opInfo[3] = new MBeanOperationInfo("destroy",
                                "destroy service lifecycle operation",
                                noParams,
                                "void",
                                MBeanOperationInfo.ACTION);                                
      opInfo[4] = new MBeanOperationInfo(ServiceController.JBOSS_INTERNAL_LIFECYCLE,
                                "Internal lifecycle (for internal use)",
                                jbossInternalLifecycleParms,
                                "void",
                                MBeanOperationInfo.ACTION);                                
      System.arraycopy(ops, 0, opInfo, 5, ops.length);
      MBeanNotificationInfo[] notifyInfo = getInternalNotificationInfo();
      return new MBeanInfo(getClass().getName(), 
                           getInternalDescription(),
                           attrInfo, 
                           ctorInfo, 
                           opInfo, 
                           notifyInfo);
}

 protected Object internalInvoke(String actionName,
    Object[] params,
    String[] signature) throws ReflectionException, MBeanException 
{
      StringBuffer buffer = new StringBuffer();
      buffer.append(actionName);
      buffer.append('(");
      for (int i = 0; i <  signature.length; ++i)
      {
         buffer.append(signature[i]);
         if (i <  signature.length - 1)
            buffer.append(", ");
      }
      buffer.append(')");
      throw new MBeanException(new Exception("Operation not found " + buffer.toString()), "Operation not found " + actionName);
}

 public Object invoke(String actionName,
    Object[] params,
    String[] signature) throws ReflectionException, MBeanException 
{
      try 
      {
         if (ServiceController.JBOSS_INTERNAL_LIFECYCLE.equals(actionName))
         {
            jbossInternalLifecycle((String) params[0]); 
            return null;
         }
         if (params == null || params.length == 0) 
         {
            if ("create".equals(actionName)) 
            {
               create(); return null;
            }
            else if ("start".equals(actionName)) 
            {
               start(); return null;
            }
            else if ("stop".equals(actionName)) 
            {
               stop(); return null;
            }
            else if ("destroy".equals(actionName)) 
            {
               destroy(); return null;
            }
         }
      }
      catch (Exception e)
      {
         throw new MBeanException(e, "Exception in service lifecyle operation: " + actionName);
      }         
      // If I am here, it means that the invocation has not been handled locally
      //
      try
      {
         return internalInvoke (actionName, params, signature);
      }
      catch (Exception e)
      {
         throw new MBeanException(e, 
               "Exception invoking: " + actionName);
      }
}

 public  void setAttribute(Attribute attribute) throws InvalidAttributeValueException, ReflectionException, AttributeNotFoundException, MBeanException 
{
      setInternalAttribute (attribute);
}

 public AttributeList setAttributes(AttributeList attributes) 
{
      AttributeList list = new AttributeList();
      if (attributes == null)
         return list;
      for (int i = 0; i <  attributes.size(); ++i)
      {
         Attribute attribute = (Attribute) attributes.get(i);
         try
         {
            setAttribute(attribute);
            list.add(attribute);
         }
         catch (Throwable t)
         {
            log.debug("Error setting attribute " + attribute.getName(), t);
         }
      }
      return list;
}

 protected  void setInternalAttribute(Attribute attribute) throws InvalidAttributeValueException, ReflectionException, AttributeNotFoundException, MBeanException 
{
      throw new AttributeNotFoundException ("Attribute not found " + attribute);
}