Responsys.mergeListMembersRIID call

        Accepts:
            InteractObject list_
            RecordData record_data
            ListMergeRule merge_rule

        Returns a RecipientResult
551525
def merge_list_members_RIID(self, list_, record_data, merge_rule):
        
        list_ = list_.get_soap_object(self.client)
        result = self.call('mergeListMembersRIID', list_, record_data, merge_rule)
        return RecipientResult(result.recipientResult)
1112048
def merge_data(path_data, request_data):
    
    merged = request_data.copy() if request_data else {}
    merged.update(path_data or {})
    return merged
600043
private void sendMemberListToOthers() {
        if (!clusterService.isMaster() || !clusterService.isJoined()
                || clusterService.getClusterJoinManager().isMastershipClaimInProgress()) {
            if (logger.isFineEnabled()) {
                logger.fine("Cannot publish member list to cluster. Is-master: "
                        + clusterService.isMaster() + ", joined: " + clusterService.isJoined()
                        + " , mastership claim in progress: " + clusterService.getClusterJoinManager()
                                                                              .isMastershipClaimInProgress());
            }

            return;
        }

        MemberMap memberMap = getMemberMap();
        MembersView membersView = memberMap.toMembersView();

        if (logger.isFineEnabled()) {
            logger.fine("Sending member list to the non-master nodes: " + memberListString());
        }

        for (MemberImpl member : memberMap.getMembers()) {
            if (member.localMember()) {
                continue;
            }

            MembersUpdateOp op = new MembersUpdateOp(member.getUuid(), membersView,
                    clusterService.getClusterTime(), null, false);
            op.setCallerUuid(clusterService.getThisUuid());
            nodeEngine.getOperationService().send(op, member.getAddress());
        }
    }
905800
public Record openMergeRecord()
    {
        String strClassName = this.getProperty("mergeRecordClass");
        if (strClassName != null)
            return Record.makeRecordFromClassName(strClassName, this);
        return null;    // Or override this
    }
1218303
@SuppressWarnings({ "rawtypes", "unchecked" })
	private void mergeResponsesNamedList(NamedList<Object> mainResponse, NamedList<Object> shardResponse)
			throws IOException {
		Iterator<Entry<String, Object>> it = shardResponse.iterator();
		while (it.hasNext()) {
			Entry<String, Object> entry = it.next();
			String name = entry.getKey();
			Object shardValue = entry.getValue();
			int originalId = mainResponse.indexOf(name, 0);
			if (originalId < 0) {
				mainResponse.add(name, adjustablePartsCloned(shardValue));
			} else {
				Object original = mainResponse.getVal(originalId);
				if (original == null) {
					original = adjustablePartsCloned(shardValue);
				} else if (shardValue != null && original.getClass().equals(shardValue.getClass())) {
					// merge ArrayList
					if (original instanceof ArrayList) {
						ArrayList originalList = (ArrayList) original;
						ArrayList shardList = (ArrayList) shardValue;
						mergeResponsesArrayList(originalList, shardList);
						// merge Namedlist
					} else if (original instanceof NamedList<?>) {
						mergeResponsesNamedList((NamedList<Object>) original, (NamedList<Object>) shardValue);
						// merge SortedSet
					} else if (original instanceof SortedSet<?>) {
						mergeResponsesSortedSet((SortedSet<Object>) original, (SortedSet<Object>) shardValue);
					} else if (original instanceof MtasSolrMtasResult) {
						MtasSolrMtasResult originalComponentResult = (MtasSolrMtasResult) original;
						originalComponentResult.merge((MtasSolrMtasResult) shardValue);
					} else if (original instanceof MtasSolrCollectionResult) {
						MtasSolrCollectionResult originalComponentResult = (MtasSolrCollectionResult) original;
						originalComponentResult.merge((MtasSolrCollectionResult) shardValue);
					} else if (original instanceof String) {
						// ignore?
					} else if (original instanceof Integer) {
						original = (Integer) original + ((Integer) shardValue);
					} else if (original instanceof Long) {
						original = (Long) original + ((Long) shardValue);
					} else {
						// ignore?
					}
					mainResponse.setVal(originalId, original);
				} else {
					// ignore?
				}
			}
		}
	}
611827
@Override
    public final Set<IPersonAttributes> mergeResults(final Set<IPersonAttributes> toModify, final Set<IPersonAttributes> toConsider) {
        Validate.notNull(toModify, "toModify cannot be null");
        Validate.notNull(toConsider, "toConsider cannot be null");

        //Convert the toModify Set into a Map to allow for easier lookups
        final Map<String, IPersonAttributes> toModfyPeople = new LinkedHashMap<>();
        for (final IPersonAttributes toModifyPerson : toModify) {
            toModfyPeople.put(toModifyPerson.getName(), toModifyPerson);
        }

        //Merge in the toConsider people
        for (final IPersonAttributes toConsiderPerson : toConsider) {
            final String toConsiderName = toConsiderPerson.getName();
            final IPersonAttributes toModifyPerson = toModfyPeople.get(toConsiderName);

            //No matching toModify person, just add the new person
            if (toModifyPerson == null) {
                toModify.add(toConsiderPerson);
            }
            //Matching toModify person, merge their attributes
            else {
                final Map<String, List<Object>> toModifyAttributes = this.buildMutableAttributeMap(toModifyPerson.getAttributes());
                final Map<String, List<Object>> mergedAttributes = this.mergePersonAttributes(toModifyAttributes, toConsiderPerson.getAttributes());
                final NamedPersonImpl mergedPerson = new NamedPersonImpl(toConsiderName, mergedAttributes);

                //Remove then re-add the mergedPerson entry
                toModify.remove(mergedPerson);
                toModify.add(mergedPerson);
            }
        }

        return toModify;
    }
