Merge the contents of the given manifest into this one.
350662
public boolean merge(final ManifestAccess other) {
    boolean _xblockexpression = false;
    {
      String _path = this.getPath();
      String _path_1 = other.getPath();
      boolean _notEquals = (!Objects.equal(_path, _path_1));
      if (_notEquals) {
        String _path_2 = this.getPath();
        String _plus = ("Merging manifest files with different paths: " + _path_2);
        String _plus_1 = (_plus + ", ");
        String _path_3 = other.getPath();
        String _plus_2 = (_plus_1 + _path_3);
        ManifestAccess.LOG.warn(_plus_2);
      }
      boolean _notEquals_1 = (!Objects.equal(this.bundleName, other.bundleName));
      if (_notEquals_1) {
        if ((this.bundleName == null)) {
          this.bundleName = other.bundleName;
        } else {
          if ((other.bundleName != null)) {
            ManifestAccess.LOG.warn(((("Merging manifest files with different bundle names: " + this.bundleName) + ", ") + other.bundleName));
          }
        }
      }
      boolean _notEquals_2 = (!Objects.equal(this.symbolicName, other.symbolicName));
      if (_notEquals_2) {
        if ((this.symbolicName == null)) {
          this.symbolicName = other.symbolicName;
        } else {
          if ((other.symbolicName != null)) {
            ManifestAccess.LOG.warn(((("Merging manifest files with different symbolic names: " + this.symbolicName) + ", ") + other.symbolicName));
          }
        }
      }
      boolean _notEquals_3 = (!Objects.equal(this.activator, other.activator));
      if (_notEquals_3) {
        if ((this.activator == null)) {
          this.activator = other.activator;
        } else {
          if ((other.activator != null)) {
            ManifestAccess.LOG.warn(((("Merging manifest files with different activators: " + this.activator) + ", ") + other.activator));
          }
        }
      }
      boolean _notEquals_4 = (!Objects.equal(this.version, other.version));
      if (_notEquals_4) {
        ManifestAccess.LOG.warn(((("Merging manifest files with different versions: " + this.version) + ", ") + other.version));
      }
      if ((this.merge != other.merge)) {
        ManifestAccess.LOG.warn("Merging manifest files with different merging settings.");
      }
      this.exportedPackages.addAll(other.exportedPackages);
      this.requiredBundles.addAll(other.requiredBundles);
      if ((this.symbolicName != null)) {
        this.requiredBundles.remove(this.getEffectiveSymbolicName());
      }
      _xblockexpression = this.importedPackages.addAll(other.importedPackages);
    }
    return _xblockexpression;
  }
534092
def MergeMessage(
      self, source, destination,
      replace_message, replace_repeated):
    """"""
    _MergeMessage(
        self._root, source, destination, replace_message, replace_repeated)
1183822
def _add_manifest_files(zip_file, dir_name, payload_info_list, tag_info_list):
    """"""
    for checksum_algorithm in _get_checksum_algorithm_set(payload_info_list):
        _add_tag_file(
            zip_file,
            dir_name,
            tag_info_list,
            _gen_manifest_file_tup(payload_info_list, checksum_algorithm),
        )
996470
def merge(directory, message, branch_label, rev_id, revisions):
    """"""
    _merge(directory, revisions, message, branch_label, rev_id)
634703
public void writeManifest(final Manifest manifest) throws IOException {
        JarEntry entry = new JarEntry("META-INF/MANIFEST.MF");
        writeEntry(entry, new EntryWriter() {
            @Override
            public void write(OutputStream outputStream) throws IOException {
                manifest.write(outputStream);
            }
        });
    }
266236
def merge(self, other):
        
        for this, other in zip(self.stats, other.stats):
            this.merge(other)
460039
def add_to_manifest(self, manifest):
        
        manifest.add_service(self.service.name)
        manifest.write_manifest()
718878
public void merge(ExtractionResult extractionResult) {
		for (Result result : extractionResult.results) {
			add(result.getObject(), result.getResultName());
		}
	}
1169201
private void mergeModComps(List<ModifiedCompound> modComps) {
		TreeSet<Integer> remove = new TreeSet<Integer>();
		int n = modComps.size();
		for (int icurr=1; icurr<n; icurr++) {
			ModifiedCompound curr = modComps.get(icurr);

			String id = curr.getModification().getId();
			if (ProteinModificationRegistry.getById(id).getCategory()
					!=ModificationCategory.UNDEFINED)
				continue;

			// find linked compounds that before curr
			//List<Integer> merging = new ArrayList<Integer>();
			int ipre = 0;
			for (; ipre<icurr; ipre++) {
				if (remove.contains(ipre))	continue;
				ModifiedCompound pre = modComps.get(ipre);
				if (!Collections.disjoint(pre.getGroups(false),
						curr.getGroups(false))) {
					break;
				}
			}

			if (ipre<icurr) {
				ModifiedCompound mcKeep = modComps.get(ipre);

				// merge modifications of the same type
				if (mcKeep.getModification().getId().equals(id)) {
					// merging the current one to the previous one
					mcKeep.addAtomLinkages(curr.getAtomLinkages());
					remove.add(icurr);
				}
			}
		}

		Iterator<Integer> it = remove.descendingIterator();
		while (it.hasNext()) {
			modComps.remove(it.next().intValue());
		}
	}
