Set the blacklist of characters which are allowed for this field.
This can either be an array or a string.

@param array|\ArrayObject|string $blacklist
@throws \Exception
10663
public function setBlacklist($blacklist)
    {
        if (is_array($blacklist)) {
            $this->blacklist = array_map('strval', $blacklist);
        } elseif ($blacklist instanceof \ArrayObject && true) {
            $this->blacklist = array_map('strval', $blacklist->getArrayCopy());
        } elseif (is_string($blacklist)) {
            $this->blacklist = [];
            for ($i = 0; $i < strlen($blacklist); $i++) {
                $this->blacklist[] = $blacklist[$i];
            }
        } else {
            throw new \Exception('Incorrect blacklist given. Allowed blacklist are: string, array or ArrayObject.');
        }
    }
461177
private function addToWhiteList(array $whiteList) {
        $current = $this->getWhiteList();
        $current = array_merge($current, $whiteList);
        $this->setWhiteList($current);
    }
974163
protected function checkNameIsNotBlacklisted(string $name): void
    {
        if (Str::contains($name, $this->blacklisted)) {
            throw new InvalidArgumentException("Invalid character in driver name [{$name}].");
        }
    }
704870
public static function setBlacklist($filter) {
        if ($filter & self::PHPDOC)
            self::$blacklist = array_merge(self::$blacklist, self::$phpdoc);
    }
1359251
public function offsetSet($offset, $value) {
        if ($this->offsetExists($offset)) {
            throw new \Exception('Can\'t override predefined character');
        } else if (!preg_match('#^[01]+$#', $value)) {
            throw new \Exception('Value must be a string of zeroes and ones (0/1)');
        } else if (isset($this->reversedTable[$value])) {
            throw new \Exception('There is already a character with value ' . $value);
        }

        $this->table[$offset] = $value;
        $this->reversedTable[$value] = $offset;
    }
526146
public function decryptNameId(XMLSecurityKey $key, array $blacklist = []) : void
    {
        if ($this->encryptedNameId === null) {
            /* No NameID to decrypt. */

            return;
        }

        $nameId = Utils::decryptElement($this->encryptedNameId, $key, $blacklist);
        Utils::getContainer()->debugMessage($nameId, 'decrypt');
        $this->nameId = new NameID($nameId);

        $this->encryptedNameId = null;
    }
1119167
public function blacklist() {
        $args = func_get_args();

        if (isset($args[0]) && is_array($args[0])) {
            $args = $args[0];
        }

        $this->_blacklist += $args;
        $this->_blacklist = array_filter($this->_blacklist);

        return $this;
    }
81859
public function setIgnorePatterns( $list )
	{
		$this->ignorePatterns	= array();
		foreach( array_value( $list ) as $pattern)
			$this->addIgnorePattern( $pattern );	
	}
731221
public function enabledStdModules(Array $whiteList)
  {
    foreach ($this->stdModules as $moduleName) {
      if (!in_array($moduleName, $whiteList)) {
        vc_remove_element($moduleName);
      }
    }
  }
1105959
def add_to_blacklist(word, deep_search=0)
      params = {
        :method => WebPurify::Constants.methods[:add_to_blacklist],
        :word   => word,
        :ds     => deep_search
      }
      parsed = WebPurify::Request.query(text_request_base, @query_base, params)
      return parsed[:success]=='1'
    end
1080920
public function setWhitelist($whitelist)
    {
        if (!is_array($whitelist)) {
            $whitelist = preg_split('/\s*,\s*/', $whitelist);
        }
        $this->whitelist = $whitelist;
        return $this;
    }
53475
protected function inBlacklist($filename, array $blacklist)
    {
        foreach ($blacklist as $pattern) {
            if (fnmatch($pattern, $filename, FNM_PATHNAME | FNM_CASEFOLD)) {
                return true;
            }
        }

        return false;
    }
821310
public function setStr($str)
    {
        if (!mb_check_encoding($str)) {
            throw new Exception('Name is not encoded in UTF-8');
        }
        $this->str = $str;
        $this->norm();

        return true;
    }
823008
private void blacklistIfNeeded(
        String nodeName, List<FaultStatsForType> faultStats) {
    for (FaultStatsForType stat : faultStats) {
      if (isBlacklisted(nodeName, stat.type)) {
        continue;
      }
      if (tooManyFailuresOnNode(stat) ||
          tooManyConnectionFailuresOnNode(stat)) {
        nm.blacklistNode(nodeName, stat.type);
        blacklist(nodeName, stat.type);
      }
    }
  }
605075
public function setByType($type)
    {
        if (isset(self::$typeList[$type])) {
            $this->value = self::$typeList[$type];
        } else {
            throw new Exception("undefined index $type");
        }
    }
803172
public static function outEntry($data, $blackList)
    {
        if ($data) {
            $blackList = array_flip($blackList);

            $data = array_diff_key($data, $blackList);
        }
        return $data;
    }
172949
def remove_from_blacklist(word)
      params = {
        :method => WebPurify::Constants.methods[:remove_from_blacklist],
        :word   => word
      }
      parsed = WebPurify::Request.query(text_request_base, @query_base, params)
      return parsed[:success]=='1'
    end