Merge the other criteria into this one.

 @example Merge another criteria into this criteria.
   criteria.merge(Person.where(name: "bob"))

 @param [ Criteria ] other The criteria to merge in.

 @return [ Criteria ] The merged criteria.

 @since 3.0.0
187380
def merge!(other)
      criteria = other.to_criteria
      selector.merge!(criteria.selector)
      options.merge!(criteria.options)
      self.documents = criteria.documents.dup unless criteria.documents.empty?
      self.scoping_options = criteria.scoping_options
      self.inclusions = (inclusions + criteria.inclusions).uniq
      self
    end
1191874
def merge(self, others, merge_conditions, common_ancestor=None): # pylint: disable=unused-argument
        

        changed_bytes = self._changes_to_merge(others)

        l.info("Merging %d bytes", len(changed_bytes))
        l.info("... %s has changed bytes %s", self.id, changed_bytes)

        self.read_strategies = self._merge_strategies(self.read_strategies, *[
            o.read_strategies for o in others
        ])
        self.write_strategies = self._merge_strategies(self.write_strategies, *[
            o.write_strategies for o in others
        ])
        merged_bytes = self._merge(others, changed_bytes, merge_conditions=merge_conditions)

        return len(merged_bytes) > 0
687216
def merge_conditions(conditions)
      @conditions = Conditions::Operation.new(:and) << @conditions unless @conditions.nil?

      conditions.compact!
      conditions.each do |condition|
        case condition
          when Conditions::AbstractOperation, Conditions::AbstractComparison
            add_condition(condition)

          when Hash
            condition.each { |key, value| append_condition(key, value) }

          when Array
            statement, *bind_values = *condition
            raw_condition = [ statement ]
            raw_condition << bind_values if bind_values.size > 0
            add_condition(raw_condition)
            @raw = true
        end
      end
    end
346338
def +(other)
      other = other.to_days if other.respond_to?(:to_days)
      ISO8601::Date.new((@date + other).iso8601)
    end
883568
public void mergeFrom(final FieldSet<FieldDescriptorType> other) {
    for (int i = 0; i < other.fields.getNumArrayEntries(); i++) {
      mergeFromField(other.fields.getArrayEntryAt(i));
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
             other.fields.getOverflowEntries()) {
      mergeFromField(entry);
    }
  }
610060
public boolean merge(ResourceMetadata other) {
        boolean modified = m_metrics.addAll(other.m_metrics);
        if (!modified) {
            modified = !m_attributes.equals(other.m_attributes);
        }
        m_attributes.putAll(other.m_attributes);
        return modified;
    }
424283
def merge(self, other):
        
        newstart = min(self._start, other.start)
        newend = max(self._end, other.end)
        return Range(newstart, newend)
145150
public GoogRequire merge(GoogRequire other) {
    checkArgument(other.symbol().equals(symbol()));
    if (other.equals(this)) {
      return this;
    }
    // if symbols are equal and the references are, then they must differ only by requireType or not
    // prefer the non requireType symbol
    if ((other.chunk() instanceof VariableDeclaration
            && chunk() instanceof VariableDeclaration
            && ((VariableDeclaration) chunk())
                .varName()
                .equals(((VariableDeclaration) other.chunk()).varName()))
        || (!(chunk() instanceof VariableReference)
            && !(other.chunk() instanceof VariableDeclaration))) {
      if (other.isTypeRequire()) {
        return this;
      }
      return other;
    }
    throw new IllegalArgumentException(
        "Found the same namespace added as a require in multiple incompatible ways: "
            + other
            + " vs. "
            + this);
  }
447083
def join(self, other):
        
        return Heading(
            [self.attributes[name].todict() for name in self.primary_key] +
            [other.attributes[name].todict() for name in other.primary_key if name not in self.primary_key] +
            [self.attributes[name].todict() for name in self.dependent_attributes if name not in other.primary_key] +
            [other.attributes[name].todict() for name in other.dependent_attributes if name not in self.primary_key])
932388
def merge(self, other):
        
        if not isinstance(other, one):
            other = one(other)
        new = concatenate((self.coordinates, other.coordinates))
        unique = set([tuple(x) for x in new.tolist()])
        final = asarray([list(x) for x in unique])
        return one(final)
61722
public ParameterTool mergeWith(ParameterTool other) {
		final Map<String, String> resultData = new HashMap<>(data.size() + other.data.size());
		resultData.putAll(data);
		resultData.putAll(other.data);

		final ParameterTool ret = new ParameterTool(resultData);

		final HashSet<String> requestedParametersLeft = new HashSet<>(data.keySet());
		requestedParametersLeft.removeAll(unrequestedParameters);

		final HashSet<String> requestedParametersRight = new HashSet<>(other.data.keySet());
		requestedParametersRight.removeAll(other.unrequestedParameters);

		ret.unrequestedParameters.removeAll(requestedParametersLeft);
		ret.unrequestedParameters.removeAll(requestedParametersRight);

		return ret;
	}
1065629
def +(other)
      case other
      when Offset
        Offset.new(self.line + other.line, self.column + other.column)
      when Integer
        Offset.new(self.line + other, self.column)
      else
        raise ArgumentError, "can't convert #{other} into #{self.class}"
      end
    end
1130755
public Filter<S> mergeRemainderFilter(CompositeScore<S> other) {
        return getFilteringScore().mergeRemainderFilter(other.getFilteringScore());
    }
252720
def union(self, other):
        
        if isinstance(other, self.__class__):
            return self.client.sunion([self.name, other.name])
        else:
            return self._as_set().union(other)
870254
def merge(other)
      m1, t1 = resolved_modifier.downcase, resolved_type.downcase
      m2, t2 = other.resolved_modifier.downcase, other.resolved_type.downcase
      t1 = t2 if t1.empty?
      t2 = t1 if t2.empty?
      if (m1 == 'not') ^ (m2 == 'not')
        return if t1 == t2
        type = m1 == 'not' ? t2 : t1
        mod = m1 == 'not' ? m2 : m1
      elsif m1 == 'not' && m2 == 'not'
        # CSS has no way of representing "neither screen nor print"
        return unless t1 == t2
        type = t1
        mod = 'not'
      elsif t1 != t2
        return
      else # t1 == t2, neither m1 nor m2 are "not"
        type = t1
        mod = m1.empty? ? m2 : m1
      end
      Query.new([mod], [type], other.expressions + expressions)
    end
1136211
public void merge(final TagRequirements other) {
        if (other != null) {
            matchAllOf.addAll(other.matchAllOf);
            matchOneOf.addAll(other.matchOneOf);
        }
    }
1300360
def merge!(another)
      configs = self.configs
      another.each_pair do |key, value|
        if config = configs[key]
          config.set(receiver, value)
        else
          store[key] = value
        end
      end
      self
    end