Delete percolator associated with the new collection.

    :param target: Collection where the percolator was attached.
517395
def delete_collection_percolator(target):
    
    for name in current_search.mappings.keys():
        if target.name and target.dbquery:
            current_search.client.delete(
                index=name,
                doc_type='.percolator',
                id='collection-{}'.format(target.name),
                ignore=[404]
            )
902920
def delete(self):
        
        for related_collection_name in self.related_collections:
            related_collection = getattr(self, related_collection_name)
            related_collection.remove_instance()
        return super(RelatedModel, self).delete()
734894
public void deleteTarget( String targetId ) throws TargetWsException {

		this.logger.finer( "Deleting target " + targetId  );

		WebResource path = this.resource.path( UrlConstants.TARGETS ).path( targetId );
		ClientResponse response = this.wsClient.createBuilder( path )
						.accept( MediaType.APPLICATION_JSON )
						.delete( ClientResponse.class );

		handleResponse( response );
	}
1072265
def delete(self):
        
        target = DeviceTarget(self.device_id)
        return self._fssapi.delete_file(target, self.path)[self.device_id]
547204
public void removeTarget(Object key) throws MatchingException
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc,
                  "removeTarget",
                  new Object[]{key});
    // Remove from the HashMap, with synch, there may be other accessors
    synchronized(_targets)
    {
      Target targ = (Target) _targets.get(key);
      if (targ == null)
        throw new MatchingException();
      for (int i = 0; i < targ.targets.length; i++)
        _matchSpace.removeTarget(targ.expr[i], targ.targets[i]);

      // Now remove the Target from the cache
      _targets.remove(key);

      // Remove from the Monitor state, with synch, there may be other accessors
      if(targ.targets.length > 0) // Defect 417084, check targets is non-empty
      {
        if(targ.targets[0] instanceof MonitoredConsumer)
          _consumerMonitoring.removeConsumer((MonitoredConsumer)targ.targets[0]);
      }
    }
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "removeTarget");
  }
949935
def clear(self):
        
        # The del_binfo() call here isn't necessary for normal execution,
        # but is for interactive mode, where we might rebuild the same
        # target and need to start from scratch.
        self.del_binfo()
        self.clear_memoized_values()
        self.ninfo = self.new_ninfo()
        self.executor_cleanup()
        try:
            delattr(self, '_calculated_sig')
        except AttributeError:
            pass
        self.includes = None
20397
def pipe(self, target):
        
        return self._replace(recver=self.recver.pipe(target))
534029
public void removeTarget(T target) {
    for (MethodlessRouter<T> r : routers.values()) r.removeTarget(target);
    anyMethodRouter.removeTarget(target);
  }
688937
def _delete(self, pk):
        
        item = self.datamodel.get(pk, self._base_filters)
        if not item:
            abort(404)
        try:
            self.pre_delete(item)
        except Exception as e:
            flash(str(e), "danger")
        else:
            if self.datamodel.delete(item):
                self.post_delete(item)
            flash(*self.datamodel.message)
            self.update_redirect()
74809
def new_collection_percolator(target):
    
    query = IQ(target.dbquery)
    for name in current_search.mappings.keys():
        if target.name and target.dbquery:
            current_search.client.index(
                index=name,
                doc_type='.percolator',
                id='collection-{}'.format(target.name),
                body={'query': query.to_dict()}
            )
1047163
public void ip_delegation_target_DELETE(String ip, String target) throws IOException {
		String qPath = "/ip/{ip}/delegation/{target}";
		StringBuilder sb = path(qPath, ip, target);
		exec(qPath, "DELETE", sb.toString(), null);
	}
1294673
def remove_target(self, target_id):
        """"""
        updated_targets = []
        for target in self.my_osid_object_form._my_map['targets']:
            if target['id'] != target_id:
                updated_targets.append(target)
        self.my_osid_object_form._my_map['targets'] = updated_targets
21646
def delete(self):
        
        # Delete each field
        for field_name in self._fields:
            field = self.get_field(field_name)
            if not isinstance(field, PKField):
                # pk has no stored key
                field.delete()
        # Remove the pk from the model collection
        self.connection.srem(self.get_field('pk').collection_key, self._pk)
        # Deactivate the instance
        delattr(self, "_pk")
1045134
def rename(self, target):
        
        if self._closed:
            self._raise_closed()
        self._accessor.rename(self, target)
1318796
public <T extends AbstractJaxb> boolean remove(T target) {
        String id = target.getId();
        if (id == null) {
            for (int i = 0; i < 256; i++) {
                id = UUID.randomUUID().toString();
                if (this.getById(id) == null) {
                    target.setId(id);
                    break;
                }
            }
        }
        return RemoveByIdUtil.removeById(id, this);
    }
991267
public static <T> boolean removeAllIterable(Iterable<? extends T> iterable, Collection<T> targetCollection)
    {
        if (iterable == null)
        {
            throw new NullPointerException();
        }
        if (iterable instanceof Collection<?>)
        {
            return targetCollection.removeAll((Collection<T>) iterable);
        }
        int oldSize = targetCollection.size();
        Iterate.forEachWith(iterable, Procedures2.<T>removeFromCollection(), targetCollection);
        return targetCollection.size() != oldSize;
    }
1364871
def delete_overwrite(target, reason = nil)
      raise 'Tried deleting a overwrite for an invalid target' unless target.is_a?(Member) || target.is_a?(User) || target.is_a?(Role) || target.is_a?(Profile) || target.is_a?(Recipient) || target.respond_to?(:resolve_id)

      API::Channel.delete_permission(@bot.token, @id, target.resolve_id, reason)
    end