Clears internal buffers

Clearing/resetting the internal buffers is done everytime
after disableContinuousBuffer() or on cipher $engine (re)init
ie after setKey() or setIV()

@access public
@internal Could, but not must, extend by the child Crypt_* class
545298
function _clearBuffers()
    {
        $this->enbuffer = $this->debuffer = array('ciphertext' => '', 'xor' => '', 'pos' => 0, 'enmcrypt_init' => true);

        // mcrypt's handling of invalid's $iv:
        // $this->encryptIV = $this->decryptIV = strlen($this->iv) == $this->block_size ? $this->iv : str_repeat("\0", $this->block_size);
        $this->encryptIV = $this->decryptIV = str_pad(substr($this->iv, 0, $this->block_size), $this->block_size, "\0");

        if (!$this->skip_key_adjustment) {
            $this->key = str_pad(substr($this->key, 0, $this->key_length), $this->key_length, "\0");
        }
    }
119712
public static function reset() {
		if (empty(self::$_initialState)) {
			self::$_initialState = get_class_vars('Inflector');
			return;
		}
		foreach (self::$_initialState as $key => $val) {
			if ($key != '_initialState') {
				self::${$key} = $val;
			}
		}
	}
683521
public void clearBuffer()
    {
        super.clearBuffer();
        if (m_vector == null)
            m_vector = new Vector<Object>();
        else
            m_vector.removeAllElements();
        m_iCurrentIndex = 0;
    }
389168
public function reset()
    {
        $this->values[self::INDEX] = null;
        $this->values[self::CIPHERKEY] = null;
        $this->values[self::MACKEY] = null;
        $this->values[self::IV] = null;
    }
99594
public function clearCacheAction()
    {
        /* @var $cache FlushableCache */
        $cache = $this->serviceLocator->get('DiCache');

        if ($cache instanceof FlushableCache) {
            $cache->flushAll();
        }

        echo "PHP DI definitions cache was cleared." . PHP_EOL . PHP_EOL;
    }
77242
public function clear()
    {
        foreach ($this->keys() as $key) {
            unset($this->_store[$key]);
        }
        $frozenKeys = \array_keys($this->_frozen);
        foreach ($frozenKeys as $key) {
            unset($this->_frozen[$key]);
        }
    }
858639
public function clear()
	{
		$cvars = get_class_vars(__CLASS__);

		$this->_updatedkeys = array();

		foreach ($cvars as $key => $value)
		{
			if ($key{0} != '_')
			{
				unset($this->$key);

				$this->$key = null;
			}
		}

		$this->_updatedkeys = array();
	}
296510
public function clearRuntime()
    {
        $file = \Imi\Util\Imi::getRuntimePath('runtime.cache');
        if(is_file($file))
        {
            unlink($file);
            echo 'Clear app runtime complete', PHP_EOL;
        }
        else
        {
            echo 'App runtime does not exists', PHP_EOL;
        }
    }
615726
public static function clear()
    {
        self::$local_ip = self::$local_port = self::$client_ip = self::$client_port =
        self::$client_id = self::$connection_id  = self::$old_session = null;
    }
1253754
private void clearBuffers() {
        // simply null out the parse buffers list, then release all the created buffers
        final boolean bTrace = TraceComponent.isAnyTracingEnabled();
        for (int i = 0; i <= this.parseIndex; i++) {
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Removing reference to parse buffer: " + this.parseBuffers[i]);
            }
            this.parseBuffers[i] = null;
            this.parseBuffersStartPos[i] = HeaderStorage.NOTSET;
        }
        this.parseIndex = HeaderStorage.NOTSET;
        for (int i = 0; i <= this.createdIndex; i++) {
            if (bTrace && tc.isDebugEnabled()) {
                Tr.debug(tc, "Releasing marshall buffer: " + this.myCreatedBuffers[i]);
            }
            this.myCreatedBuffers[i].release();
            this.myCreatedBuffers[i] = null;
        }
        this.createdIndex = HeaderStorage.NOTSET;
    }
73061
public function reset()
    {
        $this->encoding = [
            'type' => null,
            'filter' => null
        ];
        $this->charset = [
            'from' => null,
            'to' => null,
            'filter' => null
        ];
        $this->stream->rewind();
        $this->decodedStream = $this->stream;
        $this->charsetStream = $this->stream;
    }
1311765
public function clearAllData()
    {
        if (!$this->isUsed()) {
            return;
        }

        $this->getConn()->clearAllData();

        // Some DataExtensions keep a static cache of information that needs to
        // be reset whenever the database is cleaned out
        $classes = array_merge(
            ClassInfo::subclassesFor(DataExtension::class),
            ClassInfo::subclassesFor(DataObject::class)
        );
        foreach ($classes as $class) {
            $toCall = array($class, 'on_db_reset');
            if (is_callable($toCall)) {
                call_user_func($toCall);
            }
        }
    }
1314467
public function clear()
    {
        if ($this->locked) {
            throw new AccessException('Options cannot be cleared from a lazy option or normalizer.');
        }

        $this->defined = [];
        $this->defaults = [];
        $this->nested = [];
        $this->required = [];
        $this->resolved = [];
        $this->lazy = [];
        $this->normalizers = [];
        $this->allowedTypes = [];
        $this->allowedValues = [];
        $this->deprecated = [];

        return $this;
    }
1364018
private synchronized void clear() {

        if (!isEnabled()) {
            return;
        }
        m_keyCache.clear();
        m_size = 0;

        m_variationCache.clear();

        if (LOG.isInfoEnabled()) {
            LOG.info(Messages.get().getBundle().key(Messages.LOG_FLEXCACHE_CLEAR_0));
        }
    }
643995
private void clearNioBuffers() {
        int count = nioBufferCount;
        if (count > 0) {
            nioBufferCount = 0;
            Arrays.fill(NIO_BUFFERS.get(), 0, count, null);
        }
    }
447600
def __clear_in_buffer(self):
        
        self.__in_buffer.value = bytes(b'\0' * len(self.__in_buffer))
330188
public synchronized void reset() {
        ensureOpen();
        encodedBuf.clear();
        if (decodedBuf.capacity() > FilteredConstants.DEFAULT_DECODER_CAPACITY) {
            this.decodedBuf = CharBuffer.allocate(FilteredConstants.DEFAULT_DECODER_CAPACITY);
        } else {
            decodedBuf.clear();
        }
        decoder.reset();
    }