'Adds a collection of tasks to the specified job.
Note that each task must have a unique ID. The Batch service may not
return the results for each task in the same order the tasks were
submitted in this request. If the server times out or the connection is
closed during the request, the request may have been partially or fully
processed, or not at all. In such cases, the user should re-issue the
request. Note that it is up to the user to correctly handle failures
when re-issuing a request. For example, you should use the same task
ids during a retry so that if the prior operation succeeded, the retry
will not create extra tasks unexpectedly.
:param job_id: The ID of the job to which the task collection is to be
added.
:type job_id: str
:param value: The collection of tasks to add.
:type value: list of :class:`TaskAddParameter
<azure.batch.models.TaskAddParameter>`
:param task_add_collection_options: Additional parameters for the
operation
:type task_add_collection_options: :class:`TaskAddCollectionOptions
<azure.batch.models.TaskAddCollectionOptions>`
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: :class:`TaskAddCollectionResult
<azure.batch.models.TaskAddCollectionResult>`
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`BatchErrorException<azure.batch.models.BatchErrorException>`'

def add_collection(self, job_id, value, task_add_collection_options=None, custom_headers=None, raw=False, **operation_config):

    timeout = None
    if (task_add_collection_options is not None):
        timeout = task_add_collection_options.timeout
    client_request_id = None
    if (task_add_collection_options is not None):
        client_request_id = task_add_collection_options.client_request_id
    return_client_request_id = None
    if (task_add_collection_options is not None):
        return_client_request_id = task_add_collection_options.return_client_request_id
    ocp_date = None
    if (task_add_collection_options is not None):
        ocp_date = task_add_collection_options.ocp_date
    task_collection = models.TaskAddCollectionParameter(value=value)
    url = '/jobs/{jobId}/addtaskcollection'
    path_format_arguments = {'jobId': self._serialize.url('job_id', job_id, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('self.api_version', self.api_version, 'str')
    if (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'int')
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    odata=minimalmetadata;    charset=utf-8'
    if self.config.generate_client_request_id:
        header_parameters['client-request-id'] = str(uuid.uuid1())
    if custom_headers:
        header_parameters.update(custom_headers)
    if (self.config.accept_language is not None):
        header_parameters['accept-language'] = self._serialize.header('self.config.accept_language', self.config.accept_language, 'str')
    if (client_request_id is not None):
        header_parameters['client-request-id'] = self._serialize.header('client_request_id', client_request_id, 'str')
    if (return_client_request_id is not None):
        header_parameters['return-client-request-id'] = self._serialize.header('return_client_request_id', return_client_request_id, 'bool')
    if (ocp_date is not None):
        header_parameters['ocp-date'] = self._serialize.header('ocp_date', ocp_date, 'rfc-1123')
    body_content = self._serialize.body(task_collection, 'TaskAddCollectionParameter')
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, body_content, **operation_config)
    if (response.status_code not in [200]):
        raise models.BatchErrorException(self._deserialize, response)
    deserialized = None
    header_dict = {}
    if (response.status_code == 200):
        deserialized = self._deserialize('TaskAddCollectionResult', response)
        header_dict = {'client-request-id': 'str', 'request-id': 'str'}
    if raw:
        client_raw_response = ClientRawResponse(deserialized, response)
        client_raw_response.add_headers(header_dict)
        return client_raw_response
    return deserialized
