CodeExplorer

BadMethodCallException example

        $this->categoryRepository = $categoryRepository;
    }

    public function uninstall(UninstallContext $uninstallContext): void
    {
    }

    public function update(UpdateContext $updateContext): void
    {
        if ($updateContext->getContext()->hasExtension(self::THROW_ERROR_ON_UPDATE)) {
            throw new \BadMethodCallException('Update throws an error');
        }

        parent::update($updateContext);
    }

    public function deactivate(DeactivateContext $deactivateContext): void
    {
        if ($deactivateContext->getContext()->hasExtension(self::THROW_ERROR_ON_DEACTIVATE)) {
            throw new \BadFunctionCallException('Deactivate throws an error');
        }
        parent::deactivate($deactivateContext);
    }

use CodeIgniter\View\Table;

class MockTable extends Table
{
    // Override inaccessible protected method     public function __call($method, $params)
    {
        if (is_callable([$this, '_' . $method])) {
            return call_user_func_array([$this, '_' . $method], $params);
        }

        throw new BadMethodCallException('Method ' . $method . ' was not found');
    }
}

return $this;
    }

    /** * Takes a new set of data and runs it against the currently * prepared query. Upon success, will return a Results object. */
    public function _execute(array $data): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
        }

        $this->result = pg_execute($this->db->connID, $this->name, $data);

        return (bool) $this->result;
    }

    /** * Returns the result object for the prepared query or false on failure. * * @return resource|null * @phpstan-return PgSqlResult|null */

    public function app(string $key, ?string $salesChannelId = null)
    {
        if (!$this->scriptAppInformation) {
            throw new \BadMethodCallException('`config.app()` can only be called from app scripts.');
        }

        if (!$salesChannelId) {
            $salesChannelId = $this->salesChannelId;
        }

        $key = $this->scriptAppInformation->getAppName() . '.config.' . $key;

        return $this->systemConfigService->get($key, $salesChannelId);
    }

/** * Returns the current baseURL. * * @interal * * @deprecated Use SiteURI instead. */
    public function getBaseURL(): string
    {
        if ($this->baseURL === null) {
            throw new BadMethodCallException('The $baseURL is not set.');
        }

        return $this->baseURL;
    }

    /** * Sets the path portion of the URI based on segments. * * @return $this * * @deprecated This method will be private. */

return $this;
    }

    /** * Takes a new set of data and runs it against the currently * prepared query. Upon success, will return a Results object. */
    public function _execute(array $data): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
        }

        // First off -bind the parameters         $bindTypes = '';

        // Determine the type string         foreach ($data as $item) {
            if (is_int($item)) {
                $bindTypes .= 'i';
            } elseif (is_numeric($item)) {
                $bindTypes .= 'd';
            }

        $this->stringLimits = \json_encode($this->limits, \JSON_THROW_ON_ERROR);

        return ['id', 'attempts', 'timer', 'expiresAt', 'unthrottledAttempts', 'stringLimits'];
    }

    public function __wakeup(): void
    {
        try {
            $this->limits = json_decode($this->stringLimits, true, 512, \JSON_THROW_ON_ERROR);
        } catch (\JsonException) {
            throw new \BadMethodCallException('Cannot unserialize ' . self::class);
        }

        unset($this->stringLimits);
    }

    public function getId(): string
    {
        return $this->id;
    }

    public function getExpirationTime(): ?int
    {

return $this;
    }

    /** * Takes a new set of data and runs it against the currently * prepared query. Upon success, will return a Results object. */
    public function _execute(array $data): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
        }

        foreach (array_keys($data) as $key) {
            oci_bind_by_name($this->statement, ':' . $key, $data[$key]);
        }

        $result = oci_execute($this->statement, $this->db->commitMode);

        if ($result && $this->lastInsertTableName !== '') {
            $this->db->lastInsertedTableName = $this->lastInsertTableName;
        }

foreach ($elements as $element) {
            $this->addField($element);
        }
    }

    /** * @param Field $field */
    public function add($field): void
    {
        if (!$field->isCompiled()) {
            throw new \BadMethodCallException('This action is not recommended if you still need to compile the field');
        }
        $this->addField($field);
    }

    public function addNewField(Field $field): void
    {
        $field->compile($this->registry);
        $this->addField($field);
    }

    public function addField(Field $field): void
    {

if ($this->indexPage) {
            $this->baseSegments[] = $this->indexPage;
        }
    }

    /** * @deprecated */
    public function setBaseURL(string $baseURL): void
    {
        throw new BadMethodCallException('Cannot use this method.');
    }

    /** * @deprecated */
    public function setURI(?string $uri = null)
    {
        throw new BadMethodCallException('Cannot use this method.');
    }

    /** * Returns the baseURL. * * @interal */

        $builder = $this->builder();
        $result  = null;

        if (method_exists($this->db, $name)) {
            $result = $this->db->{$name}(...$params);
        } elseif (method_exists($builder, $name)) {
            $this->checkBuilderMethod($name);

            $result = $builder->{$name}(...$params);
        } else {
            throw new BadMethodCallException('Call to undefined method ' . static::class D '::' . $name);
        }

        if ($result instanceof BaseBuilder) {
            return $this;
        }

        return $result;
    }

    /** * Checks the Builder method name that should not be used in the Model. */

    protected $dom;

    /** * Constructor. * * @throws BadMethodCallException */
    public function __construct()
    {
        if (! extension_loaded('DOM')) {
            throw new BadMethodCallException('DOM extension is required, but not currently loaded.'); // @codeCoverageIgnore         }

        $this->dom = new DOMDocument('1.0', 'utf-8');
    }

    /** * Returns the body of the current document. */
    public function getBody(): string
    {
        return $this->dom->saveHTML();
    }

return $this;
    }

    /** * Takes a new set of data and runs it against the currently * prepared query. Upon success, will return a Results object. */
    public function _execute(array $data): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('You must call prepare before trying to execute a prepared statement.');
        }

        foreach ($data as $key => $item) {
            // Determine the type string             if (is_int($item)) {
                $bindType = SQLITE3_INTEGER;
            } elseif (is_float($item)) {
                $bindType = SQLITE3_FLOAT;
            } else {
                $bindType = SQLITE3_TEXT;
            }

    abstract public function _getResult();

    /** * Explicitly closes the prepared statement. * * @throws BadMethodCallException */
    public function close(): bool
    {
        if (! isset($this->statement)) {
            throw new BadMethodCallException('Cannot call close on a non-existing prepared statement.');
        }

        try {
            return $this->_close();
        } finally {
            $this->statement = null;
        }
    }

    /** * The database-dependent version of the close method. */