Önbelleğe alınan tüm verileri siler
@throws DriverNotFlushableException
@return mixed
977347
public function flush()
    {

        if ($this->adapter instanceof FlushableInterface) {
            return $this->adapter->flush();
        } else {
            throw new DriverNotFlushableException('%s sürücünüz flushable değildir', get_class($this->adapter));
        }
    }
56083
public function delay()
    {
        if ($this->delay !== null) {
            return $this->delay;
        }
        switch ($this->driver) {
            case self::DRIVER_MYSQL:
                return $this->delay = new Delay\MySQL\Manage($this->pdo);
        }
        throw new DatabaseException('Unsupported PDO driver.');
    }
1245015
public function getNotAllowedHandler() : NotAllowedHandlerInterface
    {
        if (!$this->notAllowedHandler) {
            $this->notAllowedHandler = new NotAllowedHandler(
                (bool) $this->getConfiguration('displayErrors')
            );
        }

        return $this->notAllowedHandler;
    }
408527
public function flush()
	{
		$this->where = null;
		$this->_aSelect = array();
		$this->_sFrom = '';
		$this->_sFromAs = '';
		$this->_aJoin = array();
		$this->_sUpdate = '';
		$this->_mWhere = array();
		$this->_aSet = array();
		$this->_sInsertInto = '';
		$this->_aValues = array();
		$this->_sDelete = '';
		$this->_aOrderBy = array();
		$this->_aGroupBy = array();
		$this->_iLimit = null;
		return $this;
	}
851198
public function driver()
    {
        $args = func_get_args();
        $props = Driver::parseArgs($args);
        $newProps = $this->callHookHandler('beforeCreateDriver', $props);
        if (is_array($newProps)) {
            $props = array_merge($props, $newProps);
        }
        extract($props);
        $driver = Driver::create($this, $name, $weight, $backup, $work);
        $this->drivers[$name] = $driver;
        $this->callHookHandler('afterCreateDriver', $driver);

        return $driver;
    }
822715
public function get()
    {
        if (class_exists($this->serializerType)) {

            if (in_array('Mmoreram\\RSQueueBundle\\Serializer\\Interfaces\\SerializerInterface', class_implements($this->serializerType))) {
                return new $this->serializerType;
            } else {

                throw new SerializerNotImplementsInterfaceException;
            }
        }

        $composedSerializerNamespace = '\\Mmoreram\\RSQueueBundle\\Serializer\\' . $this->serializerType . 'Serializer';

        if (class_exists($composedSerializerNamespace)) {
            return new $composedSerializerNamespace;
        }

        throw new SerializerNotFoundException;
    }
461016
public static function driver() {
        $key = get_called_class();
        if($driver = Pool::get($key)) {
            return $driver;
        }

        $args = func_get_args();
        $config = static::config();
        $config and array_unshift($args,$config);
        $class =  call_user_func_array(
            'static::create',
            $args
        );

        return Pool::set($key,$class);
    }
440960
public function cache()
    {
        if ($this->cache !== null) {
            return $this->cache;
        }
        switch ($this->driver) {
            case self::DRIVER_MYSQL:
                return $this->cache = new Cache\MySQL\Manage($this->pdo);
        }
        throw new DatabaseException('Unsupported PDO driver.');
    }
400540
public function flushCache()
    {
        // Cache disabled, just ignore this
        if ($this->eventFlushCache === false || config('repositories.cache_enabled', false) === false) {
            return false;
        }

        // Use the called class name as the tag
        $tag = get_called_class();

        return self::getCacheInstance()->tags(['repositories', $tag])->flush();
    }
1103983
public function getDriverName()
    {
        $value = $this->getValue();

        $value = explode(":", $value);

        $driver = reset($value);

        return $driver;
    }
446546
public function affectedRows(){
		$this->performed || $this->run();
		if($this->affectedRows === false)
			throw new DriverException('Affected rows are not supported by this driver.');
		return $this->affectedRows;
	}
714018
public function flush()
    {
        if (null === $this->routesFactory) {
            $routes = new RouteCollection();
        } else {
            $routes = $this->routesFactory;
        }

        return $this->doFlush('', $routes);
    }
391221
private function getDriver(): \BearFramework\App\ICacheDriver
    {
        if ($this->driver !== null) {
            return $this->driver;
        }
        throw new \Exception('No cache driver specified! Use useAppDataDriver() or setDriver() to specify one.');
    }
246633
public function save() {
		if( empty($this->modFields) || $this->isDeleted() ) {
			return false;
		}
		
		$data = array_filterbykeys($this->data, $this->modFields);
		if( !$data ) {
			throw new Exception('No updated data found but there is modified fields, unable to update');
		}
		$operation = $this->getUpdateOperation($data, $this->modFields);
		// Do not validate, new data are invalid due to the fact the new data are already in object
		// 		$operation->validate();
		$r = $operation->run();
		$this->modFields = array();
		if( !$this->onSavedInProgress ) {
			// Protect script against saving loops
			$this->onSavedInProgress = true;
			static::onSaved($data, $this);
			$this->onSavedInProgress = false;
		}
		return $r;
	}
1110191
public static function getDriverEvents()
    {
        return [
            DriverEvents::DRIVER_GET_CONFIGURATION => [
                ["getConfiguration", 0],
            ],
            DriverEvents::DRIVER_LOAD_CONFIGURATION => [
                ["loadConfiguration", 0],
            ],
            DriverEvents::INDEX_CREATE => [
                ["createIndex", 0],
            ],
            DriverEvents::INDEX_EXISTS => [
                ["indexExists", 0],
            ],
            DriverEvents::INDEX_DELETE => [
                ["deleteIndex", 0],
            ],
            DriverEvents::INDEXES_PERSIST => [
                ["persistIndexes", 0],
            ],
            DriverEvents::INDEX_SEARCH_QUERY => [
                ["executeSearchQuery", 0],
            ]
        ];
    }
323286
public function save()
    {
        if ($this->dirt) {
            return $this->driver->save($this->settings, $this->dirt);
        }

        return false;
    }
253048
private static function createDriver()
    {
        if (self::$factory === null) {
            throw new \Exception("No loop driver factory set; Either pass a driver to Loop::execute or set a factory.");
        }

        $driver = self::$factory->create();

        if (!$driver instanceof Driver) {
            $type = is_object($driver) ? "an instance of " . get_class($driver) : gettype($driver);
            throw new \Exception("Loop driver factory returned {$type}, but must return an instance of Driver.");
        }

        return $driver;
    }