Updates the products for a particular target, removing the given existing entries.

    :API: public

    :param target: The target to remove the products for.
    :param products: A list of tuples (conf, path) to remove.
434326
def remove_for_target(self, target, products):
    
    for product in products:
      self._products_by_target[target].discard(product)
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]
            )
1309578
protected function updateProduct()
    {
        $this->controlAccess('product_edit');

        if ($this->product->update($this->data_product['product_id'], $this->getSubmitted())) {
            $this->redirect('admin/content/product', $this->text('Product has been updated'), 'success');
        }

        $this->redirect('', $this->text('Product has not been updated'), 'warning');
    }
104581
def delete_association(self, target, api_type=None, api_sub_type=None, unique_id=None):
        
        api_type = api_type or target.api_type
        api_sub_type = api_sub_type or target.api_sub_type
        unique_id = unique_id or target.unique_id
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        if not target.can_update():
            self._tcex.handle_error(910, [target.type])

        return self.tc_requests.delete_association(
            self.api_type,
            self.api_sub_type,
            self.unique_id,
            api_type,
            api_sub_type,
            unique_id,
            owner=self.owner,
        )
199805
def remove_subproducts(self):
        """"""
        if not self.fullpath or not self.archived:
            raise RuntimeError("""Can't remove a non-archived data product""")
        for root, dirs, files in os.walk(self.subproduct_dir(), topdown=False):
            for name in files:
                try:
                    os.remove(os.path.join(root, name))
                except:
                    pass
            for name in dirs:
                try:
                    os.remove(os.path.join(root, name))
                except:
                    pass
245817
protected function deleteProduct()
    {
        $this->controlAccess('product_delete');

        if ($this->product->delete($this->data_product['product_id'])) {
            $this->redirect('admin/content/product', $this->text('Product has been deleted'), 'success');
        }

        $this->redirect('', $this->text('Product has not been deleted'), 'warning');
    }
925078
def _consolidate_classpath(self, targets, classpath_products):
    
    # TODO: find a way to not process classpath entries for valid VTs.

    # NB: It is very expensive to call to get entries for each target one at a time.
    # For performance reasons we look them all up at once.
    entries_map = defaultdict(list)
    for (cp, target) in classpath_products.get_product_target_mappings_for_targets(targets, True):
      entries_map[target].append(cp)

    with self.invalidated(targets=targets, invalidate_dependents=True) as invalidation:
      for vt in invalidation.all_vts:
        entries = entries_map.get(vt.target, [])
        for index, (conf, entry) in enumerate(entries):
          if ClasspathUtil.is_dir(entry.path):
            jarpath = os.path.join(vt.results_dir, 'output-{}.jar'.format(index))

            # Regenerate artifact for invalid vts.
            if not vt.valid:
              with self.open_jar(jarpath, overwrite=True, compressed=False) as jar:
                jar.write(entry.path)

            # Replace directory classpath entry with its jarpath.
            classpath_products.remove_for_target(vt.target, [(conf, entry.path)])
            classpath_products.add_for_target(vt.target, [(conf, jarpath)])
1141604
def update_association_cache_for(association, target, action=:add)
    return unless association_cached? association
    case action
    when :add
      return if @association_cache[association].collection.include? target
      @association_cache[association].push(target) # don't use `<<` because overriden method in AssociationCollection gets called instead
    when :delete      
      @association_cache[association].delete target
    end
  end
534029
public void removeTarget(T target) {
    for (MethodlessRouter<T> r : routers.values()) r.removeTarget(target);
    anyMethodRouter.removeTarget(target);
  }
290132
def _remove_refs(self, keys):
        
        # remove direct refs
        for key in keys:
            del self.relations[key]
        # then remove all entries from each child
        for cached in self.relations.values():
            cached.release_references(keys)
99383
def add_versioned_targets_to_INSTALLED_FILES(target, source, env):
    
    global _INSTALLED_FILES, _UNIQUE_INSTALLED_FILES
    Verbose = False
    _INSTALLED_FILES.extend(target)
    if Verbose:
        print("add_versioned_targets_to_INSTALLED_FILES: target={:r}".format(list(map(str, target))))
    symlinks = listShlibLinksToInstall(target[0], source, env)
    if symlinks:
        SCons.Tool.EmitLibSymlinks(env, symlinks, target[0])
    _UNIQUE_INSTALLED_FILES = None
    return (target, source)
559480
def remove(self, filename):
        
        files = self.get_value('list', [])
        files.remove(filename)
        self.set_value('list', files)
        self.updated.emit()
357990
def set_target(self, target, ctx=None):
        

        if target is not None:
            # check if target is already intercepted
            if is_intercepted(target):
                # set self interception last target reference
                self._interception = target
                # and targets, ctx
                self.target, self.ctx = get_intercepted(target)
            else:
                # if not, update target reference with new interception
                self.apply_pointcut(target, ctx=ctx)
510348
def unlink_version(self, source, target):
        
        if not hasattr(source, REFERENCE_VERSIONS):
            return
        target_uid = api.get_uid(target)
        if target_uid in source.reference_versions[target_uid]:
            # delete the version
            del source.reference_versions[target_uid]
            # persist changes that occured referenced versions
            source._p_changed = 1
        else:
            logger.warn("No version link found on '{}' -> '{}'"
                        .format(repr(source), repr(target)))
505169
public void setProductBuiltInTargeting(com.google.api.ads.admanager.axis.v201805.Targeting productBuiltInTargeting) {
        this.productBuiltInTargeting = productBuiltInTargeting;
    }
183121
def execute(self, sources, target):
        
        fields = self._get_fields_list_from_eps(sources)
        feature_set = set(self.exclude_names)
        target._ml_fields = list(self._clear_field_roles(fields[0], feature_set))
1175311
public void removeTarget(T target) {
    Iterator<Pattern<T>> it = patterns.iterator();
    while (it.hasNext()) {
      Pattern<T> pattern = it.next();
      if (pattern.target().equals(target)) it.remove();
    }

    reverse.remove(target);
  }