
package processes;

import java.beans.*;

import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.HashMap;
import java.util.Map;

import org.apache.beehive.controls.api.bean.*;
import org.apache.beehive.controls.api.context.ControlBeanContext;
import org.apache.beehive.controls.api.properties.PropertyKey;
import org.apache.beehive.controls.api.properties.PropertyMap;
import org.apache.beehive.controls.api.versioning.*;

@SuppressWarnings("all")
public class MyTaskWorkerCtrlBean
extends com.bea.control.TaskWorkerControlBean
implements processes.MyTaskWorkerCtrl
{
    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);
        }
    }
    
    
    
    static
    {
        
    }
    
    
    
    /**
    * This is the public constructor for the class.  A client-defined control ID may
    * be provided.  This ID must be unique within the nesting ControlBeanContext.
    * @param context The containing ControlBeanContext
    * @param id The control identifier (or null to autogenerate a unique value)
    * @param props The initialization Properties for the new instance (or null for defaults)
    */
    public MyTaskWorkerCtrlBean(ControlBeanContext context, String id, PropertyMap props)
    {
        this(context, id, props, processes.MyTaskWorkerCtrl.class);
    }
    
    /**
    * This is the public null-arg constructor for this ControlBean.  If a control id
    * is not provided, a unique value will be auto-generated.
    */
    public MyTaskWorkerCtrlBean()
    {
        this(null, null, null);
    }
    
    /**
    * This is the protected version that is used by any ControlBean subclass
    */
    protected MyTaskWorkerCtrlBean(ControlBeanContext context, String id, PropertyMap props, Class controlClass)
    {
        super(context, id, props, controlClass);
        
    }
    
    
    /**
    * Returns an array of parameter names for the request method, or null if no parameter
    * data is available.
    */
    protected String [] getParameterNames(Method m)
    {
        // Check the local map for operations on this bean type
        if (_methodParamMap.containsKey(m))
        {
            return _methodParamMap.get(m);
        }
        
        // Delegate up if not found locally
        return super.getParameterNames(m);
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTasksResponse
    */
    public  org.apache.xmlbeans.XmlObject[] getTasksResponse(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        org.apache.xmlbeans.XmlObject[] __bc_retval = null;
        
        try
        {
            preInvoke(_getTasksResponseMethod, __bc_argArray);
            
            __bc_retval =
            (org.apache.xmlbeans.XmlObject[])
            __bc_target.invoke(_getTasksResponseMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTasksResponseMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.claimTasksOnBehalfOf
    */
    public  void claimTasksOnBehalfOf(java.lang.String claimant, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { claimant, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_claimTasksOnBehalfOfMethod, __bc_argArray);
            
            __bc_target.invoke(_claimTasksOnBehalfOfMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_claimTasksOnBehalfOfMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskRequest
    */
    public  void setTaskRequest(org.apache.xmlbeans.XmlObject xml, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { xml, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskRequestMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskRequestMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskRequestMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.removeTaskProperty
    */
    public  void removeTaskProperty(java.lang.String name, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { name, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_removeTaskPropertyMethod, __bc_argArray);
            
            __bc_target.invoke(_removeTaskPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_removeTaskPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksClaimDueDate
    */
    public  void setTasksClaimDueDate(java.util.Date date, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { date, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksClaimDueDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksClaimDueDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksClaimDueDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskProperty
    */
    public  void setTaskProperty(java.lang.String name, java.lang.String value, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { name, value, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskPropertyMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.completeTask
    */
    public  void completeTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_completeTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_completeTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_completeTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.suspendTasks
    */
    public  void suspendTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_suspendTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_suspendTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_suspendTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTasksRequest
    */
    public  org.apache.xmlbeans.XmlObject[] getTasksRequest(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        org.apache.xmlbeans.XmlObject[] __bc_retval = null;
        
        try
        {
            preInvoke(_getTasksRequestMethod, __bc_argArray);
            
            __bc_retval =
            (org.apache.xmlbeans.XmlObject[])
            __bc_target.invoke(_getTasksRequestMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTasksRequestMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.suspendTask
    */
    public  void suspendTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_suspendTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_suspendTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_suspendTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksProperty
    */
    public  void setTasksProperty(java.lang.String name, java.lang.String value, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { name, value, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksPropertyMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskCompletionDueBusinessDate
    */
    public  void setTaskCompletionDueBusinessDate(java.lang.String duration, java.lang.String calendarID, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { duration, calendarID, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskCompletionDueBusinessDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskCompletionDueBusinessDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskCompletionDueBusinessDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksPermissions
    */
    public  void setTasksPermissions(java.lang.Boolean aborted, java.lang.Boolean returned, java.lang.Boolean reassigned, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { aborted, returned, reassigned, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksPermissionsMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksPermissionsMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksPermissionsMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTasksInfo
    */
    public  com.bea.wli.worklist.api.TaskInfo[] getTasksInfo(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        com.bea.wli.worklist.api.TaskInfo[] __bc_retval = null;
        
        try
        {
            preInvoke(_getTasksInfoMethod, __bc_argArray);
            
            __bc_retval =
            (com.bea.wli.worklist.api.TaskInfo[])
            __bc_target.invoke(_getTasksInfoMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTasksInfoMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.returnTasks
    */
    public  void returnTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_returnTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_returnTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_returnTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTaskInfo
    */
    public  com.bea.wli.worklist.api.TaskInfo getTaskInfo(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        com.bea.wli.worklist.api.TaskInfo __bc_retval = null;
        
        try
        {
            preInvoke(_getTaskInfoMethod, __bc_argArray);
            
            __bc_retval =
            (com.bea.wli.worklist.api.TaskInfo)
            __bc_target.invoke(_getTaskInfoMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTaskInfoMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksOwner
    */
    public  void setTasksOwner(java.lang.String owner, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { owner, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksOwnerMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksOwnerMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksOwnerMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.removeTasksProperty
    */
    public  void removeTasksProperty(java.lang.String name, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { name, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_removeTasksPropertyMethod, __bc_argArray);
            
            __bc_target.invoke(_removeTasksPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_removeTasksPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksComment
    */
    public  void setTasksComment(java.lang.String comment, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { comment, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksCommentMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksCommentMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksCommentMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskCompletionDueDate
    */
    public  void setTaskCompletionDueDate(java.util.Date date, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { date, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskCompletionDueDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskCompletionDueDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskCompletionDueDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskOwner
    */
    public  void setTaskOwner(java.lang.String owner, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { owner, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskOwnerMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskOwnerMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskOwnerMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTaskToUserInGroup
    */
    public  void assignTaskToUserInGroup(java.lang.String group, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { group, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTaskToUserInGroupMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTaskToUserInGroupMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTaskToUserInGroupMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.claimTaskOnBehalfOf
    */
    public  void claimTaskOnBehalfOf(java.lang.String claimant, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { claimant, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_claimTaskOnBehalfOfMethod, __bc_argArray);
            
            __bc_target.invoke(_claimTaskOnBehalfOfMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_claimTaskOnBehalfOfMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskPermissions
    */
    public  void setTaskPermissions(java.lang.Boolean aborted, java.lang.Boolean returned, java.lang.Boolean reassigned, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { aborted, returned, reassigned, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskPermissionsMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskPermissionsMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskPermissionsMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTasksToUserInGroup
    */
    public  void assignTasksToUserInGroup(java.lang.String group, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { group, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTasksToUserInGroupMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTasksToUserInGroupMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTasksToUserInGroupMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskPriority
    */
    public  void setTaskPriority(java.lang.Integer priority, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { priority, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskPriorityMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskPriorityMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskPriorityMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTasksToUser
    */
    public  void assignTasksToUser(java.lang.String user, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { user, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTasksToUserMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTasksToUserMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTasksToUserMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.claimTask
    */
    public  void claimTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_claimTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_claimTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_claimTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.completeTasks
    */
    public  void completeTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_completeTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_completeTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_completeTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskClaimDueDate
    */
    public  void setTaskClaimDueDate(java.util.Date date, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { date, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskClaimDueDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskClaimDueDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskClaimDueDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTasksProperty
    */
    public  java.lang.String[] getTasksProperty(java.lang.String name, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { name, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        java.lang.String[] __bc_retval = null;
        
        try
        {
            preInvoke(_getTasksPropertyMethod, __bc_argArray);
            
            __bc_retval =
            (java.lang.String[])
            __bc_target.invoke(_getTasksPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTasksPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTasksToUsersAndGroups
    */
    public  void assignTasksToUsersAndGroups(java.lang.String[] users, java.lang.String[] groups, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { users, groups, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTasksToUsersAndGroupsMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTasksToUsersAndGroupsMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTasksToUsersAndGroupsMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksRequest
    */
    public  void setTasksRequest(org.apache.xmlbeans.XmlObject xml, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { xml, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksRequestMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksRequestMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksRequestMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksCompletionDueDate
    */
    public  void setTasksCompletionDueDate(java.util.Date date, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { date, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksCompletionDueDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksCompletionDueDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksCompletionDueDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.deleteTask
    */
    public  void deleteTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_deleteTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_deleteTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_deleteTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskComment
    */
    public  void setTaskComment(java.lang.String comment, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { comment, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskCommentMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskCommentMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskCommentMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskCompletionDueBusinessDateSystemCalendar
    */
    public  void setTaskCompletionDueBusinessDateSystemCalendar(java.lang.String duration, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { duration, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskResponse
    */
    public  void setTaskResponse(org.apache.xmlbeans.XmlObject xml, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { xml, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskResponseMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskResponseMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskResponseMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTaskInfoXML
    */
    public  com.bea.wli.worklist.xml.TaskInfoXMLDocument getTaskInfoXML(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        com.bea.wli.worklist.xml.TaskInfoXMLDocument __bc_retval = null;
        
        try
        {
            preInvoke(_getTaskInfoXMLMethod, __bc_argArray);
            
            __bc_retval =
            (com.bea.wli.worklist.xml.TaskInfoXMLDocument)
            __bc_target.invoke(_getTaskInfoXMLMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTaskInfoXMLMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksCompletionDueBusinessDate
    */
    public  void setTasksCompletionDueBusinessDate(java.lang.String duration, java.lang.String calendarID, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { duration, calendarID, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksCompletionDueBusinessDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksCompletionDueBusinessDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksCompletionDueBusinessDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.stopTask
    */
    public  void stopTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_stopTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_stopTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_stopTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.create
    */
    public  processes.MyTaskWorkerCtrl create() 
    {
        Object [] __bc_argArray = new Object[] {  };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        processes.MyTaskWorkerCtrl __bc_retval = null;
        
        try
        {
            preInvoke(_createMethod, __bc_argArray);
            
            __bc_retval =
            (processes.MyTaskWorkerCtrl)
            __bc_target.invoke(_createMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_createMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskClaimDueBusinessDateSystemCalendar
    */
    public  void setTaskClaimDueBusinessDateSystemCalendar(java.lang.String duration, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { duration, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskClaimDueBusinessDateSystemCalendarMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskClaimDueBusinessDateSystemCalendarMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskClaimDueBusinessDateSystemCalendarMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksCompletionDueBusinessDateSystemCalendar
    */
    public  void setTasksCompletionDueBusinessDateSystemCalendar(java.lang.String duration, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { duration, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksCompletionDueBusinessDateSystemCalendarMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.startTasks
    */
    public  void startTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_startTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_startTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_startTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTaskToUsersAndGroups
    */
    public  void assignTaskToUsersAndGroups(java.lang.String[] users, java.lang.String[] groups, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { users, groups, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTaskToUsersAndGroupsMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTaskToUsersAndGroupsMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTaskToUsersAndGroupsMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksClaimDueBusinessDate
    */
    public  void setTasksClaimDueBusinessDate(java.lang.String duration, java.lang.String calendarID, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { duration, calendarID, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksClaimDueBusinessDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksClaimDueBusinessDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksClaimDueBusinessDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTaskRequest
    */
    public  org.apache.xmlbeans.XmlObject getTaskRequest(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        org.apache.xmlbeans.XmlObject __bc_retval = null;
        
        try
        {
            preInvoke(_getTaskRequestMethod, __bc_argArray);
            
            __bc_retval =
            (org.apache.xmlbeans.XmlObject)
            __bc_target.invoke(_getTaskRequestMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTaskRequestMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksResponse
    */
    public  void setTasksResponse(org.apache.xmlbeans.XmlObject xml, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { xml, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksResponseMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksResponseMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksResponseMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.returnTask
    */
    public  void returnTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_returnTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_returnTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_returnTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTaskProperty
    */
    public  java.lang.String getTaskProperty(java.lang.String name, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { name, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        java.lang.String __bc_retval = null;
        
        try
        {
            preInvoke(_getTaskPropertyMethod, __bc_argArray);
            
            __bc_retval =
            (java.lang.String)
            __bc_target.invoke(_getTaskPropertyMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTaskPropertyMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTaskResponse
    */
    public  org.apache.xmlbeans.XmlObject getTaskResponse(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        org.apache.xmlbeans.XmlObject __bc_retval = null;
        
        try
        {
            preInvoke(_getTaskResponseMethod, __bc_argArray);
            
            __bc_retval =
            (org.apache.xmlbeans.XmlObject)
            __bc_target.invoke(_getTaskResponseMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTaskResponseMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksClaimDueBusinessDateSystemCalendar
    */
    public  void setTasksClaimDueBusinessDateSystemCalendar(java.lang.String duration, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { duration, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksClaimDueBusinessDateSystemCalendarMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksClaimDueBusinessDateSystemCalendarMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksClaimDueBusinessDateSystemCalendarMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.stopTasks
    */
    public  void stopTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_stopTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_stopTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_stopTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.abortTask
    */
    public  void abortTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_abortTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_abortTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_abortTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.createTaskByName
    */
    public  java.lang.String createTaskByName(java.lang.String name) 
    {
        Object [] __bc_argArray = new Object[] { name };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        java.lang.String __bc_retval = null;
        
        try
        {
            preInvoke(_createTaskByNameMethod, __bc_argArray);
            
            __bc_retval =
            (java.lang.String)
            __bc_target.invoke(_createTaskByNameMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_createTaskByNameMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.startTask
    */
    public  void startTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_startTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_startTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_startTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.deleteTasks
    */
    public  void deleteTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_deleteTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_deleteTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_deleteTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTasksPriority
    */
    public  void setTasksPriority(java.lang.Integer priority, java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { priority, taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTasksPriorityMethod, __bc_argArray);
            
            __bc_target.invoke(_setTasksPriorityMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTasksPriorityMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.assignTaskToUser
    */
    public  void assignTaskToUser(java.lang.String user, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { user, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_assignTaskToUserMethod, __bc_argArray);
            
            __bc_target.invoke(_assignTaskToUserMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_assignTaskToUserMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.abortTasks
    */
    public  void abortTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_abortTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_abortTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_abortTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.setTaskClaimDueBusinessDate
    */
    public  void setTaskClaimDueBusinessDate(java.lang.String duration, java.lang.String calendarID, java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { duration, calendarID, taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_setTaskClaimDueBusinessDateMethod, __bc_argArray);
            
            __bc_target.invoke(_setTaskClaimDueBusinessDateMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_setTaskClaimDueBusinessDateMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.claimTasks
    */
    public  void claimTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_claimTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_claimTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_claimTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.resumeTask
    */
    public  void resumeTask(java.lang.String taskId) 
    {
        Object [] __bc_argArray = new Object[] { taskId };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_resumeTaskMethod, __bc_argArray);
            
            __bc_target.invoke(_resumeTaskMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_resumeTaskMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.resumeTasks
    */
    public  void resumeTasks(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        
        try
        {
            preInvoke(_resumeTasksMethod, __bc_argArray);
            
            __bc_target.invoke(_resumeTasksMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = null;
            postInvoke(_resumeTasksMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
    }
    
    /**
    * Implements processes.MyTaskWorkerCtrl.getTasksInfoXML
    */
    public  com.bea.wli.worklist.xml.TaskInfoXMLDocument[] getTasksInfoXML(java.lang.String[] taskIds) 
    {
        Object [] __bc_argArray = new Object[] { taskIds };
        Throwable __bc_thrown = null;
        Extensible __bc_target = (Extensible)ensureControl();
        com.bea.wli.worklist.xml.TaskInfoXMLDocument[] __bc_retval = null;
        
        try
        {
            preInvoke(_getTasksInfoXMLMethod, __bc_argArray);
            
            __bc_retval =
            (com.bea.wli.worklist.xml.TaskInfoXMLDocument[])
            __bc_target.invoke(_getTasksInfoXMLMethod, __bc_argArray)
            ;
        }
        catch (Throwable __bc_t)
        {
            //
            // All exceptions are caught here, so postInvoke processing has visibility into
            // the exception status.  Errors, RuntimExceptions, or declared checked exceptions will
            // be rethrown.
            //
            __bc_thrown = __bc_t;
            
            if (__bc_t instanceof Error) throw (Error)__bc_t;
            else if (__bc_t instanceof RuntimeException) throw (RuntimeException)__bc_t;
            
            throw new UndeclaredThrowableException(__bc_t);
        }
        finally
        {
            Object __bc_rv = __bc_retval;
            postInvoke(_getTasksInfoXMLMethod, __bc_argArray, __bc_rv, __bc_thrown);
        }
        return __bc_retval;
    }
    
    
    /**
    * A PropertyKey that can be used to access the controlImplementation property of the
    * BaseProperties PropertySet
    */
    public static final PropertyKey ControlImplementationKey = new PropertyKey(org.apache.beehive.controls.api.properties.BaseProperties.class, "controlImplementation");
    
    public synchronized void setControlImplementation(java.lang.String value)
    {
        
        setControlProperty(ControlImplementationKey, value);
    }
    
    public java.lang.String getControlImplementation()
    {
        return (java.lang.String)getControlProperty(ControlImplementationKey);
    }
    
    
    
    
    
    /**
    * The _annotCache maintains a lookup cache from AnnotatedElements to an associated
    * PropertyMap.  This enables these maps to be shared across multiple beans.
    */
    static private HashMap __bc_annotCache = new HashMap();
    
    protected Map getPropertyMapCache() { return __bc_annotCache; }
    
    private static final long serialVersionUID = 1L;
}
