private void validate(
File file,
Collection<Exception> exceptions,
Collection<MavenProjectProblem> problems,
Collection<MavenId> unresolvedArtifacts)
throws RemoteException {
for (Exception each : exceptions) {
Maven3ServerGlobals.getLogger().info(each);
if (each instanceof InvalidProjectModelException) {
ModelValidationResult modelValidationResult =
((InvalidProjectModelException) each).getValidationResult();
if (modelValidationResult != null) {
for (Object eachValidationProblem : modelValidationResult.getMessages()) {
problems.add(
MavenProjectProblem.createStructureProblem(
file.getPath(), (String) eachValidationProblem));
}
} else {
problems.add(
MavenProjectProblem.createStructureProblem(
file.getPath(), each.getCause().getMessage()));
}
} else if (each instanceof ProjectBuildingException) {
String causeMessage =
each.getCause() != null ? each.getCause().getMessage() : each.getMessage();
problems.add(MavenProjectProblem.createStructureProblem(file.getPath(), causeMessage));
} else {
problems.add(MavenProjectProblem.createStructureProblem(file.getPath(), each.getMessage()));
}
}
unresolvedArtifacts.addAll(retrieveUnresolvedArtifactIds());
}
public void getNodeValues(
ResolvedDependency node,
Collection<ResolvedArtifact> values,
Collection<ResolvedDependency> connectedNodes) {
values.addAll(node.getModuleArtifacts());
connectedNodes.addAll(node.getChildren());
}
/**
* This method is similar to {@link #getAffectedUsers(Group)} except that it receives some group
* properties. The group properties are passed as parameters since the called of this method may
* want to obtain the related users of the group based in some properties values.
*
* <p>This is useful when the group is being edited and some properties has changed and we need to
* obtain the related users of the group based on the previous group state.
*/
private Collection<String> getAffectedUsers(Group group, String showInRoster, String groupNames) {
// Answer an empty collection if the group is not being shown in users' rosters
if (!"onlyGroup".equals(showInRoster) && !"everybody".equals(showInRoster)) {
return new ArrayList<String>();
}
// Add the users of the group
Collection<String> users = new HashSet<String>(group.getMembers());
users.addAll(group.getAdmins());
// Check if anyone can see this shared group
if ("everybody".equals(showInRoster)) {
// Add all users in the system
for (User user : UserManager.getInstance().getUsers()) {
users.add(user.getUsername());
}
// Add all logged users. We don't need to add all users in the system since only the
// logged ones will be affected.
// users.addAll(SessionManager.getInstance().getSessionUsers());
} else {
// Add the users that may see the group
Collection<Group> groupList = parseGroups(groupNames);
for (Group groupInList : groupList) {
users.addAll(groupInList.getMembers());
users.addAll(groupInList.getAdmins());
}
}
return users;
}
private X509Certificate[] doBuild(X509Certificate[] chain, Collection otherCerts)
throws CertificateException {
try {
PKIXBuilderParameters params = (PKIXBuilderParameters) parameterTemplate.clone();
setDate(params);
// setup target constraints
X509CertSelector selector = new X509CertSelector();
selector.setCertificate(chain[0]);
params.setTargetCertConstraints(selector);
// setup CertStores
Collection certs = new ArrayList();
certs.addAll(Arrays.asList(chain));
if (otherCerts != null) {
certs.addAll(otherCerts);
}
CertStore store =
CertStore.getInstance("Collection", new CollectionCertStoreParameters(certs));
params.addCertStore(store);
// do the build
CertPathBuilder builder = CertPathBuilder.getInstance("PKIX");
PKIXCertPathBuilderResult result = (PKIXCertPathBuilderResult) builder.build(params);
return toArray(result.getCertPath(), result.getTrustAnchor());
} catch (GeneralSecurityException e) {
throw new ValidatorException("PKIX path building failed: " + e.toString(), e);
}
}
Collection<String> getSharedUsersForRoster(Group group, Roster roster) {
String showInRoster = group.getProperties().get("sharedRoster.showInRoster");
String groupNames = group.getProperties().get("sharedRoster.groupList");
// Answer an empty collection if the group is not being shown in users' rosters
if (!"onlyGroup".equals(showInRoster) && !"everybody".equals(showInRoster)) {
return new ArrayList<String>();
}
// Add the users of the group
Collection<String> users = new HashSet<String>(group.getMembers());
users.addAll(group.getAdmins());
// Check if anyone can see this shared group
if ("everybody".equals(showInRoster)) {
// If the user of the roster belongs to the public group then we should return all users
// in the system since they all need to be in the roster with subscription "from"
if (group.isUser(roster.getUsername())) {
// Add all users in the system
for (User user : UserManager.getInstance().getUsers()) {
users.add(user.getUsername());
}
}
} else {
// Add the users that may see the group
Collection<Group> groupList = parseGroups(groupNames);
for (Group groupInList : groupList) {
users.addAll(groupInList.getMembers());
users.addAll(groupInList.getAdmins());
}
}
return users;
}
private void doPostponedFormattingInner(final FileViewProvider key) {
final List<ASTNode> astNodes = myReformatElements.remove(key);
final Document document = key.getDocument();
// Sort ranges by end offsets so that we won't need any offset adjustment after reformat or
// reindent
if (document == null) return;
final VirtualFile virtualFile = key.getVirtualFile();
if (!virtualFile.isValid()) return;
final TreeSet<PostprocessFormattingTask> postProcessTasks =
new TreeSet<PostprocessFormattingTask>();
Collection<Disposable> toDispose = ContainerUtilRt.newArrayList();
try {
// process all roots in viewProvider to find marked for reformat before elements and create
// appropriate range markers
handleReformatMarkers(key, postProcessTasks);
toDispose.addAll(postProcessTasks);
// then we create ranges by changed nodes. One per node. There ranges can intersect. Ranges
// are sorted by end offset.
if (astNodes != null) createActionsMap(astNodes, key, postProcessTasks);
if ("true".equals(System.getProperty("check.psi.is.valid"))
&& ApplicationManager.getApplication().isUnitTestMode()) {
checkPsiIsCorrect(key);
}
while (!postProcessTasks.isEmpty()) {
// now we have to normalize actions so that they not intersect and ordered in most
// appropriate way
// (free reformatting -> reindent -> formatting under reindent)
final List<PostponedAction> normalizedActions =
normalizeAndReorderPostponedActions(postProcessTasks, document);
toDispose.addAll(normalizedActions);
// only in following loop real changes in document are made
for (final PostponedAction normalizedAction : normalizedActions) {
CodeStyleSettings settings =
CodeStyleSettingsManager.getSettings(myPsiManager.getProject());
boolean old = settings.ENABLE_JAVADOC_FORMATTING;
settings.ENABLE_JAVADOC_FORMATTING = false;
try {
normalizedAction.execute(key);
} finally {
settings.ENABLE_JAVADOC_FORMATTING = old;
}
}
}
} finally {
for (Disposable disposable : toDispose) {
//noinspection SSBasedInspection
disposable.dispose();
}
}
}
public Collection<String> getArguments() {
Collection<String> args = new ArrayList<>();
Optional.ofNullable(username).ifPresent(s -> args.addAll(Arrays.asList("-u", s)));
Optional.ofNullable(password).ifPresent(s -> args.addAll(Arrays.asList("-p", s)));
Optional.ofNullable(from)
.ifPresent(d -> args.addAll(Arrays.asList("-f", d.format(DateTimeFormatter.ISO_DATE))));
return args;
}
protected Collection<String> generateSuggestedNames(PyExpression expression) {
Collection<String> candidates =
new LinkedHashSet<String>() {
@Override
public boolean add(String s) {
if (PyNames.isReserved(s)) {
return false;
}
return super.add(s);
}
};
String text = expression.getText();
final Pair<PsiElement, TextRange> selection =
expression.getUserData(PyReplaceExpressionUtil.SELECTION_BREAKS_AST_NODE);
if (selection != null) {
text = selection.getSecond().substring(text);
}
if (expression instanceof PyCallExpression) {
final PyExpression callee = ((PyCallExpression) expression).getCallee();
if (callee != null) {
text = callee.getText();
}
}
if (text != null) {
candidates.addAll(NameSuggesterUtil.generateNames(text));
}
final TypeEvalContext context = TypeEvalContext.userInitiated(expression.getContainingFile());
PyType type = context.getType(expression);
if (type != null && type != PyNoneType.INSTANCE) {
String typeName = type.getName();
if (typeName != null) {
if (type.isBuiltin()) {
typeName = typeName.substring(0, 1);
}
candidates.addAll(NameSuggesterUtil.generateNamesByType(typeName));
}
}
final PyKeywordArgument kwArg =
PsiTreeUtil.getParentOfType(expression, PyKeywordArgument.class);
if (kwArg != null && kwArg.getValueExpression() == expression) {
candidates.add(kwArg.getKeyword());
}
final PyArgumentList argList = PsiTreeUtil.getParentOfType(expression, PyArgumentList.class);
if (argList != null) {
final CallArgumentsMapping result = argList.analyzeCall(PyResolveContext.noImplicits());
if (result.getMarkedCallee() != null) {
final PyNamedParameter namedParameter = result.getPlainMappedParams().get(expression);
if (namedParameter != null) {
candidates.add(namedParameter.getName());
}
}
}
return candidates;
}
private static Collection<DeclarationDescriptor> getAllVariables(LexicalScope scope) {
Collection<DeclarationDescriptor> result = ContainerUtil.newArrayList();
result.addAll(
ScopeUtilsKt.collectDescriptorsFiltered(
scope, DescriptorKindFilter.VARIABLES, MemberScope.Companion.getALL_NAME_FILTER()));
for (ReceiverParameterDescriptor implicitReceiver :
ScopeUtilsKt.getImplicitReceiversHierarchy(scope)) {
result.addAll(DescriptorUtils.getAllDescriptors(implicitReceiver.getType().getMemberScope()));
}
return result;
}
@SuppressWarnings("unchecked")
private Collection<KnowledgePackage> convertCollectionItemsToKnowledgePackages(
Collection loadedObjects) {
Collection<KnowledgePackage> knowledgePackages = new ArrayList<KnowledgePackage>();
knowledgePackages.addAll(loadedObjects);
return knowledgePackages;
}
/**
* This method extracts a collection of tests for a given audit
*
* @return
*/
private void extractTestSet(boolean extractThemeAndCriterion) {
testSet = new HashSet<Test>();
testSet.addAll(auditDataService.getAuditWithTest(this.audit.getId()).getTestList());
if (extractThemeAndCriterion) {
extractThemeAndCriterionSet();
}
}
/** @throws Exception If failed. */
public void testClientAffinity() throws Exception {
GridClientData partitioned = client.data(PARTITIONED_CACHE_NAME);
Collection<Object> keys = new ArrayList<>();
keys.addAll(Arrays.asList(Boolean.TRUE, Boolean.FALSE, 1, Integer.MAX_VALUE));
Random rnd = new Random();
StringBuilder sb = new StringBuilder();
// Generate some random strings.
for (int i = 0; i < 100; i++) {
sb.setLength(0);
for (int j = 0; j < 255; j++)
// Only printable ASCII symbols for test.
sb.append((char) (rnd.nextInt(0x7f - 0x20) + 0x20));
keys.add(sb.toString());
}
// Generate some more keys to achieve better coverage.
for (int i = 0; i < 100; i++) keys.add(UUID.randomUUID());
for (Object key : keys) {
UUID nodeId = grid(0).mapKeyToNode(PARTITIONED_CACHE_NAME, key).id();
UUID clientNodeId = partitioned.affinity(key);
assertEquals(
"Invalid affinity mapping for REST response for key: " + key, nodeId, clientNodeId);
}
}
private static void appendAnnotationAttributeValues(
final Map<String, Collection<String>> results,
final PsiAnnotation annotation,
final PsiDocCommentOwner commentOwner) {
for (String parameter : results.keySet()) {
final Collection<String> values = results.get(parameter);
if (annotation != null) {
final PsiAnnotationMemberValue value = annotation.findDeclaredAttributeValue(parameter);
if (value != null) {
values.addAll(extractValuesFromParameter(value));
}
} else {
values.addAll(extractAnnotationValuesFromJavaDoc(getTextJavaDoc(commentOwner), parameter));
}
}
}
@Override
public Collection<String> findConflicts(
PsiElement element, PsiElement[] elements, UsageInfo[] usages) {
String methodRefFound = null;
if (!ApplicationManager.getApplication().isUnitTestMode()
&& (element instanceof PsiMethod || element instanceof PsiParameter)) {
for (UsageInfo usage : usages) {
final PsiElement refElement = usage.getElement();
if (refElement instanceof PsiMethodReferenceExpression) {
methodRefFound = RefactoringBundle.message("expand.method.reference.warning");
break;
}
}
}
if (methodRefFound != null) {
Collection<String> result = new ArrayList<>();
result.add(methodRefFound);
final Collection<String> conflicts = super.findConflicts(element, elements, usages);
if (conflicts != null) {
result.addAll(conflicts);
}
return result;
}
return super.findConflicts(element, elements, usages);
}
@NotNull
public static Collection<ClassDescriptor> getClassOrObjectDescriptorsByFqName(
@NotNull ResolveSession resolveSession,
@NotNull FqName fqName,
boolean includeObjectDeclarations) {
if (fqName.isRoot()) {
return Collections.emptyList();
}
Collection<ClassDescriptor> classDescriptors = Lists.newArrayList();
FqName packageFqName = fqName.parent();
while (true) {
NamespaceDescriptor packageDescriptor =
resolveSession.getPackageDescriptorByFqName(packageFqName);
if (packageDescriptor != null) {
FqName classInPackagePath = new FqName(QualifiedNamesUtil.tail(packageFqName, fqName));
Collection<ClassDescriptor> descriptors =
getClassOrObjectDescriptorsByFqName(
packageDescriptor, classInPackagePath, includeObjectDeclarations);
classDescriptors.addAll(descriptors);
}
if (packageFqName.isRoot()) {
break;
} else {
packageFqName = packageFqName.parent();
}
}
return classDescriptors;
}
// 删除
@RequestMapping(value = "/delete", method = RequestMethod.POST)
@ResponseBody
public Object del(String ids) {
Map map = new HashMap();
int result = 0;
Collection collection = new ArrayList();
for (String id : ids.split("&")) {
List<ControlBaseInfo> controlBaseInfos =
controlBaseInfoService.selectByBaseMer(Long.valueOf(id));
if (controlBaseInfos.size() == 0) {
result = baseMerService.deleteByPrimaryKey(Long.valueOf(id));
} else {
collection.addAll(controlBaseInfos);
}
}
map.put("state", result);
if (!collection.isEmpty()) {
map.put(
"controlBaseInfos",
BeanUtil.getCollection2JSON(collection, "controlBaseInfos", "controlmername", true));
}
return map;
}
/**
* Core sentiment detection method. doNota = none of the above
*
* @param captions (null/none = all)
*/
public Map<String, Collection<Document>> getEmotions(
Indexer indexer,
Collection<Document> docs,
boolean doNota,
boolean originalContentOnly,
String... captions) {
Collection<Lexicon1Lang> lexicons = getRelevantLexicon1Langs(docs);
Map<String, Collection<Document>> result = new LinkedHashMap<>();
Set<Document> docs_set = Util.castOrCloneAsSet(docs);
// aggregate results for each lang into result
for (Lexicon1Lang lex : lexicons) {
Map<String, Collection<Document>> resultsForThisLang =
(doNota
? lex.getEmotionsWithNOTA(indexer, docs_set, originalContentOnly)
: lex.getEmotions(indexer, docs_set, originalContentOnly, captions));
if (resultsForThisLang == null) continue;
for (String caption : resultsForThisLang.keySet()) {
Collection<Document> resultDocsThisLang = resultsForThisLang.get(caption);
Collection<Document> resultDocs = result.get(caption);
// if caption doesn't exist already, create a new entry, or else add to the existing set of
// docs that match this caption
if (resultDocs == null) result.put(caption, resultDocsThisLang);
else resultDocs.addAll(resultDocsThisLang);
}
}
// TODO: the result can be cached at server to avoid redundant computation (by concurrent users,
// which are few for now)
return result;
}
protected Collection<PsiElement> classGoToDeclaration(PsiElement psiElement, String className) {
Collection<PsiElement> psiElements = new HashSet<PsiElement>();
// Class::method
// Class::FooAction
// Class:Foo
if (className.contains(":")) {
String[] split = className.replaceAll("(:)\\1", "$1").split(":");
if (split.length == 2) {
for (String append : new String[] {"", "Action"}) {
Method classMethod =
PhpElementsUtil.getClassMethod(psiElement.getProject(), split[0], split[1] + append);
if (classMethod != null) {
psiElements.add(classMethod);
}
}
}
return psiElements;
}
// ClassName
psiElements.addAll(PhpElementsUtil.getClassesInterface(psiElement.getProject(), className));
return psiElements;
}
private void removeSharedGroupFromRoster(Group group, String username) {
// Get the group users to remove from the user's roster
Collection<String> users = new HashSet<String>(group.getMembers());
users.addAll(group.getAdmins());
// Get the roster of the user from which we need to remove the shared group users
Roster userRoster = (Roster) CacheManager.getCache("username2roster").get(username);
// Iterate on all the group users and update their rosters
for (String userToRemove : users) {
// Get the roster to update
Roster roster = (Roster) CacheManager.getCache("username2roster").get(userToRemove);
// Only update rosters in memory
if (roster != null) {
roster.deleteSharedUser(group, username);
}
// Update the roster of the user
if (userRoster != null) {
try {
User user = UserManager.getInstance().getUser(userToRemove);
Collection<Group> groups = GroupManager.getInstance().getGroups(user);
userRoster.deleteSharedUser(userToRemove, groups, group);
} catch (UserNotFoundException e) {
}
}
}
}
/** @return Not null, read only and of type <tt>String</tt>. */
public Collection getHiddenTableColumns() throws XavaException {
if (hiddenTableColumns == null) {
hiddenTableColumns = getTableColumns(getHiddenPropertiesNames());
hiddenTableColumns.addAll(getCmpFieldsColumnsInMultipleProperties());
}
return hiddenTableColumns;
}
private void processElements(
Attribute attribute,
CssElementType elementType,
Map<String, Collection<FileObject>> elements2files) {
CharSequence value = attribute.unquotedValue();
if (value == null) {
return;
}
if (value.length() == 0) {
return; // ignore empty value
}
// all files containing the id declaration
Collection<FileObject> filesWithTheId = elements2files.get(value.toString());
// all referred files with the id declaration
Collection<FileObject> referredFilesWithTheId = new LinkedList<FileObject>();
if (filesWithTheId != null) {
referredFilesWithTheId.addAll(filesWithTheId);
referredFilesWithTheId.retainAll(referredFiles);
}
if (referredFilesWithTheId.isEmpty()) {
// unknown id
hints.add(
new MissingCssElement(
rule, context, getAttributeValueOffsetRange(attribute, context), filesWithTheId));
}
}
public void add(NullAnalysisResult duplicate) {
for (int i = 0; i < groupedByValue.length; i++) {
Collection<PsiElement> elements = groupedByValue[i];
Collection<PsiElement> other = duplicate.groupedByValue[i];
elements.addAll(other);
}
}
public Collection<Change> getAllChanges() {
final Collection<Change> changes = new HashSet<Change>();
for (LocalChangeList list : myMap.values()) {
changes.addAll(list.getChanges());
}
return changes;
}
@Override
public void rebuildList() {
if (myInRebuildList) return;
try {
myInRebuildList = true;
if (myChangesToDisplay == null) {
// changes set not fixed === local changes
final ChangeListManager manager = ChangeListManager.getInstance(myProject);
myChangeListsMap = new HashMap<Change, LocalChangeList>();
final List<LocalChangeList> lists = manager.getChangeListsCopy();
Collection<Change> allChanges = new ArrayList<Change>();
for (LocalChangeList list : lists) {
final Collection<Change> changes = list.getChanges();
allChanges.addAll(changes);
for (Change change : changes) {
myChangeListsMap.put(change, list);
}
}
myAllChanges = allChanges;
// refresh selected list also
updateListsInChooser();
}
super.rebuildList();
if (myRebuildListListener != null) {
myRebuildListListener.run();
}
} finally {
myInRebuildList = false;
}
}
// look up and apply coarts for given rels to each sign in result
private void applyCoarts(List<String> coartRels, Collection<Sign> result) {
List<Sign> inputSigns = new ArrayList<Sign>(result);
result.clear();
List<Sign> outputSigns = new ArrayList<Sign>(inputSigns.size());
// for each rel, lookup coarts and apply to input signs, storing results in output signs
for (Iterator<String> it = coartRels.iterator(); it.hasNext(); ) {
String rel = it.next();
Collection<String> preds = (Collection<String>) _coartRelsToPreds.get(rel);
if (preds == null) continue; // not expected
Collection<Sign> coartResult = getSignsFromRelAndPreds(rel, preds);
if (coartResult == null) continue;
for (Iterator<Sign> it2 = coartResult.iterator(); it2.hasNext(); ) {
Sign coartSign = it2.next();
// apply to each input
for (int j = 0; j < inputSigns.size(); j++) {
Sign sign = inputSigns.get(j);
grammar.rules.applyCoart(sign, coartSign, outputSigns);
}
}
// switch output to input for next iteration
inputSigns.clear();
inputSigns.addAll(outputSigns);
outputSigns.clear();
}
// add results back
result.addAll(inputSigns);
}
public void checkRedeclarationsInInnerClassNames(@NotNull TopDownAnalysisContext c) {
for (ClassDescriptorWithResolutionScopes classDescriptor : c.getDeclaredClasses().values()) {
if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
// Class objects should be considered during analysing redeclarations in classes
continue;
}
Collection<DeclarationDescriptor> allDescriptors =
classDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors();
ClassDescriptorWithResolutionScopes classObj = classDescriptor.getClassObjectDescriptor();
if (classObj != null) {
Collection<DeclarationDescriptor> classObjDescriptors =
classObj.getScopeForMemberLookup().getOwnDeclaredDescriptors();
if (!classObjDescriptors.isEmpty()) {
allDescriptors = Lists.newArrayList(allDescriptors);
allDescriptors.addAll(classObjDescriptors);
}
}
Multimap<Name, DeclarationDescriptor> descriptorMap = HashMultimap.create();
for (DeclarationDescriptor desc : allDescriptors) {
if (desc instanceof ClassDescriptor || desc instanceof PropertyDescriptor) {
descriptorMap.put(desc.getName(), desc);
}
}
reportRedeclarations(descriptorMap);
}
}
@Override
protected void setInitialSelection(
List<? extends ChangeList> changeLists,
List<Change> changes,
ChangeList initialListSelection) {
myAllChanges = new ArrayList<Change>();
mySelectedChangeList = initialListSelection;
for (ChangeList list : changeLists) {
if (list instanceof LocalChangeList) {
myAllChanges.addAll(list.getChanges());
if (initialListSelection == null) {
for (Change c : list.getChanges()) {
if (changes.contains(c)) {
mySelectedChangeList = list;
break;
}
}
}
}
}
if (mySelectedChangeList == null) {
for (ChangeList list : changeLists) {
if (list instanceof LocalChangeList && ((LocalChangeList) list).isDefault()) {
mySelectedChangeList = list;
break;
}
}
if (mySelectedChangeList == null && !changeLists.isEmpty()) {
mySelectedChangeList = changeLists.get(0);
}
}
}
@Override
public void collectMethods(
@NotNull final GrTypeDefinition clazz, @NotNull Collection<PsiMethod> collector) {
Set<PsiClass> processed = new HashSet<PsiClass>();
if (!checkForDelegate(clazz)) return;
Map<MethodSignature, PsiMethod> signatures =
new THashMap<MethodSignature, PsiMethod>(
MethodSignatureUtil.METHOD_PARAMETERS_ERASURE_EQUALITY);
initializeSignatures(clazz, PsiSubstitutor.EMPTY, signatures, processed);
List<PsiMethod> methods = new ArrayList<PsiMethod>();
process(
clazz,
PsiSubstitutor.EMPTY,
true,
new HashSet<PsiClass>(),
processed,
methods,
clazz,
false);
final Set<PsiMethod> result = new LinkedHashSet<PsiMethod>();
for (PsiMethod method : methods) {
addMethodChecked(signatures, method, PsiSubstitutor.EMPTY, result);
}
collector.addAll(result);
}
/**
* JUnit.
*
* @throws Exception If failed.
*/
public void testGetAndIncrement() throws Exception {
Collection<Long> res = new HashSet<>();
String seqName = UUID.randomUUID().toString();
for (int i = 0; i < GRID_CNT; i++) {
Set<Long> retVal =
compute(grid(i).cluster().forLocal()).call(new GetAndIncrementJob(seqName, RETRIES));
for (Long l : retVal) assert !res.contains(l) : "Value already was used " + l;
res.addAll(retVal);
}
assert res.size() == GRID_CNT * RETRIES;
int gapSize = 0;
for (long i = 0; i < GRID_CNT * RETRIES; i++) {
if (!res.contains(i)) gapSize++;
else gapSize = 0;
assert gapSize <= BATCH_SIZE + 1
: "Gap above id " + i + " is " + gapSize + " more than batch size: " + (BATCH_SIZE + 1);
}
}
public Runnable prepareMergeRunnable() {
Map<MapContainer, Collection<Record>> recordMap =
new HashMap<MapContainer, Collection<Record>>(mapContainers.size());
InternalPartitionService partitionService = nodeEngine.getPartitionService();
int partitionCount = partitionService.getPartitionCount();
Address thisAddress = nodeEngine.getClusterService().getThisAddress();
for (MapContainer mapContainer : mapContainers.values()) {
for (int i = 0; i < partitionCount; i++) {
RecordStore recordStore = getPartitionContainer(i).getRecordStore(mapContainer.getName());
// add your owned entries to the map so they will be merged
if (thisAddress.equals(partitionService.getPartitionOwner(i))) {
Collection<Record> records = recordMap.get(mapContainer);
if (records == null) {
records = new ArrayList<Record>();
recordMap.put(mapContainer, records);
}
records.addAll(recordStore.getReadonlyRecordMap().values());
}
// clear all records either owned or backup
recordStore.reset();
}
}
return new Merger(recordMap);
}
