Removes a whole document revision.
 _index_:: Revision index, first is 0.
509748
def remove_revision(index)
            if index < 0 or index > @revisions.size
                raise IndexError, "Not a valid revision index"
            end

            if @revisions.size == 1
                raise InvalidPDFError, "Cannot remove last revision"
            end

            @revisions.delete_at(index)
            self
        end
509065
def undone(self, index):
        
        if self.model.exists(index):
            self.model.edit(index, done=False)
1256343
def removeTab(self, index):
        
        curr_index = self.currentIndex()
        items = list(self.items())

        item = items[index]
        item.close()
        if index <= curr_index:
            self._currentIndex -= 1
272720
def removeByIndex(self, index):
        """"""
        if index < len(self._invites) -1 and \
           index >=0:
            self._invites.remove(index)
576473
def remove_label(self, doc, label, update_index=True):
        
        doc.remove_label(label)
        if update_index:
            self.upd_doc(doc)
            self.commit()
1254129
synchronized int removeAllDocuments(String uuid) throws IOException
   {
      synchronized (updateMonitor)
      {
         //updateInProgress = true;
         indexUpdateMonitor.setUpdateInProgress(true, false);
      }
      int num;
      try
      {
         Term idTerm = new Term(FieldNames.UUID, uuid.toString());
         executeAndLog(new Start(Action.INTERNAL_TRANSACTION));
         num = volatileIndex.removeDocument(idTerm);
         if (num > 0)
         {
            redoLog.append(new DeleteNode(getTransactionId(), uuid));
         }
         for (int i = 0; i < indexes.size(); i++)
         {
            PersistentIndex index = indexes.get(i);
            // only remove documents from registered indexes
            if (indexNames.contains(index.getName()))
            {
               int removed = index.removeDocument(idTerm);
               if (removed > 0)
               {
                  redoLog.append(new DeleteNode(getTransactionId(), uuid));
               }
               num += removed;
            }
         }
         executeAndLog(new Commit(getTransactionId()));
      }
      finally
      {
         synchronized (updateMonitor)
         {
            //updateInProgress = false;
            indexUpdateMonitor.setUpdateInProgress(false, false);
            updateMonitor.notifyAll();
            releaseMultiReader();
         }
      }
      return num;
   }
682639
def destroy(bulk=false)
      caught = catch(:halt)  do
        _run_destroy_callbacks do
          result = database.delete_doc(self, bulk)
          if result['ok']
            self.delete('_rev')
            self.delete('_id')
          end
          result['ok']
        end
      end
    end
378568
def delete_mapping(self, index, doc_type):
        
        path = make_path(index, doc_type)
        return self.conn._send_request('DELETE', path)
1181490
def remove(self, visualization):
        
        res = self.es.delete(index=self.index, id=visualization.id, doc_type=self.doc_type, refresh=True)
        return res
318773
def delete_doc(self, doc_id, revision):
        ''''''
        d = defer.Deferred()

        self.increase_stat('delete_doc')

        try:
            doc = self._get_doc(doc_id)
            if doc['_rev'] != revision:
                raise ConflictError("Document update conflict.")
            if doc.get('_deleted', None):
                raise NotFoundError('%s deleted' % doc_id)
            doc['_deleted'] = True
            self._expire_cache(doc['_id'])
            for key in doc.keys():
                if key in ['_rev', '_deleted', '_id']:
                    continue
                del(doc[key])
            self.log('Marking document %r as deleted', doc_id)
            del self._attachments[doc['_id']]
            self._update_rev(doc)
            self._analize_changes(doc)
            d.callback(Response(ok=True, id=doc_id, rev=doc['_rev']))
        except (ConflictError, NotFoundError, ) as e:
            d.errback(e)

        return d
1011817
public function clearDocument()
    {
        $this->version = '1.0';
        $this->href = null;
        $this->scope = null;
        $this->attributes = new \StdClass();
        $this->links = new \StdClass();
        $this->items = [];
        $this->errors = null;
        return $this;
    }
677308
def remove(self, item):
        ''
        i = self.index(item)
        del self._keys[i]
        del self._items[i]
1074457
def destroy(self):
        """"""
        self._refresh_connection()

        self.push_queue = []
        index_name = self.document_class()._get_index()  # pylint: disable=protected-access
        connections.get_connection().indices.delete(index_name, ignore=404)

        self._mapping_created = False
247523
def delete_index(self,*fields):
        """"""
        for f in fields:
            if not f in self.indices:
                raise ValueError,"No index on field %s" %f
        for f in fields:
            del self.indices[f]
        self.commit()
21235
def remove(self, tab_index):
        """"""
        _id = id(self.editor.tabs.widget(tab_index))
        if _id in self.history:
            self.history.remove(_id)
1330884
def remove(self, index):
        
        data = self.data
        index = self._split(index)
        for j, c in enumerate(index):
            i = int(c) - 1
            if j + 1 == len(index):
                try:
                    del data[i]
                except IndexError:
                    raise NoItemError('.'.join(index))
            else:
                data = data[i][4]
1163923
def clear(self, models=None, commit=True):
        
        for language in self.languages:
            self.log.debug('clearing index for {0}'.format(language))
            self.index_name = self._index_name_for_language(language)
            super(ElasticsearchMultilingualSearchBackend, self).clear(models, commit)
        self._reset_existing_mapping()