package processes;

import java.beans.BeanDescriptor;
import java.beans.EventSetDescriptor;
import java.beans.IntrospectionException;
import java.beans.MethodDescriptor;
import java.beans.ParameterDescriptor;
import java.beans.PropertyDescriptor;
import java.beans.PropertyEditor;
import java.lang.reflect.Method;
import java.util.HashMap;

import org.apache.beehive.controls.api.ControlException;
import org.apache.beehive.controls.runtime.bean.BeanPersistenceDelegate;
import org.apache.beehive.controls.runtime.packaging.ControlEventSetDescriptor;

@SuppressWarnings("all")
public class MyTaskWorkerCtrlBeanBeanInfo
extends com.bea.control.TaskWorkerControlBeanBeanInfo
{
    static final Method _getTasksResponseMethod;
    static final Method _claimTasksOnBehalfOfMethod;
    static final Method _setTaskRequestMethod;
    static final Method _removeTaskPropertyMethod;
    static final Method _setTasksClaimDueDateMethod;
    static final Method _setTaskPropertyMethod;
    static final Method _completeTaskMethod;
    static final Method _suspendTasksMethod;
    static final Method _getTasksRequestMethod;
    static final Method _suspendTaskMethod;
    static final Method _setTasksPropertyMethod;
    static final Method _setTaskCompletionDueBusinessDateMethod;
    static final Method _setTasksPermissionsMethod;
    static final Method _getTasksInfoMethod;
    static final Method _returnTasksMethod;
    static final Method _getTaskInfoMethod;
    static final Method _setTasksOwnerMethod;
    static final Method _removeTasksPropertyMethod;
    static final Method _setTasksCommentMethod;
    static final Method _setTaskCompletionDueDateMethod;
    static final Method _setTaskOwnerMethod;
    static final Method _assignTaskToUserInGroupMethod;
    static final Method _claimTaskOnBehalfOfMethod;
    static final Method _setTaskPermissionsMethod;
    static final Method _assignTasksToUserInGroupMethod;
    static final Method _setTaskPriorityMethod;
    static final Method _assignTasksToUserMethod;
    static final Method _claimTaskMethod;
    static final Method _completeTasksMethod;
    static final Method _setTaskClaimDueDateMethod;
    static final Method _getTasksPropertyMethod;
    static final Method _assignTasksToUsersAndGroupsMethod;
    static final Method _setTasksRequestMethod;
    static final Method _setTasksCompletionDueDateMethod;
    static final Method _deleteTaskMethod;
    static final Method _setTaskCommentMethod;
    static final Method _setTaskCompletionDueBusinessDateSystemCalendarMethod;
    static final Method _setTaskResponseMethod;
    static final Method _getTaskInfoXMLMethod;
    static final Method _setTasksCompletionDueBusinessDateMethod;
    static final Method _stopTaskMethod;
    static final Method _createMethod;
    static final Method _setTaskClaimDueBusinessDateSystemCalendarMethod;
    static final Method _setTasksCompletionDueBusinessDateSystemCalendarMethod;
    static final Method _startTasksMethod;
    static final Method _assignTaskToUsersAndGroupsMethod;
    static final Method _setTasksClaimDueBusinessDateMethod;
    static final Method _getTaskRequestMethod;
    static final Method _setTasksResponseMethod;
    static final Method _returnTaskMethod;
    static final Method _getTaskPropertyMethod;
    static final Method _getTaskResponseMethod;
    static final Method _setTasksClaimDueBusinessDateSystemCalendarMethod;
    static final Method _stopTasksMethod;
    static final Method _abortTaskMethod;
    static final Method _createTaskByNameMethod;
    static final Method _startTaskMethod;
    static final Method _deleteTasksMethod;
    static final Method _setTasksPriorityMethod;
    static final Method _assignTaskToUserMethod;
    static final Method _abortTasksMethod;
    static final Method _setTaskClaimDueBusinessDateMethod;
    static final Method _claimTasksMethod;
    static final Method _resumeTaskMethod;
    static final Method _resumeTasksMethod;
    static final Method _getTasksInfoXMLMethod;
    
    //
    // This HashMap will map from a Method to the array of names for parameters of the
    // method.  This is necessary because parameter name data isn't carried along in the
    // class file, but if available can enable ease of use by referencing parameters by
    // the declared name (vs. by index).
    //
    // This map should be read-only after its initialization in the static block, hence
    // using a plain HashMap is thread-safe.
    //
    static HashMap<Method, String []> _methodParamMap = new HashMap<Method, String []>();
    
    static
    {
        
        
        try
        {
            _getTasksResponseMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTasksResponse", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_getTasksResponseMethod, new String [] { "taskIds" });
            _claimTasksOnBehalfOfMethod = processes.MyTaskWorkerCtrl.class.getMethod("claimTasksOnBehalfOf", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_claimTasksOnBehalfOfMethod, new String [] { "claimant", "taskIds" });
            _setTaskRequestMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskRequest", new Class [] {org.apache.xmlbeans.XmlObject.class, java.lang.String.class});
            _methodParamMap.put(_setTaskRequestMethod, new String [] { "xml", "taskId" });
            _removeTaskPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("removeTaskProperty", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_removeTaskPropertyMethod, new String [] { "name", "taskId" });
            _setTasksClaimDueDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksClaimDueDate", new Class [] {java.util.Date.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksClaimDueDateMethod, new String [] { "date", "taskIds" });
            _setTaskPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskProperty", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskPropertyMethod, new String [] { "name", "value", "taskId" });
            _completeTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("completeTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_completeTaskMethod, new String [] { "taskId" });
            _suspendTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("suspendTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_suspendTasksMethod, new String [] { "taskIds" });
            _getTasksRequestMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTasksRequest", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_getTasksRequestMethod, new String [] { "taskIds" });
            _suspendTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("suspendTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_suspendTaskMethod, new String [] { "taskId" });
            _setTasksPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksProperty", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksPropertyMethod, new String [] { "name", "value", "taskIds" });
            _setTaskCompletionDueBusinessDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskCompletionDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskCompletionDueBusinessDateMethod, new String [] { "duration", "calendarID", "taskId" });
            _setTasksPermissionsMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksPermissions", new Class [] {java.lang.Boolean.class, java.lang.Boolean.class, java.lang.Boolean.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksPermissionsMethod, new String [] { "aborted", "returned", "reassigned", "taskIds" });
            _getTasksInfoMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTasksInfo", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_getTasksInfoMethod, new String [] { "taskIds" });
            _returnTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("returnTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_returnTasksMethod, new String [] { "taskIds" });
            _getTaskInfoMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTaskInfo", new Class [] {java.lang.String.class});
            _methodParamMap.put(_getTaskInfoMethod, new String [] { "taskId" });
            _setTasksOwnerMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksOwner", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksOwnerMethod, new String [] { "owner", "taskIds" });
            _removeTasksPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("removeTasksProperty", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_removeTasksPropertyMethod, new String [] { "name", "taskIds" });
            _setTasksCommentMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksComment", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksCommentMethod, new String [] { "comment", "taskIds" });
            _setTaskCompletionDueDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskCompletionDueDate", new Class [] {java.util.Date.class, java.lang.String.class});
            _methodParamMap.put(_setTaskCompletionDueDateMethod, new String [] { "date", "taskId" });
            _setTaskOwnerMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskOwner", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskOwnerMethod, new String [] { "owner", "taskId" });
            _assignTaskToUserInGroupMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTaskToUserInGroup", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_assignTaskToUserInGroupMethod, new String [] { "group", "taskId" });
            _claimTaskOnBehalfOfMethod = processes.MyTaskWorkerCtrl.class.getMethod("claimTaskOnBehalfOf", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_claimTaskOnBehalfOfMethod, new String [] { "claimant", "taskId" });
            _setTaskPermissionsMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskPermissions", new Class [] {java.lang.Boolean.class, java.lang.Boolean.class, java.lang.Boolean.class, java.lang.String.class});
            _methodParamMap.put(_setTaskPermissionsMethod, new String [] { "aborted", "returned", "reassigned", "taskId" });
            _assignTasksToUserInGroupMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTasksToUserInGroup", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_assignTasksToUserInGroupMethod, new String [] { "group", "taskIds" });
            _setTaskPriorityMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskPriority", new Class [] {java.lang.Integer.class, java.lang.String.class});
            _methodParamMap.put(_setTaskPriorityMethod, new String [] { "priority", "taskId" });
            _assignTasksToUserMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTasksToUser", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_assignTasksToUserMethod, new String [] { "user", "taskIds" });
            _claimTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("claimTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_claimTaskMethod, new String [] { "taskId" });
            _completeTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("completeTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_completeTasksMethod, new String [] { "taskIds" });
            _setTaskClaimDueDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskClaimDueDate", new Class [] {java.util.Date.class, java.lang.String.class});
            _methodParamMap.put(_setTaskClaimDueDateMethod, new String [] { "date", "taskId" });
            _getTasksPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTasksProperty", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_getTasksPropertyMethod, new String [] { "name", "taskIds" });
            _assignTasksToUsersAndGroupsMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTasksToUsersAndGroups", new Class [] {java.lang.String[].class, java.lang.String[].class, java.lang.String[].class});
            _methodParamMap.put(_assignTasksToUsersAndGroupsMethod, new String [] { "users", "groups", "taskIds" });
            _setTasksRequestMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksRequest", new Class [] {org.apache.xmlbeans.XmlObject.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksRequestMethod, new String [] { "xml", "taskIds" });
            _setTasksCompletionDueDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksCompletionDueDate", new Class [] {java.util.Date.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksCompletionDueDateMethod, new String [] { "date", "taskIds" });
            _deleteTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("deleteTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_deleteTaskMethod, new String [] { "taskId" });
            _setTaskCommentMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskComment", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskCommentMethod, new String [] { "comment", "taskId" });
            _setTaskCompletionDueBusinessDateSystemCalendarMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskCompletionDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskCompletionDueBusinessDateSystemCalendarMethod, new String [] { "duration", "taskId" });
            _setTaskResponseMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskResponse", new Class [] {org.apache.xmlbeans.XmlObject.class, java.lang.String.class});
            _methodParamMap.put(_setTaskResponseMethod, new String [] { "xml", "taskId" });
            _getTaskInfoXMLMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTaskInfoXML", new Class [] {java.lang.String.class});
            _methodParamMap.put(_getTaskInfoXMLMethod, new String [] { "taskId" });
            _setTasksCompletionDueBusinessDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksCompletionDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksCompletionDueBusinessDateMethod, new String [] { "duration", "calendarID", "taskIds" });
            _stopTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("stopTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_stopTaskMethod, new String [] { "taskId" });
            _createMethod = processes.MyTaskWorkerCtrl.class.getMethod("create", new Class [] {});
            _methodParamMap.put(_createMethod, new String [] {  });
            _setTaskClaimDueBusinessDateSystemCalendarMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskClaimDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskClaimDueBusinessDateSystemCalendarMethod, new String [] { "duration", "taskId" });
            _setTasksCompletionDueBusinessDateSystemCalendarMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksCompletionDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksCompletionDueBusinessDateSystemCalendarMethod, new String [] { "duration", "taskIds" });
            _startTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("startTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_startTasksMethod, new String [] { "taskIds" });
            _assignTaskToUsersAndGroupsMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTaskToUsersAndGroups", new Class [] {java.lang.String[].class, java.lang.String[].class, java.lang.String.class});
            _methodParamMap.put(_assignTaskToUsersAndGroupsMethod, new String [] { "users", "groups", "taskId" });
            _setTasksClaimDueBusinessDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksClaimDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksClaimDueBusinessDateMethod, new String [] { "duration", "calendarID", "taskIds" });
            _getTaskRequestMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTaskRequest", new Class [] {java.lang.String.class});
            _methodParamMap.put(_getTaskRequestMethod, new String [] { "taskId" });
            _setTasksResponseMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksResponse", new Class [] {org.apache.xmlbeans.XmlObject.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksResponseMethod, new String [] { "xml", "taskIds" });
            _returnTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("returnTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_returnTaskMethod, new String [] { "taskId" });
            _getTaskPropertyMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTaskProperty", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_getTaskPropertyMethod, new String [] { "name", "taskId" });
            _getTaskResponseMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTaskResponse", new Class [] {java.lang.String.class});
            _methodParamMap.put(_getTaskResponseMethod, new String [] { "taskId" });
            _setTasksClaimDueBusinessDateSystemCalendarMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksClaimDueBusinessDateSystemCalendar", new Class [] {java.lang.String.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksClaimDueBusinessDateSystemCalendarMethod, new String [] { "duration", "taskIds" });
            _stopTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("stopTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_stopTasksMethod, new String [] { "taskIds" });
            _abortTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("abortTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_abortTaskMethod, new String [] { "taskId" });
            _createTaskByNameMethod = processes.MyTaskWorkerCtrl.class.getMethod("createTaskByName", new Class [] {java.lang.String.class});
            _methodParamMap.put(_createTaskByNameMethod, new String [] { "name" });
            _startTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("startTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_startTaskMethod, new String [] { "taskId" });
            _deleteTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("deleteTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_deleteTasksMethod, new String [] { "taskIds" });
            _setTasksPriorityMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTasksPriority", new Class [] {java.lang.Integer.class, java.lang.String[].class});
            _methodParamMap.put(_setTasksPriorityMethod, new String [] { "priority", "taskIds" });
            _assignTaskToUserMethod = processes.MyTaskWorkerCtrl.class.getMethod("assignTaskToUser", new Class [] {java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_assignTaskToUserMethod, new String [] { "user", "taskId" });
            _abortTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("abortTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_abortTasksMethod, new String [] { "taskIds" });
            _setTaskClaimDueBusinessDateMethod = processes.MyTaskWorkerCtrl.class.getMethod("setTaskClaimDueBusinessDate", new Class [] {java.lang.String.class, java.lang.String.class, java.lang.String.class});
            _methodParamMap.put(_setTaskClaimDueBusinessDateMethod, new String [] { "duration", "calendarID", "taskId" });
            _claimTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("claimTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_claimTasksMethod, new String [] { "taskIds" });
            _resumeTaskMethod = processes.MyTaskWorkerCtrl.class.getMethod("resumeTask", new Class [] {java.lang.String.class});
            _methodParamMap.put(_resumeTaskMethod, new String [] { "taskId" });
            _resumeTasksMethod = processes.MyTaskWorkerCtrl.class.getMethod("resumeTasks", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_resumeTasksMethod, new String [] { "taskIds" });
            _getTasksInfoXMLMethod = processes.MyTaskWorkerCtrl.class.getMethod("getTasksInfoXML", new Class [] {java.lang.String[].class});
            _methodParamMap.put(_getTasksInfoXMLMethod, new String [] { "taskIds" });
        }
        catch (NoSuchMethodException __bc_nsme)
        {
            throw new ExceptionInInitializerError(__bc_nsme);
        }
    }
    
    /**
    * Default null-arg constructor used to create a new BeanInfo instance
    */
    public MyTaskWorkerCtrlBeanBeanInfo()
    {
        super(processes.MyTaskWorkerCtrlBean.class);
    }
    
    /**
    * Protected constructor used if this BeanInfo class is extended.
    */
    protected MyTaskWorkerCtrlBeanBeanInfo(Class beanClass)
    {
        super(beanClass);
    }
    
    // java.beans.BeanInfo.getBeanDescriptor
    public BeanDescriptor getBeanDescriptor()
    {
        BeanDescriptor bd = new BeanDescriptor(processes.MyTaskWorkerCtrlBean.class);
        bd.setName( "MyTaskWorkerCtrlBean" );
        bd.setDisplayName( "MyTaskWorkerCtrlBean" );
        
        //
        // The org.apache.beehive.controls.runtime.bean.BeanPersistenceDelegate class
        // implements the XMLDecode delegation model for all Control JavaBean types. It
        // provides optimized XML persistance based upon the Control runtime architecture.
        // The 'persistenceDelegate' attribute of a BeanDescriptor is used by XMLEncoder to
        // locate a delegate for a particular JavaBean type.
        //
        bd.setValue("persistenceDelegate", new BeanPersistenceDelegate());
        
        return bd;
    }
    
    /**
    * Stores MethodDescriptor descriptors for this bean and its superclasses into
    * an array, starting at the specified index
    */
    protected void initMethodDescriptors(MethodDescriptor [] methodDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        String [] __bc_paramNames;
        ParameterDescriptor [] __bc_paramDescriptors;
        MethodDescriptor md;
        
        //
        // Declare MethodDescriptor for getTasksResponse(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_getTasksResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTasksResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for claimTasksOnBehalfOf(claimant, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_claimTasksOnBehalfOfMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_claimTasksOnBehalfOfMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskRequest(xml, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for removeTaskProperty(name, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_removeTaskPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_removeTaskPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksClaimDueDate(date, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksClaimDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksClaimDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskProperty(name, value, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for completeTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_completeTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_completeTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for suspendTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_suspendTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_suspendTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTasksRequest(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_getTasksRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTasksRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for suspendTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_suspendTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_suspendTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksProperty(name, value, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskCompletionDueBusinessDate(duration, calendarID, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskCompletionDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskCompletionDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksPermissions(aborted, returned, reassigned, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksPermissionsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksPermissionsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTasksInfo(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_getTasksInfoMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTasksInfoMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for returnTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_returnTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_returnTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTaskInfo(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_getTaskInfoMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTaskInfoMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksOwner(owner, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksOwnerMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksOwnerMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for removeTasksProperty(name, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_removeTasksPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_removeTasksPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksComment(comment, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksCommentMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksCommentMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskCompletionDueDate(date, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskCompletionDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskCompletionDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskOwner(owner, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskOwnerMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskOwnerMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUserInGroup(group, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUserInGroupMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUserInGroupMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for claimTaskOnBehalfOf(claimant, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_claimTaskOnBehalfOfMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_claimTaskOnBehalfOfMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskPermissions(aborted, returned, reassigned, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskPermissionsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskPermissionsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTasksToUserInGroup(group, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_assignTasksToUserInGroupMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTasksToUserInGroupMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskPriority(priority, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskPriorityMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskPriorityMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTasksToUser(user, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_assignTasksToUserMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTasksToUserMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for claimTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_claimTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_claimTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for completeTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_completeTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_completeTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskClaimDueDate(date, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskClaimDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskClaimDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTasksProperty(name, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_getTasksPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTasksPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTasksToUsersAndGroups(users, groups, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_assignTasksToUsersAndGroupsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTasksToUsersAndGroupsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksRequest(xml, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksCompletionDueDate(date, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksCompletionDueDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksCompletionDueDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for deleteTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_deleteTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_deleteTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskComment(comment, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskCommentMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskCommentMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskCompletionDueBusinessDateSystemCalendar(duration, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskCompletionDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskCompletionDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskResponse(xml, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTaskInfoXML(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_getTaskInfoXMLMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTaskInfoXMLMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksCompletionDueBusinessDate(duration, calendarID, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksCompletionDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksCompletionDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for stopTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_stopTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_stopTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for create()
        //
        __bc_paramNames = _methodParamMap.get(_createMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_createMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskClaimDueBusinessDateSystemCalendar(duration, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskClaimDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskClaimDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksCompletionDueBusinessDateSystemCalendar(duration, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksCompletionDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksCompletionDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for startTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_startTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_startTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUsersAndGroups(users, groups, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUsersAndGroupsMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUsersAndGroupsMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksClaimDueBusinessDate(duration, calendarID, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksClaimDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksClaimDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTaskRequest(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_getTaskRequestMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTaskRequestMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksResponse(xml, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for returnTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_returnTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_returnTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTaskProperty(name, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_getTaskPropertyMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTaskPropertyMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTaskResponse(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_getTaskResponseMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTaskResponseMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksClaimDueBusinessDateSystemCalendar(duration, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksClaimDueBusinessDateSystemCalendarMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksClaimDueBusinessDateSystemCalendarMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for stopTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_stopTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_stopTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for abortTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_abortTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_abortTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for createTaskByName(name)
        //
        __bc_paramNames = _methodParamMap.get(_createTaskByNameMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_createTaskByNameMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for startTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_startTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_startTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for deleteTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_deleteTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_deleteTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTasksPriority(priority, taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_setTasksPriorityMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTasksPriorityMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for assignTaskToUser(user, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_assignTaskToUserMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_assignTaskToUserMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for abortTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_abortTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_abortTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for setTaskClaimDueBusinessDate(duration, calendarID, taskId)
        //
        __bc_paramNames = _methodParamMap.get(_setTaskClaimDueBusinessDateMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_setTaskClaimDueBusinessDateMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for claimTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_claimTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_claimTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for resumeTask(taskId)
        //
        __bc_paramNames = _methodParamMap.get(_resumeTaskMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_resumeTaskMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for resumeTasks(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_resumeTasksMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_resumeTasksMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        //
        // Declare MethodDescriptor for getTasksInfoXML(taskIds)
        //
        __bc_paramNames = _methodParamMap.get(_getTasksInfoXMLMethod);
        __bc_paramDescriptors = new ParameterDescriptor[__bc_paramNames.length];
        for (int j = 0; j < __bc_paramNames.length; j++)
        {
            __bc_paramDescriptors[j] = new ParameterDescriptor();
            __bc_paramDescriptors[j].setName(__bc_paramNames[j]);
            __bc_paramDescriptors[j].setDisplayName(__bc_paramNames[j]);
        }
        md = new MethodDescriptor(_getTasksInfoXMLMethod, __bc_paramDescriptors);
        methodDescriptors[index++] = md;
        
        
        //
        // Add method descriptors from parent BeanInfo
        //
        super.initMethodDescriptors(methodDescriptors, index);
    }
    
    public MethodDescriptor [] getMethodDescriptors()
    {
        MethodDescriptor [] __bc_methodDescriptors = new MethodDescriptor[71];
        try
        {
            initMethodDescriptors(__bc_methodDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create MethodDescriptor", __bc_ie);
        }
        return __bc_methodDescriptors;
    }
    
    /**
    * Stores PropertyDescriptor descriptors for this bean and its superclasses into
    * an array, starting at the specified index
    */
    protected void initPropertyDescriptors(PropertyDescriptor [] propDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        PropertyDescriptor pd;
        
        pd = new PropertyDescriptor( "controlImplementation" , processes.MyTaskWorkerCtrlBean.class, "getControlImplementation", "setControlImplementation");
        propDescriptors[index++] = pd;
        
        
        //
        // Add property descriptors from parent BeanInfo
        //
        super.initPropertyDescriptors(propDescriptors, index);
    }
    
    // java.beans.BeanInfo.getPropertyDescriptors
    public PropertyDescriptor [] getPropertyDescriptors()
    {
        PropertyDescriptor [] __bc_propDescriptors = new PropertyDescriptor[4];
        try
        {
            initPropertyDescriptors(__bc_propDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create PropertyDescriptor", __bc_ie);
        }
        return __bc_propDescriptors;
    }
    
    
    protected void initEventSetDescriptors(EventSetDescriptor [] eventSetDescriptors, int index)
    throws java.beans.IntrospectionException
    {
        
        
        //
        // Add event set descriptors from parent BeanInfo
        //
        super.initEventSetDescriptors(eventSetDescriptors, index);
    }
    
    // java.beans.BeanInfo.getEventSetDescriptors
    public EventSetDescriptor [] getEventSetDescriptors()
    {
        EventSetDescriptor [] __bc_eventSetDescriptors = new EventSetDescriptor[0];
        try
        {
            initEventSetDescriptors(__bc_eventSetDescriptors, 0);
        }
        catch (java.beans.IntrospectionException __bc_ie)
        {
            throw new ControlException("Unable to create EventSetDescriptor", __bc_ie);
        }
        return __bc_eventSetDescriptors;
    }
}
