Return whether `self` depends on `other` and will be instanciated
        later.

        :param other: Another service.
        :type other: :class:`aioxmpp.service.Service`

        .. versionadded:: 0.11
175439
def orders_after(self, other, *, visited=None):
        
        return self.orders_after_any(frozenset([other]), visited=visited)
728876
def is_correct(self):
        
        state = True

        # Internal checks before executing inherited function...
        loop = self.no_loop_in_parents("service_description", "dependent_service_description")
        if loop:
            msg = "Loop detected while checking service dependencies"
            self.add_error(msg)
            state = False
            for item in self:
                for elem in loop:
                    if elem == item.service_description:
                        msg = "Service %s is parent service_description in dependency "\
                              "defined in %s" % (
                                  item.service_description_string, item.imported_from
                              )
                        self.add_error(msg)
                    elif elem == item.dependent_service_description:
                        msg = "Service %s is child service_description in dependency"\
                              " defined in %s" % (
                                  item.dependent_service_description_string, item.imported_from
                              )
                        self.add_error(msg)

        return super(Servicedependencies, self).is_correct() and state
874642
def is_not_equal_to(self, other):
        
        self._run(unittest_case.assertNotEqual, (self._subject, other))
        return ChainInspector(self._subject)
1135328
function (other) {
            var self = this;
            // port and hostname has to be same
            return equalsIgnoreCase(self.hostname, other['hostname']) &&
                equalsIgnoreCase(self.scheme, other['scheme']) &&
                equalsIgnoreCase(self.port, other['port']);
        }
428153
def otherrole(self, otherrole):
        
        if otherrole is not None:
            self._el.set('ROLE', 'OTHER')
            self._el.set('OTHERROLE', otherrole)
54594
def **(other)
      if other.is_a?(Numeric)
        new(value ** other, unit ** other)
      else
        fail TypeError, "Can't raise #{self} to #{other} power."
      end
    end
124955
def union_update(self, other):
        
        if not isinstance(other, Set):
            raise ValueError('other must be a Set instance')
        if self is other:
            return
        for item in other.items:
            self.add(item)
1322414
def is_entailed_by(self, other):
        
        other = IntervalCell.coerce(other)
        return other.low >= self.low and other.high <= self.high
765077
def _is_compatible_with(self, other):
        

        title = self._compare_title(other)
        suffix = self._compare_suffix(other)

        return title and suffix
1073087
def eq_or_parent(self, other):
        
        return self.parts[: len(other.parts)] == other.parts[: len(self.parts)]
261768
def validate_matches(other):
    
    def matches_validator(field, data):
        if field.value is None:
            return
        if not (field.value == data.get(other)):
            raise ValidationError('matches', other=other)
    return matches_validator
1171167
def relation(self, other):  # type: (Term) -> int
        
        if self.dependency.name != other.dependency.name:
            raise ValueError(
                "{} should refer to {}".format(other, self.dependency.name)
            )

        other_constraint = other.constraint

        if other.is_positive():
            if self.is_positive():
                if not self._compatible_dependency(other.dependency):
                    return SetRelation.DISJOINT

                # foo ^1.5.0 is a subset of foo ^1.0.0
                if other_constraint.allows_all(self.constraint):
                    return SetRelation.SUBSET

                # foo ^2.0.0 is disjoint with foo ^1.0.0
                if not self.constraint.allows_any(other_constraint):
                    return SetRelation.DISJOINT

                return SetRelation.OVERLAPPING
            else:
                if not self._compatible_dependency(other.dependency):
                    return SetRelation.OVERLAPPING

                # not foo ^1.0.0 is disjoint with foo ^1.5.0
                if self.constraint.allows_all(other_constraint):
                    return SetRelation.DISJOINT

                # not foo ^1.5.0 overlaps foo ^1.0.0
                # not foo ^2.0.0 is a superset of foo ^1.5.0
                return SetRelation.OVERLAPPING
        else:
            if self.is_positive():
                if not self._compatible_dependency(other.dependency):
                    return SetRelation.SUBSET

                # foo ^2.0.0 is a subset of not foo ^1.0.0
                if not other_constraint.allows_any(self.constraint):
                    return SetRelation.SUBSET

                # foo ^1.5.0 is disjoint with not foo ^1.0.0
                if other_constraint.allows_all(self.constraint):
                    return SetRelation.DISJOINT

                # foo ^1.0.0 overlaps not foo ^1.5.0
                return SetRelation.OVERLAPPING
            else:
                if not self._compatible_dependency(other.dependency):
                    return SetRelation.OVERLAPPING

                # not foo ^1.0.0 is a subset of not foo ^1.5.0
                if self.constraint.allows_all(other_constraint):
                    return SetRelation.SUBSET

                # not foo ^2.0.0 overlaps not foo ^1.0.0
                # not foo ^1.5.0 is a superset of not foo ^1.0.0
                return SetRelation.OVERLAPPING
1165554
def difference(self, *others):
        
        others = self._typesafe_others(others)
        return set(map(
            self._loads, self._client.sdiff(self.key_prefix, *others)))
1111379
def merge(self, other):
        
        other = IntervalCell.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.low, self.high = other.low, other.high
        elif self.is_contradictory(other):
            #import traceback
            #for line in traceback.format_stack(): print line.strip()

            raise Contradiction("Cannot merge [%0.2f, %0.2f] with [%0.2f, %0.2f]" \
                    % (self.low, self.high, other.low, other.high))
        else:
            # information in both
            self.low = max(self.low, other.low)
            self.high = min(self.high, other.high)
        return self
657451
public boolean isNewerThan(UpdateEntry other) {
    return other == null || other.value == null || (value != null && value.isNewerThan(other.value));
  }
645259
def unioniter(self, *others):
        
        others = self._typesafe_others(others)
        for other in self._client.sunion(self.key_prefix, *others):
            yield self._loads(other)
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