/**
  * Unlock process
  *
  * @return Mage_Index_Model_Process
  */
 public function unlock()
 {
     $this->_getSemIdentifier();
     shm_remove_var($this->_shmId, $this->getIndexerCodeCrc());
     @sem_release($this->_getSemIdentifier());
     $this->_isLocked = false;
 }

 /**
  * (non-PHPdoc)
  * @see Lexik\Bundle\MaintenanceBundle\Drivers.AbstractDriver::createUnlock()
  */
 protected function createUnlock()
 {
     if ($this->shmId) {
         return shm_remove_var($this->shmId, self::VARIABLE_KEY);
     }
     return false;
 }

 /**
  * {@inheritdoc}
  */
 public function get()
 {
     if (shm_has_var($this->shared_memory_segment, self::$SEGMENT_VAR_ID)) {
         $data = shm_get_var($this->shared_memory_segment, self::$SEGMENT_VAR_ID);
         shm_remove_var($this->shared_memory_segment, self::$SEGMENT_VAR_ID);
         return $data;
     }
 }

 /**
  * Delete shared memory var
  */
 public function del()
 {
     sem_acquire($this->__mutex);
     //block until released
     @shm_remove_var($this->__shm, $this->__key);
     sem_release($this->__mutex);
     //release mutex
 }

 public function del($key)
 {
     if ($this->has($key)) {
         return shm_remove_var($this->shm, $this->shm_key($key));
     } else {
         return false;
     }
 }

 public function remove(string $key) : bool
 {
     if (isset($this->_cache[$key])) {
         unset($this->_cache[$key]);
     }
     $key = crc32($key);
     if (shm_has_var($this->_shmid, $key)) {
         return shm_remove_var($this->_shmid, $key);
     } else {
         return false;
     }
 }

 /**
  * @param int $key
  *
  * @throws \Exception
  * @return $this
  * @author Yohann Marillet
  */
 public function delete($key = 1)
 {
     $res = false;
     if ($this->has($key, true)) {
         $value = $this->get($key, true);
         $res = shm_remove_var($this->segment, $key);
     }
     if (!$res) {
         throw new \Exception('Cannot delete data in semaphore');
     }
     return $this;
 }

 public function unlink($key)
 {
     try {
         $shm = shm_attach($this->id, self::SEGMENT_SIZE, HESPER_IPC_PERMS);
     } catch (BaseException $e) {
         return false;
     }
     try {
         $result = shm_remove_var($shm, $key);
     } catch (BaseException $e) {
         // non existent key
         $result = false;
     }
     shm_detach($shm);
     return $result;
 }

 /**
  * @param string $varName
  * @param mixed $value
  */
 public function set($varName, $value)
 {
     $this->loadVars();
     $varId = array_search($varName, $this->varNames);
     if (false === $varId) {
         shm_put_var($this->memory, count($this->varNames) + 2, $value);
         $this->varNames[] = $varName;
         if ($this->lock->lock()) {
             shm_put_var($this->memory, self::SID_VARS, $this->varNames);
             $this->lock->unlock();
         }
     } else {
         if ($this->lock->lock()) {
             if (is_null($value)) {
                 shm_remove_var($this->memory, $varId + 2);
                 unset($this->varNames[$varId]);
                 shm_put_var($this->memory, self::SID_VARS, $this->varNames);
             } else {
                 shm_put_var($this->memory, $varId + 2, $value);
             }
             $this->lock->unlock();
         }
     }
 }

 /**
  * Delete data from storage
  * @param string $k
  * @return bool
  */
 public function delete($k)
 {
     $key = $this->__hashcode($k);
     return @shm_remove_var($this->db, $key);
 }

 public function destroy()
 {
     if (shm_has_var($this->shm, 1)) {
         shm_remove_var($this->shm, 1);
     }
     shm_remove($this->shm);
 }

 /**
  * Deletes a cache entry.
  *
  * @param string $id cache id
  * @return boolean TRUE if the cache entry was successfully deleted, FALSE otherwise.
  */
 public function delete($id)
 {
     return shm_remove_var($this->shmId, $this->forgeKey($id));
 }

 public function __unset($name)
 {
     $name = $this->intkey($name);
     shm_remove_var($this->ipc, $name);
 }

 /**
  * (non-PHPdoc)
  * @see \parallely\TransportInterface::delete()
  */
 public function delete($sId)
 {
     $this->_prepare();
     $sId = crc32($sId);
     if (empty($this->_rShared) !== true and shm_has_var($this->_rShared, $sId) === true) {
         shm_remove_var($this->_rShared, $sId);
     }
     return $this;
 }

 /**
  * @param      $key
  *
  * @return bool
  */
 public function delete($key)
 {
     return shm_remove_var(self::$shm_id, $key);
 }

 /**
  * remove variable from memory
  *
  * @param string $name  name of the variable
  *
  * @return bool true on success, false on fail
  * @access public
  */
 function rm($name)
 {
     return shm_remove_var($this->_h, $this->_s2i($name));
 }

 /**
  * Removes a variable from shared memory.
  *
  * @param string $varName
  */
 public function removeVar($varName)
 {
     $this->_registerVarName($varName);
     $useLocalMutex = !$this->_mutex->isAcquired();
     if ($useLocalMutex) {
         $this->_mutex->acquire();
     }
     $varKey = self::$_registeredVarLookup[$varName];
     if (self::$_useSysV) {
         $res = shm_remove_var($this->_shmResource, $varKey);
     } else {
         $this->_readSharedData();
         unset($this->_shmData[$varKey]);
         $res = $this->_writeSharedData();
     }
     $this->addToVar('_varcount', -1);
     if ($useLocalMutex) {
         $this->_mutex->release();
     }
     if (!$res) {
         throw new SharedMemoryException('Got error when attempting to remove shared variable "' . $varName . '".');
     }
 }

 /**
  * Removes a variable from the shared memory be specified key.
  *
  * @param string $key The key of variable
  *
  * @return bool True if the variable with key has been removed, otherwise false
  *
  * @see checkHandler
  * @see lock
  */
 public function remove($key)
 {
     $this->checkHandle();
     $this->lock();
     $removed = false;
     if ($this->has($key)) {
         $removed = shm_remove_var($this->handle, $this->getIndex($key));
         if ($removed) {
             $keys = $this->getHashKeys();
             unset($keys[$key]);
             shm_put_var($this->handle, self::SHM_HASHKEYS_INDEX, $keys);
         }
     }
     $this->unlock();
     return $removed;
 }

 /**
  * (PHP 5 &gt;= 5.0.0)<br/>
  * Offset to unset
  * @link http://php.net/manual/en/arrayaccess.offsetunset.php
  *
  * @param mixed $offset <p>
  * The offset to unset.
  * </p>
  *
  * @return void
  */
 public function offsetUnset($offset)
 {
     $task = function () use($offset) {
         $keyMapper = $this->getKeyMap();
         if (array_key_exists($offset, $keyMapper)) {
             shm_remove_var($this->id, $keyMapper[$offset]);
             unset($keyMapper[$offset]);
             shm_put_var($this->id, 0, $keyMapper);
         }
     };
     $this->lockExecute($task);
 }

 /**
  * Expire old entries.
  */
 function gc()
 {
     $dict = $this->_get_dict();
     foreach ($dict['keys'] as $k => $v) {
         if ($v['expire'] && $v['expire'] <= time()) {
             shm_remove_var($this->shmid, $v['varkey']);
             unset($dict['keys'][$k]);
         }
     }
     $this->_set_dict($dict);
 }