Clear item object in storage
@param string $sClassName
@param int    $iElementID
494266
public static function clear($sClassName, $iElementID)
    {
        $sKey = self::getKey($sClassName, $iElementID);
        if (!isset(self::$arItemStore[$sKey])) {
            return;
        }

        unset(self::$arItemStore[$sKey]);
    }
399213
function removeItem( $itemID )
    {
        $item = eZProductCollectionItem::fetch( $itemID );
        if ( is_object( $item ) && $this->attribute( 'productcollection_id' ) == $item->attribute( 'productcollection_id' ) )
        {
            $item->remove();
        }
    }
1146684
public void deleteElement(String elementId, final String relatedElementId) {

        elementId = getServerId(elementId);
        removeContainerElements(elementId);
        addToRecentList(elementId, null);
        reloadElements(new String[] {relatedElementId});
    }
47316
protected function deleteTypeNameData($typeId, $typeStatus)
    {
        $query = $this->dbHandler->createDeleteQuery();
        $query->deleteFrom('ezcontentclass_name')
            ->where(
                $query->expr->lAnd(
                    $query->expr->eq(
                        $this->dbHandler->quoteColumn('contentclass_id'),
                        $query->bindValue($typeId, null, \PDO::PARAM_INT)
                    ),
                    $query->expr->eq(
                        $this->dbHandler->quoteColumn('contentclass_version'),
                        $query->bindValue($typeStatus, null, \PDO::PARAM_INT)
                    )
                )
            );
        $query->prepare()->execute();
    }
927915
function clear() {
  // TODO: Only remove used items
  data = {};
  if (localExists()) {
    try {
      // Clear session storage
      window.sessionStorage.clear();
    } catch (error) {
      _logger2.default.warn({
        description: 'Session storage could not be cleared.', error: error,
        obj: 'storage', func: 'removeItem'
      });
    }
  }
}
299848
public void clear() {
        documentsByEntity.clear();
        deletedEntities.clear();
        documentsById.clear();
        _knownMissingIds.clear();
        if (_countersByDocId != null) {
            _countersByDocId.clear();
        }
    }
437929
static function remove( $classID )
    {
        $contentClass = eZContentClass::fetch( $classID );

        if ( $contentClass == null or !$contentClass->isRemovable() )
            return false;

        // Remove all objects
        $contentObjects = eZContentObject::fetchSameClassList( $classID );
        foreach ( $contentObjects as $contentObject )
        {
            eZContentObjectOperations::remove( $contentObject->attribute( 'id' ) );
        }

        if ( count( $contentObjects ) == 0 )
            eZContentObject::expireAllViewCache();

        eZContentClassClassGroup::removeClassMembers( $classID, 0 );
        eZContentClassClassGroup::removeClassMembers( $classID, 1 );

        // Fetch real version and remove it
        $contentClass->remove( true );

        // Fetch temp version and remove it
        $tempDeleteClass = eZContentClass::fetch( $classID, true, 1 );
        if ( $tempDeleteClass != null )
            $tempDeleteClass->remove( true, 1 );

        return true;
    }
1023408
public void clearTenant(String tenantId) {
        String index = getIndex(tenantId);

        synchronized (knownIndices) {
            IndicesAdminClient indices = client.admin().indices();

            boolean indexExists = indices.prepareExists(index)
                    .execute()
                    .actionGet()
                    .isExists();

            if (indexExists) {
                indices.prepareDelete(index)
                        .execute()
                        .actionGet();
            }

            knownIndices.remove(index);
        }
    }
362198
public function unshift($iElementID)
    {
        if (empty($iElementID)) {
            return $this->returnThis();
        }

        if ($this->isEmpty()) {
            $this->arElementIDList = [$iElementID];

            return $this->returnThis();
        }

        array_unshift($this->arElementIDList, $iElementID);

        return $this->returnThis();
    }
265976
public function deleteEntry()
    {
        $delete = oxNew($this->_sListClass);

        //disabling deletion for derived items
        if ($delete->isDerived()) {
            return;
        }

        $blDelete = $delete->delete($this->getEditObjectId());

        // #A - we must reset object ID
        if ($blDelete && isset($_POST['oxid'])) {
            $_POST['oxid'] = -1;
        }

        $this->resetContentCache();

        $this->init();
    }
791913
public function remove()
    {
        foreach ($this as $node) {
            /**
             * @var \DOMNode $node
             */
            if ($node->parentNode instanceof \DOMElement) {
                $node->parentNode->removeChild($node);
            }
        }
        $this->clear();
    }
102247
function cleanup(e) {
    if (e.tile.proxyRefs) {
      for (var proxyKey in e.tile.proxyRefs) {
        var proxyTile = e.tile.proxyRefs[proxyKey];
        if ((--proxyTile.proxyCount <= 0) && cache.unload(proxyKey)) {
          proxyTile.element.parentNode.removeChild(proxyTile.element);
        }
      }
      delete e.tile.proxyRefs;
    }
  }
109704
public function removeItems($eventName)
    {
        if (!isset($this->items[$eventName])) {
            return false;
        }
        
        // Remove the event
        unset($this->items[$eventName]);
        
        // Save the items
        $this->saveItems();
    }
300547
function deleteStoredObjectAttribute( $contentObjectAttribute, $version = null )
    {
        $contentObjectAttributeID = $contentObjectAttribute->attribute( 'id' );
        eZEnumObjectValue::removeAllElements( $contentObjectAttributeID, $version );

    }
698824
function removeElData(el) {
  var id = el[elIdAttr];

  if (!id) {
    return;
  }

  // Remove all stored data
  delete elData[id];

  // Remove the elIdAttr property from the DOM node
  try {
    delete el[elIdAttr];
  } catch (e) {
    if (el.removeAttribute) {
      el.removeAttribute(elIdAttr);
    } else {
      // IE doesn't appear to support removeAttribute on the document element
      el[elIdAttr] = null;
    }
  }
}
25998
function removeItem(itemName) {
  // TODO: Only remove used items
  if (data[itemName]) {
    data[itemName] = null;
  }
  if (localExists() && getItem(itemName)) {
    try {
      // Clear session storage
      window.sessionStorage.removeItem(itemName);
    } catch (error) {
      _logger2.default.warn({
        description: 'Error removing item from session storage', error: error,
        obj: 'storage', func: 'removeItem'
      });
    }
  }
}
229672
public static void removeCSSClass(Element e, String cssclass) {
    String oldval = e.getAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE);
    if(oldval == null) {
      return;
    }
    String[] classes = oldval.split(" ");
    if(classes.length == 1) {
      if(cssclass.equals(classes[0])) {
        e.removeAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE);
      }
    }
    else if(classes.length == 2) {
      if(cssclass.equals(classes[0])) {
        if(cssclass.equals(classes[1])) {
          e.removeAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE);
        }
        else {
          e.setAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE, classes[1]);
        }
      }
      else if(cssclass.equals(classes[1])) {
        e.setAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE, classes[0]);
      }
    }
    else {
      StringBuilder joined = new StringBuilder();
      for(String c : classes) {
        if(!c.equals(cssclass)) {
          if(joined.length() > 0) {
            joined.append(' ');
          }
          joined.append(c);
        }
      }
      e.setAttribute(SVGConstants.SVG_CLASS_ATTRIBUTE, joined.toString());
    }
  }