881778
public static function merge(&$context, $tmp) {
        $context['error'] = $tmp['error'];
        $context['helpers'] = $tmp['helpers'];
        $context['partials'] = $tmp['partials'];
        $context['partialCode'] = $tmp['partialCode'];
        $context['partialStack'] = $tmp['partialStack'];
        $context['usedCount'] = $tmp['usedCount'];
        $context['usedFeature'] = $tmp['usedFeature'];
        $context['usedPartial'] = $tmp['usedPartial'];
    }
645328
private String merge(final String first, final String[] more) {
        assert first != null : "first must be specified";
        assert more != null : "more must be specified";

        final StringBuilder merged = new StringBuilder();
        merged.append(first);
        for (int i = 0; i < more.length; i++) {
            merged.append(ArchivePath.SEPARATOR);
            merged.append(more[i]);
        }
        return merged.toString();

    }
60968
function reduceManifestBundles(input, manifest) {
  // If manifest doesn't have any bundles, then no reducing to do
  if (!manifest.bundles) {
    return input;
  }

  // Merge the bundles together, checking for collisions
  return Object.keys(manifest.bundles).reduce((output, bundle) => {
    Ember.assert(`The bundle "${bundle}" already exists.`, !output.bundles[bundle]);
    output.bundles[bundle] = manifest.bundles[bundle];
    return output;
  }, input);
}
1151020
def merge(directory=None, revisions='', message=None, branch_label=None,
          rev_id=None):
    """"""
    if alembic_version >= (0, 7, 0):
        config = current_app.extensions['migrate'].migrate.get_config(
            directory)
        command.merge(config, revisions, message=message,
                      branch_label=branch_label, rev_id=rev_id)
    else:
        raise RuntimeError('Alembic 0.7.0 or greater is required')
78257
def merge(self, other):
        """"""
        other.qindex.normalize, other.qindex.num_best = False, self.topsims
        # update precomputed "most similar" for old documents (in case some of
        # the new docs make it to the top-N for some of the old documents)
        logger.info("updating old precomputed values")
        pos, lenself = 0, len(self.qindex)
        for chunk in self.qindex.iter_chunks():
            for sims in other.qindex[chunk]:
                if pos in self.pos2id:
                    # ignore masked entries (deleted, overwritten documents)
                    docid = self.pos2id[pos]
                    sims = self.sims2scores(sims)
                    self.id2sims[docid] = merge_sims(self.id2sims[docid], sims, self.topsims)
                pos += 1
                if pos % 10000 == 0:
                    logger.info("PROGRESS: updated doc #%i/%i" % (pos, lenself))
        self.id2sims.sync()

        logger.info("merging fresh index into optimized one")
        pos, docids = 0, []
        for chunk in other.qindex.iter_chunks():
            for vec in chunk:
                if pos in other.pos2id: # don't copy deleted documents
                    self.qindex.add_documents([vec])
                    docids.append(other.pos2id[pos])
                pos += 1
        self.qindex.save()
        self.update_ids(docids)

        logger.info("precomputing most similar for the fresh index")
        pos, lenother = 0, len(other.qindex)
        norm, self.qindex.normalize = self.qindex.normalize, False
        topsims, self.qindex.num_best = self.qindex.num_best, self.topsims
        for chunk in other.qindex.iter_chunks():
            for sims in self.qindex[chunk]:
                if pos in other.pos2id:
                    # ignore masked entries (deleted, overwritten documents)
                    docid = other.pos2id[pos]
                    self.id2sims[docid] = self.sims2scores(sims)
                pos += 1
                if pos % 10000 == 0:
                    logger.info("PROGRESS: precomputed doc #%i/%i" % (pos, lenother))
        self.qindex.normalize, self.qindex.num_best = norm, topsims
        self.id2sims.sync()
1213311
def merge(self, pdf_files, output):
        """"""
        if self.method is 'pypdf3':
            return self.pypdf3(pdf_files, output)
        else:
            return self.pdfrw(pdf_files, output)
348952
def create_manifest_from_s3_files(self):
        
        for k in self.s3.list_objects(Bucket=self.sitename)['Contents']:
            key = k["Key"]
            files = []
            if key not in [self.manifest_file]:
                files.append(key)
            self._set_manifest_data(files)
1269962
def merge(self, item):
        """"""
        self.name = item.name

        if item.icon:
            self.icon = item.icon

        if item.url:
            self.url = item.url

        if item.order:
            self.order = item.order

        if item.permission:
            self.permission = item.permission