Add a blind carbon copy to the message.

@param  string|array  $address
@param  string|null  $name
@param  bool  $override
@return $this
194977
public function bcc($address, $name = null, $override = false)
    {
        if ($override) {
            $this->swift->setBcc($address, $name);

            return $this;
        }

        return $this->addAddresses($address, $name, 'Bcc');
    }
1044825
public static function scheme($name = null, $scheme = null, $override = false)
    {
        if (is_array($name) && is_bool($scheme)) {
            $override = $scheme;
        }

        return Util::operateArray(self::$scheme, $name, $scheme, null, function ($key, $value) {
            if (is_string($key)) {
                self::modifyScheme($key, is_array($value) ? $value : "$value");
            } elseif (is_int($key)) {
                self::modifyScheme($value, '');
            }
        }, $override, function (array $origin) {
            if (self::isTaskBooted()) {
                foreach (array_keys($origin) as $name) {
                    self::getTask()->removeDriver($name);
                }
            }
        });
    }
1285968
public function setFrom($address, $name = null, $auto = true)
    {
        $address = substr($address, 0, 150);
        $name = substr($name, 0, 150);

        $success = false;
        try {
            $success = parent::setFrom($address, $name, $auto);
        } catch (Exception $exception) {
        }

        return $success;
    }
966179
public function sender($address, $name = null)
    {
        $this->swiftMessage->setSender($address, $name);

        return $this;
    }
575808
public function bcc($address, $name = "", array $variables = [])
    {
        if (!empty($variables)) {
            $this->variables[$address] = $variables;
        }
        $this->messageBuilder->addBccRecipient($address, ['full_name' => $name]);

        return $this;
    }
1228264
public function setSender($address, $name = null)
    {
        if (!is_array($address) && isset($name)) {
            $address = [$address => $name];
        }

        if (!$this->setHeaderFieldModel('Sender', (array) $address)) {
            $this->getHeaders()->addMailboxHeader('Sender', (array) $address);
        }

        return $this;
    }
1298463
public function setParameter(String $key, $value, Bool $override=false)
	{
		if ($this->getParameter($key)) {
			$defValue = $this->getParameter($key);
			$this->parameters[$key] = [$defValue];
			$this->parameters[$key][] = $value;
			return;
		}

		$this->parameters[$key] = $value;
	}
119898
public void addOverrideMap(Map<String, String> overrideMap) {
    if (sealed) {
      throw new IllegalStateException("Instance is sealed.");
    }
    for (Map.Entry<String, String> entry : overrideMap.entrySet()) {
      try {
        ParameterOverrideInfo info = new ParameterOverrideInfo(entry.getKey());
        if (info.isOverrideSystemDefault()) {
          putMapIfNotExsits(overrideSystemDefaultMap, info.getParameterName(), entry.getValue());
        }
        else if (StringUtils.isNotEmpty(info.getConfigurationId()))  {
          Map<String, String> overrideForceScopeMapEntry = overrideForceScopeMap.get(info.getConfigurationId());
          if (overrideForceScopeMapEntry == null) {
            overrideForceScopeMapEntry = new HashMap<>();
            overrideForceScopeMap.put(info.getConfigurationId(), overrideForceScopeMapEntry);
          }
          putMapIfNotExsits(overrideForceScopeMapEntry, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            Set<String> lockedParameterNamesScopeMapEntry = lockedParameterNamesScopeMap.get(info.getConfigurationId());
            if (lockedParameterNamesScopeMapEntry == null) {
              lockedParameterNamesScopeMapEntry = new HashSet<>();
              lockedParameterNamesScopeMap.put(info.getConfigurationId(), lockedParameterNamesScopeMapEntry);
            }
            putSetIfNotExsits(lockedParameterNamesScopeMapEntry, info.getParameterName());
          }
        }
        else {
          putMapIfNotExsits(overrideForceMap, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            putSetIfNotExsits(lockedParameterNamesSet, info.getParameterName());
          }
        }
      }
      catch (IllegalArgumentException ex) {
        log.warn("Ignoring invalid parameter override definition:\n" + ex.getMessage());
      }
    }
  }
478674
public static function makeMasternodePauseInstance(string $address): self
    {
        $transaction = new self();

        $transaction->setVersion(Version::MASTERNODE_PAUSE);
        return self::setMasternodeCommandDefaults($address, $transaction);
    }
655133
public function setFrom($address, $name = null)
	{
		$this->getComposer()->from = new ezcMailAddress($address, $name, CHARSET);

		return $this;
	}
274553
public static function makeMasternodeResumeInstance(string $address): self
    {
        $transaction = new self();

        $transaction->setVersion(Version::MASTERNODE_RESUME);
        return self::setMasternodeCommandDefaults($address, $transaction);
    }
409086
public function set($key, $value = null, $override = false)
    {
        // if key is array,
        // loop the set, while expecting value parameter to be override
        if(is_array($key))
        {
            $override = $value;

            foreach($key as $k => $val)
            {
                if($override === true)
                    $this->setOverride($k, $val);
                else
                    $this->data[$k] = $val;
            }

            return $this;
        }
        else
        {
            if($override === true)
                $this->setOverride($key, $value);
            else
                $this->data[$key] = $value;

            return $this;
        }
    }
169141
public function to($address, $name = "", array $variables = [])
    {
        if (is_array($address)) {
            foreach ($address as $email => $variables) {
                $this->variables[$email] = $variables;

                $name = isset($variables['name']) ? $variables['name'] : null;
                $this->messageBuilder->addToRecipient($email, ['full_name' => $name]);
            }
        } else {
            if (!empty($variables)) {
                $this->variables[$address] = $variables;
            }
            $this->messageBuilder->addToRecipient($address, ['full_name' => $name]);
        }

        return $this;
    }
49689
public function alwaysFrom(string $address, ?string $name = null): void
    {
        $this->getMailer()->alwaysFrom($address, $name);
    }
901999
public function addBodyParam(string $name, $value, bool $overwrite = false)
    {
        $keyExists = array_key_exists($name, $this->body);
        # check if the key already exists
        if ($keyExists && !$overwrite) {
            return $this;
        }
        if (is_null($value)) {
            if ($keyExists) {
                unset($this->body[$name]);
            }
            return $this;
        }
        if (is_null($value)) {
            unset($this->query[$name]);
            return $this;
        }
        $this->body[$name] = $value;
        return $this;
    }
485997
public function cc($address, $name = null)
    {
        if (is_array($address)) {
            $this->addAddressArray($address, 'cc');
        } else {
            $this->cc[$address] = $name;
        }

        return $this;
    }
434919
public static function makeMasternodeReleaseInstance(string $address): self
    {
        $transaction = new self();

        $transaction->setVersion(Version::MASTERNODE_RELEASE);
        return self::setMasternodeCommandDefaults($address, $transaction);
    }