Update the set, removing any elements from other which are not
        in both sets.
        @param other: the collection of items with which to update the set
        @type other: Set object
420503
def intersection_update(self, other):
        
        if not isinstance(other, Set):
            raise ValueError('other must be a Set instance')
        if self is other:
            return
        # we make a copy of the list so that we can remove items from
        # the list without breaking the iterator.
        for item in list(self.items):
            if item not in other.items:
                self.items.remove(item)
1058115
def intersection_update(self, other):
        
        ivs = list(self)
        for iv in ivs:
            if iv not in other:
                self.remove(iv)
574367
def issuperset(self, other):
        

        if not isinstance(other, Set):
            raise ValueError('other must be a Set instance')
        for item in other.items:
            if not item in self.items:
                return False
        return True
433094
public void increment(PairCountAccumulator<A,B> other) {
    for (A key1 : other.counts.keySet()) {
      for (B key2 : other.counts.get(key1).keySet()) {
        double value = other.getCount(key1, key2);
        incrementOutcome(key1, key2, value);
      }
    }
  }
499427
def update(self, other):
        
        if other.model._meta.abstract:
            self.local_fields.update(other.local_fields)
        self.fields.update(other.fields)
1345029
def update(self, other):
        
        self.procedures.update(other.procedures)
        self.non_returning.update(other.non_returning)
        self.prototypes.update(other.prototypes)
        self.default_ccs.update(other.default_ccs)
468819
def intersection_update(self, other):
        """"""
        return self.client.sinterstore(self.name, [self.name, other.name])
1116054
def update(self, other):
        

        acceptable_models = [ m for m in other._models if set(m.model.keys()) == self.variables ]
        self._models.update(acceptable_models)
        self._eval_exhausted.update(other._eval_exhausted)
        self._max_exhausted.update(other._max_exhausted)
        self._min_exhausted.update(other._min_exhausted)
499067
def merge(self, other):
        
        other.qualify()
        for n in ('name',
                  'qname',
                  'min',
                  'max',
                  'default',
                  'type',
                  'nillable',
                  'form_qualified',):
            if getattr(self, n) is not None:
                continue
            v = getattr(other, n)
            if v is None:
                continue
            setattr(self, n, v)
137065
def update(self, other):
        

        self.globals.update(other.globals)
        self.locals.update(other.locals)
        return self
1096400
def _iand(self, other):
		
		# TODO do we have to create a bag from the other first?
		if not isinstance(other, _basebag):
			other = self._from_iterable(other)
		for elem, old_count in set(self.counts()):
			other_count = other.count(elem)
			new_count = min(other_count, old_count)
			self._set_count(elem, new_count)
		return self
1112324
def difference_update(self, *iterables):
        
        _set = self._set
        values = set(chain(*iterables))
        if (4 * len(values)) > len(_set):
            _list = self._list
            _set.difference_update(values)
            _list.clear()
            _list.update(_set)
        else:
            _discard = self.discard
            for value in values:
                _discard(value)
        return self
69104
def update(self, other):
        
        if type(self) != type(other):
            return NotImplemented
        else:
            if other.bad:
                self.error = other.error
                self.bad = True
            self._fieldDict.update(other._fieldDict)
905963
public void update( Pattern52 other ) {
        setBoundName( other.getBoundName() );
        setChildColumns( other.getChildColumns() );
        setEntryPointName( other.getEntryPointName() );
        setFactType( other.getFactType() );
        setNegated( other.isNegated() );
        setWindow( other.getWindow() );
    }
1136211
public void merge(final TagRequirements other) {
        if (other != null) {
            matchAllOf.addAll(other.matchAllOf);
            matchOneOf.addAll(other.matchOneOf);
        }
    }
1214340
def update(self, other, copy=True, *args, **kwargs):
        """"""

        if other:  # dirty hack for python2.6

            if isinstance(other, self.__class__):

                if copy:
                    other = other.copy(*args, **kwargs)

                for slot in other.__slots__:
                    attr = getattr(other, slot)
                    if attr is not None:
                        setattr(self, slot, attr)

            else:
                raise TypeError(
                    'Wrong element to update with {0}: {1}'.format(self, other)
                )

        return self
973644
def update(self, other):
        """"""
        if isinstance(other, self.__class__):
            return self.client.sunionstore(self.name, [self.name, other.name])
        else:
            return map(self.add, other)