1215054
public void sendMemberListToMember(Address target) {
        clusterServiceLock.lock();
        try {
            if (!clusterService.isMaster() || !clusterService.isJoined()) {
                if (logger.isFineEnabled()) {
                    logger.fine("Cannot publish member list to " + target + ". Is-master: "
                            + clusterService.isMaster() + ", joined: " + clusterService.isJoined());
                }

                return;
            }
            if (clusterService.getThisAddress().equals(target)) {
                return;
            }

            MemberMap memberMap = memberMapRef.get();
            MemberImpl member = memberMap.getMember(target);
            if (member == null) {
                if (logger.isFineEnabled()) {
                    logger.fine("Not member: " + target + ", cannot send member list.");
                }

                return;
            }

            if (logger.isFineEnabled()) {
                logger.fine("Sending member list to member: " + target + " " + memberListString());
            }

            MembersUpdateOp op = new MembersUpdateOp(member.getUuid(), memberMap.toMembersView(),
                    clusterService.getClusterTime(), null, false);
            op.setCallerUuid(clusterService.getThisUuid());
            nodeEngine.getOperationService().send(op, target);
        } finally {
            clusterServiceLock.unlock();
        }
    }
1229895
private boolean canMergeLegacy(String dataStructureName) {
        Object mergePolicy = getMergePolicy(dataStructureName);
        InMemoryFormat inMemoryFormat = getInMemoryFormat(dataStructureName);

        return checkMergePolicySupportsInMemoryFormat(dataStructureName,
                mergePolicy, inMemoryFormat, false, logger);
    }
61949
protected boolean mergeSSLRequired(boolean otherSSLRequired) {
        boolean mergedSSLRequired = false;
        if (collectionMatch.isExactMatch()) {
            mergedSSLRequired = sslRequired && otherSSLRequired;
        } else if (collectionMatch.isPathMatch() || collectionMatch.isExtensionMatch()) {
            mergedSSLRequired = sslRequired || otherSSLRequired;
        }
        return mergedSSLRequired;
    }
10059
function sendToMultiple(send, msg, destinations, type) {
  destinations = destinations instanceof Array && destinations || [destinations];
  destinations.forEach(function(destination) {
    var set, socketIds;
    set = subscriptions[type];
    if ((socketIds = set.members(destination))) {
      return socketIds.slice(0).forEach(function(socketId) {
        if (!send.socketId(socketId, msg, destination)) {
          return set.removeFromAll(socketId);
        }
      });
    }
  });
  return true;
}
408013
function createMergedResultFunction(one, two) {
    return function mergedResult() {
      var a = one.apply(this, arguments);
      var b = two.apply(this, arguments);
      if (a == null) {
        return b;
      } else if (b == null) {
        return a;
      }
      var c = {};
      mergeIntoWithNoDuplicateKeys(c, a);
      mergeIntoWithNoDuplicateKeys(c, b);
      return c;
    };
  }
416299
public static <T> void join(Collection<T> collection, String delimiter, StringBuilder sb) {
		join(collection, delimiter, sb, new JoinCallback<T>() {
			public void handle(StringBuilder sb, T value) {
				sb.append(value);
			}
		});
	}
1064589
public static int checkNestedMergedSizeRecords(final Sheet sheet, final List<MergedRecord> records) 
            throws NestedRecordMergedSizeException {
        
        int mergedSize = -1;
        
        for(MergedRecord record : records) {
            
            if(mergedSize < 0) {
                mergedSize = record.getMergedSize();
                continue;
            }
            
            if(mergedSize != record.getMergedSize()) {
                
                String message = MessageBuilder.create("anno.XlsNestedRecords.mergeSizeNoMatch")
                        .var("sheetName", sheet.getSheetName())
                        .var("address", record.getMergedRange().formatAsString())
                        .var("actualMergeSize", record.getMergedSize())
                        .var("expectedMergeSize", mergedSize)
                        .format();
                throw new NestedRecordMergedSizeException(sheet.getSheetName(), record.getMergedSize(), message);
            }
        }
        
        return mergedSize;
        
    }
132865
function mergeEdges(
  sourceEdges: Array<?RecordProxy>,
  targetEdges: Array<?RecordProxy>,
  nodeIDs: Set<mixed>,
): void {
  const {NODE} = RelayConnectionInterface.get();

  for (let ii = 0; ii < sourceEdges.length; ii++) {
    const edge = sourceEdges[ii];
    if (!edge) {
      continue;
    }
    const node = edge.getLinkedRecord(NODE);
    const nodeID = node && node.getValue('id');
    if (nodeID) {
      if (nodeIDs.has(nodeID)) {
        continue;
      }
      nodeIDs.add(nodeID);
    }
    targetEdges.push(edge);
  }
}
1232694
public function addMergeField($listId, array $mergeData)
    {
        $result = $this->mailchimp->post("lists/$listId/merge-fields", $mergeData);

        if (!$this->mailchimp->success()) {
            $this->throwMailchimpError($this->mailchimp->getLastResponse());
        }

        return $result;
    }
1200745
def joinMember(self, JoinInfo):
        
        JoinInfo.LinkID = self.__linkID
        postData = self._stringtify(JoinInfo)
        return self._httppost('/Join', postData)
624048
public function deleteMergeField($listId, $mergeId)
    {
        $result = $this->mailchimp->delete("lists/$listId/merge-fields/$mergeId");

        if (!$this->mailchimp->success()) {
            $this->throwMailchimpError($this->mailchimp->getLastResponse());
        }

        return $result;
    }