Add a recipient for the message

@param recipients
one or several recipient to add
@return this instance for fluent chaining
970293
@Override
	public Sms recipient(Recipient... recipients) {
		this.recipients.addAll(Arrays.asList(recipients));
		return this;
	}
706323
public function addVariablesForRecipient(string $recipient, array $variables): self
    {
        $this->recipientVariables[$recipient] = $variables;

        return $this;
    }
497636
public Message createTextMessage(String text, String sender, String recipients) throws JMSException {
        return decorateMessage(getSession().createTextMessage(text), sender, recipients);
    }
1204044
static public Message createBinarySMS(String originator, String header, String body, String recipients) {
        Message msg = new Message(originator, body, recipients);
        final Map<String, Object> binarySMS = new LinkedHashMap<String, Object>(4);
        binarySMS.put("udh", header);
        msg.setTypeDetails(binarySMS);
        msg.setType(MsgType.binary);
        return msg;
    }
353614
public void addCc(final Address internetAddress) throws MessagingException
	{
		super.addRecipient(javax.mail.Message.RecipientType.CC, internetAddress);
	}
662348
def add_user(self, recipient_email):
        
        self.import_key(emailid=recipient_email)
        emailid_list = self.list_user_emails()
        self.y = self.decrypt()
        emailid_list.append(recipient_email)
        self.encrypt(emailid_list=emailid_list)
1123431
@Override
    public SendObjectMessage recipients(Collection<? extends ApiBaseUser> recipients) {
        for(ApiBaseUser user : recipients) {
            this.recipients.add(user.getName());
        }
        return this;
    }
715080
def add_recipients(self, id, recipients):
        
        path = {}
        data = {}
        params = {}

        # REQUIRED - PATH - id
        """ID"""
        path["id"] = id

        # REQUIRED - recipients
        """An array of recipient ids. These may be user ids or course/group ids
        prefixed with "course_" or "group_" respectively, e.g.
        recipients[]=1&recipients[]=2&recipients[]=course_3"""
        data["recipients"] = recipients

        self.logger.debug("POST /api/v1/conversations/{id}/add_recipients with query params: {params} and form data: {data}".format(params=params, data=data, **path))
        return self.generic_request("POST", "/api/v1/conversations/{id}/add_recipients".format(**path), data=data, params=params, no_data=True)
833269
public boolean publish(String channel, Message message, Recipient... recipients) {
        boolean result = false;
        prepare(channel, message, recipients);

        for (IMessageProducer producer : producers) {
            result |= producer.publish(channel, message);
        }

        return result;
    }
1168596
public Sms to(String... numbers) {
		for (String num : numbers) {
			to(new Recipient(num));
		}
		return this;
	}
67384
public void distribute(CmsObject cms, List<I_CmsNewsletterRecipient> recipients, I_CmsNewsletter newsletter) {

        Iterator<I_CmsNewsletterRecipient> recipientsIterator = recipients.iterator();
        while (recipientsIterator.hasNext()) {
            I_CmsNewsletterRecipient recipient = recipientsIterator.next();
            try {
                Email mail = newsletter.getEmail(cms, recipient);
                mail.addTo(recipient.getEmail(), recipient.getFullName());
                mail.send();
            } catch (Exception e) {
                LOG.error(e.getMessage(), e);
            }
        }
    }
226216
async def _send_recipients(
        self,
        recipients: List[str],
        options: List[str] = None,
        timeout: DefaultNumType = _default,
    ) -> RecipientErrorsType:
        
        recipient_errors = []
        for address in recipients:
            try:
                await self.rcpt(address, timeout=timeout)
            except SMTPRecipientRefused as exc:
                recipient_errors.append(exc)

        if len(recipient_errors) == len(recipients):
            raise SMTPRecipientsRefused(recipient_errors)

        formatted_errors = {
            err.recipient: SMTPResponse(err.code, err.message)
            for err in recipient_errors
        }

        return formatted_errors
865321
public function addRecipients($recipients)
    {
        try {
            if (is_array($recipients)) {
                foreach ($recipients as $recipientsOne) {
                    $this->addRecipient($recipientsOne);
                }
            } else {
                $this->addRecipient($recipientsOne);
            }
        } catch (\Exception $e) {
            return false;
        }

        return true;
    }
1075742
function addFromAddress(inboundMessage, outboundMessage) {
  if (inboundMessage && _.has(inboundMessage, 'from')) {
    outboundMessage.recipients = outboundMessage.recipients || [];

    outboundMessage.recipients.push(inboundMessage.from);
  }

  return outboundMessage;
}
21937
function Recipient() {
    /**
     * The method value
     * @member
     */
    this.method = null;
    /**
     * The destination of value
     * @member
     * @type { Destination }
     */
    this.destination = Object.create(Destination.prototype);
    /**
     * The contactId value
     * @member
     */
    this.contactId = null;

}
1294015
public ClientNetworkConfig addAddress(String... addresses) {
        isNotNull(addresses, "addresses");
        for (String address : addresses) {
            isNotNull(address, "address");
            checkHasText(address.trim(), "member must contain text");
        }
        Collections.addAll(addressList, addresses);
        return this;
    }
510490
public void addMessage(final long messageId, final List<Token> messageTokens)
    {
        Verify.notNull(messageTokens, "messageTokens");

        captureTypes(messageTokens, 0, messageTokens.size() - 1);
        updateComponentTokenCounts(messageTokens);

        messagesByIdMap.put(messageId, new ArrayList<>(messageTokens));
    }