Clears all error handlers for an exception type.

@param string $exceptionType Exception type
181664
public function clearHandlers(string $exceptionType): void
	{
		foreach($this->handlers as $key => $handler)
		{
			if($handler['exceptionType'] === $exceptionType)
			{
				unset($this->handlers[$key]);
			}
		}
	}
670418
protected function resolveHandlingMethod($eventType)
    {
        // Remove namespace
        $pos = strrpos($eventType, '\\');
        if ($pos !== false) {
            $eventType = substr($eventType, $pos + 1);
        }

        // Remove "Event" suffix
        if (substr($eventType, -5) === 'Event') {
            $eventType = substr($eventType, 0, -5);
        }

        return 'on' . $eventType;
    }
467391
public static function setCurrentIntegrationType($type)
    {
        if (!self::integrationTypes()[$type]) {
            $integrationTypes = array_keys(self::integrationTypes());
            $integrationTypesAsString = join($integrationTypes, ", ");
            throw new \Exception('Invalid integration type, valid values are: ' . $integrationTypesAsString);
        }
        self::$integrationType = $type;
    }
413814
public function cleanupDeferredEventHandlers()
    {
        foreach ($this as $key => $property) {
            if ($property instanceof DeferredEvent) {
                $property->cleanup();
                $this->{$key} = null;
            }
        }
    }
944657
public static function shutdownHandler($type = E_ERROR)
    {
//echo __METHOD__;
        $error = error_get_last();
        if ($error["type"] & $type) {
            self::errorHandler( $error["type"], $error["message"], $error["file"], $error["line"] );
        }
    }
126088
public function disableLoggingFor($exceptionType): void
	{
		$this->disableLoggingFor = array_unique(array_merge($this->disableLoggingFor, (array) $exceptionType));
	}
319088
public void clearTypes() {

        List<String> selectedTypes = m_searchObject.getTypes();
        m_handler.onClearTypes(selectedTypes);
        m_searchObject.clearTypes();
        updateResultsTab(false);
        ValueChangeEvent.fire(this, m_searchObject);
    }
287582
public function clearBlockTypes()
    {
        $app = Application::getFacadeApplication();
        $db = $app->make(Connection::class);
        $db->delete('BlockTypeSetBlockTypes', ['btsID' => $this->getBlockTypeSetID()]);
    }
929498
protected function setError(int $errorType = 0, string $className = ''): void
    {
        $errorMessage = '';
        if ($errorType == self::E_NO_CONNECTION) {
            $errorMessage = \sprintf(
                'FATAL ERROR (%s): Cannot establish connection to database server.',
                $this->currentLink->connect_errno
            );
        } elseif ($errorType == self::E_NO_DB_SELECTED) {
            $errorMessage = \sprintf(
                'FATAL ERROR (%s): Cannot select database \'%s\'.',
                $this->currentLink->errno,
                $this->selectedDB
            );
        } elseif ($errorType == self::E_NO_SQL) {
            $errorMessage = \sprintf(
                'FATAL ERROR (%s): Query was empty.',
                $this->currentLink->errno
            );
        } elseif ($errorType == self::E_ENGINE_ERROR) {
            $errorMessage = \sprintf(
                'FATAL ERROR (%s): %s: %s',
                $this->currentLink->errno,
                $this->currentLink->error,
                $this->currentQuery
            );
        }

        if ($this->logHandler !== null) {
            $this->logHandler->logError($errorMessage, $className);
        }

        if ($this->errorLevel == 'print') {
            $errorText = \sprintf('%s%s%s%s', $errorMessage, Tags::CRLF, Tags::br(), Tags::CRLF);
            echo filter_var($errorText, FILTER_DEFAULT);
        }
        if ($this->errorLevel == 'exception') {
            $this->closeConnection();
            throw new RuntimeException($errorMessage);
        }
    }
508602
public function clearNotificationListeners($notification_type)
    {
        if (!NotificationType::isNotificationTypeValid($notification_type)) {
            $this->_logger->log(Logger::ERROR, "Invalid notification type.");
            $this->_errorHandler->handleError(new InvalidNotificationTypeException('Invalid notification type.'));
            return;
        }

        $this->_notifications[$notification_type] = [];
        $this->_logger->log(Logger::INFO, "All callbacks for notification type '{$notification_type}' have been removed.");
    }
1011717
public function setErrorHandling( $errorHandling )
    {
        if ( $errorHandling != eZDB::ERROR_HANDLING_EXCEPTIONS &&
             $errorHandling != eZDB::ERROR_HANDLING_STANDARD )
            throw new RuntimeException( "Unknown eZDB error handling mode $errorHandling" );

        $this->errorHandling = $errorHandling;
    }
395508
public function setHashType($hashType)
    {
        $type = strtolower($hashType);
        if (!in_array($type, array('md5', 'sha1'), true)) {
            throw new \Exception(sprintf('Invalid Hash Type %s', $hashType));
        }
        $this->hashType = $type;
    }
334011
protected function resetMessageTypes()
    {
        foreach (array_keys($this->config('types')) as $type) {
            $_SESSION[$this->alias][$type] = [];
        }
    }
642654
public static function shutdownHandler()
    {
        if ( ! ($error = error_get_last())) {
            return;
        }

        self::exceptionHandler(
            new \ErrorException($error['message'], 0, $error['type'], $error['file'], $error['line'])
        );
    }
1182074
protected function cleanup($dataType, $data)
    {
        // Delete Translations, if present
        if (is_crud_translatable($data)) {
            $data->deleteAttributeTranslations($data->getTranslatableAttributes());
        }

        // Delete Images
        $this->deleteCrudImages($data, $dataType->deleteRows->where('type', 'image'));

        // Delete Files
        foreach ($dataType->deleteRows->where('type', 'file') as $row) {
            $files = json_decode($data->{$row->field});
            if ($files) {
                foreach ($files as $file) {
                    $this->deleteFileIfExists($file->download_link);
                }
            }
        }
    }
915233
public function removeType(string $type)
    {
        if (!$this->removing && Type::hasType($type)) {
            $this->removing = true;
            Type::overrideType($type, null);
        }

        $this->removing = false;
        unset($this->types[$type]);
    }
1138480
private void preDelete(MembershipType type) throws Exception
   {
      for (MembershipTypeEventListener listener : listeners)
      {
         listener.preDelete(type);
      }
   }