Java Code Examples for com.google.common.collect.Multimap#containsKey()

protected void computeAllFeatures(List<JvmFeature> unfiltered, Multimap<String, AbstractResolvedOperation> processedOperations, List<JvmFeature> result) {
	for(JvmFeature feature: unfiltered) {
		if (feature instanceof JvmOperation) {
			String simpleName = feature.getSimpleName();
			if (processedOperations.containsKey(simpleName)) {
				if (parent.isOverridden((JvmOperation) feature, processedOperations.get(simpleName))) {
					continue;
				}
			}
			BottomResolvedOperation resolvedOperation = parent.createResolvedOperation((JvmOperation) feature, type);
			processedOperations.put(simpleName, resolvedOperation);
			result.add(feature);
		} else {
			result.add(feature);
		}
	}
}
 

public static Multimap<String, String> generateFilterSetWithDimensionMap(DimensionMap dimensionMap,
    Multimap<String, String> filterSet) {

  Multimap<String, String> newFilterSet = HashMultimap.create();

  // Dimension map gives more specified dimension information than filter set (i.e., Dimension Map should be a subset
  // of filterSet), so it needs to be processed first.
  if (MapUtils.isNotEmpty(dimensionMap)) {
    for (Map.Entry<String, String> dimensionMapEntry : dimensionMap.entrySet()) {
      newFilterSet.put(dimensionMapEntry.getKey(), dimensionMapEntry.getValue());
    }
  }

  if (filterSet != null && filterSet.size() != 0) {
    for (String key : filterSet.keySet()) {
      if (!newFilterSet.containsKey(key)) {
        newFilterSet.putAll(key, filterSet.get(key));
      }
    }
  }

  return newFilterSet;
}
 

protected void computeAllOperations(boolean isSuperClassBranch, Multimap<String, AbstractResolvedOperation> superClassBranchOperations,
		JvmDeclaredType type, Multimap<String, AbstractResolvedOperation> processedOperations) {
	for (JvmOperation operation: type.getDeclaredOperations()) {
		boolean addToResult = true;
		if (targetVersion.isAtLeast(JavaVersion.JAVA8)) {
			addToResult = handleOverridesAndConflicts(isSuperClassBranch, operation, processedOperations, superClassBranchOperations);
		} else {
			String simpleName = operation.getSimpleName();
			if (processedOperations.containsKey(simpleName)) {
				addToResult = !isOverridden(operation, processedOperations.get(simpleName));
			}
		}
		if (addToResult) {
			BottomResolvedOperation resolvedOperation = createResolvedOperation(operation);
			processedOperations.put(operation.getSimpleName(), resolvedOperation);
			if (isSuperClassBranch) {
				superClassBranchOperations.put(operation.getSimpleName(), resolvedOperation);
			}
		}
	}
}
 

@Override
public PartialResult holdsOnGuards(Multimap<GuardType, Guard> neverHolding,
		Multimap<GuardType, Guard> alwaysHolding) {

	if (alwaysHolding.containsKey(GuardType.InState)) {
		// TODO: change from GuardType to Guard
		// Guard guard = alwaysHolding.get(GuardType.InState);
		// Collection<String> inStates = getDeclaredStates(guard.condition, ANNOTATION_INSTATE);
		// if (!inStates.isEmpty()) {
		// if (guard.asserts == HoldAssertion.AlwaysHolds) {
		// preStates.addAll(inStates);
		// }
		// if (guard.asserts == HoldAssertion.NeverHolds) {
		// preStates.clear();
		// preStates.addAll(inStates);
		// }
		// }
	}
	return PartialResult.Unclear;
}
 

@Override
public PartialResult holdsOnGuards(Multimap<GuardType, Guard> neverHolding,
		Multimap<GuardType, Guard> alwaysHolding) {

	if (alwaysHolding.containsKey(GuardType.IsTruthy)) {
		return PartialResult.Passed;
	}
	if (neverHolding.containsKey(GuardType.IsNull) && neverHolding.containsKey(GuardType.IsUndefined)) {
		return PartialResult.Passed;
	}
	if (alwaysHolding.containsKey(GuardType.IsNull)) {
		return new NullDereferenceFailed(GuardType.IsNull);
	}
	if (alwaysHolding.containsKey(GuardType.IsUndefined)) {
		return new NullDereferenceFailed(GuardType.IsUndefined);
	}

	return PartialResult.Unclear;
}
 

protected void checkDispatchNonDispatchConflict(XtendClass clazz,
		Multimap<DispatchHelper.DispatchSignature, JvmOperation> dispatchMethods) {
	if(isIgnored(DISPATCH_PLAIN_FUNCTION_NAME_CLASH)) {
		return;
	}
	Multimap<DispatchHelper.DispatchSignature, XtendFunction> nonDispatchMethods = HashMultimap.create();
	for(XtendFunction method: filter(clazz.getMembers(), XtendFunction.class)) {
		if(!method.isDispatch()) {
			nonDispatchMethods.put(new DispatchHelper.DispatchSignature(method.getName(), method.getParameters().size()), method);
		}
	}
	for (DispatchHelper.DispatchSignature dispatchSignature : dispatchMethods.keySet()) {
		if (nonDispatchMethods.containsKey(dispatchSignature)) {
			for (XtendFunction function : nonDispatchMethods.get(dispatchSignature))
				addIssue("Non-dispatch method has same name and number of parameters as dispatch method", function,
						XTEND_FUNCTION__NAME,
						DISPATCH_PLAIN_FUNCTION_NAME_CLASH);
			for (JvmOperation operation : dispatchMethods.get(dispatchSignature))
				addIssue("Dispatch method has same name and number of parameters as non-dispatch method", associations.getXtendFunction(operation),
						XTEND_FUNCTION__NAME,
						DISPATCH_PLAIN_FUNCTION_NAME_CLASH);
		}
	}
}
 

static Collection<List<Function>> findMetricFunctions(Multimap<String, List<Function>> metricFunctions,
                                                       String metricName) {
  if (metricFunctions.containsKey(metricName)) {
    return metricFunctions.get(metricName);
  }

  for (String metricNameEntry : metricFunctions.keySet()) {
    String metricRegEx = getJavaRegexFromSqlRegex(metricNameEntry);
    if (metricName.matches(metricRegEx)) {
      return metricFunctions.get(metricNameEntry);
    }
  }

  return null;
}
 

@Override
public PartialResult holdsOnGuards(Multimap<GuardType, Guard> neverHolding,
		Multimap<GuardType, Guard> alwaysHolding) {

	if (alwaysHolding.containsKey(GuardType.IsZero)) {
		// TODO
		// return new PartialResult.Failed(GuardType.IsZero);
	}
	if (neverHolding.containsKey(GuardType.IsZero)) {
		return PartialResult.Passed;
	}
	return PartialResult.Unclear;
}
 

private static void copyZip(
    CustomZipOutputStream out,
    Path from,
    Set<Path> seenFiles,
    Multimap<String, Integer> allowedEntries)
    throws IOException {
  try (ZipInputStream in =
      new ZipInputStream(new BufferedInputStream(Files.newInputStream(from)))) {
    int position = 0;
    for (ZipEntry entry = in.getNextEntry();
        entry != null;
        entry = in.getNextEntry(), position++) {
      if (!allowedEntries.containsKey(entry.getName())) {
        continue;
      }
      if (!allowedEntries.get(entry.getName()).contains(position)) {
        continue;
      }
      if (entry.isDirectory()) {
        seenFiles.add(Paths.get(entry.getName()));
      }
      CustomZipEntry customEntry = new CustomZipEntry(entry);
      customEntry.setFakeTime();
      out.putNextEntry(customEntry);
      ByteStreams.copy(in, out);
      out.closeEntry();
    }
  }
}
 

private static void checkReferencedModulesExist(Multimap<String, String> moduleDependenciesMap) {
  for (String referencedModule : moduleDependenciesMap.values()) {
    if (!moduleDependenciesMap.containsKey(referencedModule)) {
      throw InvalidBundleException.builder()
          .withUserMessage(
              "Module '%s' is referenced by <uses-split> but does not exist.", referencedModule)
          .build();
    }
  }
}
 

private static void createAccount(PublicKey pubKey, UserInfo userInfo, String loginFilePath, String groupFilePath,
        Properties props, Multimap<String, String> groupsMap) throws ManageUsersException, KeyException {
    if (!userInfo.isLoginSet()) {
        warnWithMessage(PROVIDED_USERNAME + IS_EMPTY_SKIPPING);
        return;
    }
    if (!userInfo.isPasswordSet()) {
        warnWithMessage("Provided password for user " + userInfo.getLogin() + IS_EMPTY_SKIPPING);
        return;
    }
    if (!userInfo.isGroupSet()) {
        warnWithMessage("Provided groups for user " + userInfo.getLogin() + IS_EMPTY_SKIPPING);
        return;
    }
    if (props.containsKey(userInfo.getLogin())) {
        warnWithMessage(USER_HEADER + userInfo.getLogin() + ALREADY_EXISTS_IN_LOGIN_FILE + loginFilePath +
                        UPDATING_THIS_USER_INFORMATION);
    }
    if (groupsMap.containsKey(userInfo.getLogin())) {
        warnWithMessage(USER_HEADER + userInfo.getLogin() + ALREADY_EXISTS_IN_GROUP_FILE + groupFilePath +
                        UPDATING_THIS_USER_INFORMATION);
    }
    updateUserPassword(pubKey, userInfo.getLogin(), userInfo.getPassword(), props);
    updateUserGroups(userInfo.getLogin(), userInfo.getGroups(), groupsMap);
    System.out.println("Created user " + userInfo.getLogin());

}
 

/**
 * Order {@link com.i2group.disco.user.spi.DefaultSecurityDimension}s and default dimension value ids in schema order.
 */
private Collection<com.i2group.disco.user.spi.DefaultSecurityDimension> createOrderedDefaultSecurityDimension(
        SecuritySchema securitySchema, Multimap<String, String> dimensionValueIdsByDimensionId)
{
    final Collection<Dimension> schemaDimensions = securitySchema.getSecurityDimensions().getAccessSecurityPermissions();
    final Collection<com.i2group.disco.user.spi.DefaultSecurityDimension> result = new ArrayList<>();
    for (Dimension schemaDimension : schemaDimensions)
    {
        final String dimensionId = schemaDimension.getId();
        if (dimensionValueIdsByDimensionId.containsKey(dimensionId))
        {
            final Collection<String> valueIds = dimensionValueIdsByDimensionId.get(dimensionId);

            final List<DimensionValue> schemaDimensionValues = schemaDimension.getValues();
            final boolean isOrdered = schemaDimension.isOrdered();
            final Collection<String> orderedValueIds = new ArrayList<>();
            for (DimensionValue schemaDimensionValue : schemaDimensionValues)
            {
                final String schemaDimensionValueId = schemaDimensionValue.getId();
                if (valueIds.contains(schemaDimensionValueId))
                {
                    orderedValueIds.add(schemaDimensionValueId);
                }
                // Only include 1 ordered dimension value id.
                if (isOrdered == true && !orderedValueIds.isEmpty())
                {
                    break;
                }
            }

            final com.i2group.disco.user.spi.DefaultSecurityDimension defaultSecurityDimension = 
                    new com.i2group.disco.user.spi.DefaultSecurityDimension(dimensionId, orderedValueIds);
            result.add(defaultSecurityDimension);
        }
    }
    return result;
}
 

public void peturbBalance() {
    Multimap<TServerInstance,KeyExtent> serverTablets = HashMultimap.create();
    for (Entry<KeyExtent,TServerInstance> entry : tabletLocs.entrySet()) {
        serverTablets.put(entry.getValue(), entry.getKey());
    }
    
    ArrayList<TServerInstance> serversArray = new ArrayList<>(tservers);
    for (int i = 0; i < 101; i++) {
        // Find a random source server that has at least some tablets assigned to it.
        TServerInstance fromServer = serversArray.get(random.nextInt(serversArray.size()));
        while (!serverTablets.containsKey(fromServer)) {
            fromServer = serversArray.get(random.nextInt(serversArray.size()));
        }
        // Find a random destination server that's different.
        TServerInstance toServer;
        do {
            toServer = serversArray.get(random.nextInt(serversArray.size()));
        } while (fromServer.equals(toServer));
        
        ArrayList<KeyExtent> fromExtents = new ArrayList<>(serverTablets.get(fromServer));
        int migrationsToMove = random.nextInt(fromExtents.size());
        for (int j = 0; j < migrationsToMove; j++) {
            KeyExtent extent = fromExtents.get(random.nextInt(fromExtents.size()));
            fromExtents.remove(extent); // we have a local copy
            assertTrue("Couldn't remove extent " + extent + " from server " + fromServer, serverTablets.remove(fromServer, extent));
            assertTrue("Couldn't add extent " + extent + " to server " + toServer, serverTablets.put(toServer, extent));
            assertEquals("Extent " + extent + " wasn't assigned to " + fromServer, fromServer, tabletLocs.put(extent, toServer));
        }
    }
}
 

public static void addProxyHeaders(Multimap<String, String> headers, X509Certificate clientCert) {
    if (clientCert != null) {
        List<String> proxiedEntitiesList = new ArrayList<>();
        if (headers.containsKey(TimelyAuthenticationToken.PROXIED_ENTITIES_HEADER)) {
            String proxiedEntities = HttpHeaderUtils.getSingleHeader(headers,
                    TimelyAuthenticationToken.PROXIED_ENTITIES_HEADER, false);
            headers.removeAll(TimelyAuthenticationToken.PROXIED_ENTITIES_HEADER);
            String[] preExistingProxiedEntities = ProxiedEntityUtils.splitProxiedDNs(proxiedEntities, false);
            if (preExistingProxiedEntities.length > 0) {
                proxiedEntitiesList.addAll(Arrays.asList(preExistingProxiedEntities));
            }
        }
        String subjectDN = DnUtils.normalizeDN(clientCert.getSubjectDN().getName());
        proxiedEntitiesList.add(subjectDN);
        String[] newProxiedEntities = new String[proxiedEntitiesList.size()];
        proxiedEntitiesList.toArray(newProxiedEntities);
        headers.put(TimelyAuthenticationToken.PROXIED_ENTITIES_HEADER,
                ProxiedEntityUtils.buildProxiedDN(newProxiedEntities));

        List<String> proxiedIssuersList = new ArrayList<>();
        if (headers.containsKey(TimelyAuthenticationToken.PROXIED_ISSUERS_HEADER)) {
            String proxiedIssuers = HttpHeaderUtils.getSingleHeader(headers,
                    TimelyAuthenticationToken.PROXIED_ISSUERS_HEADER, false);
            headers.removeAll(TimelyAuthenticationToken.PROXIED_ISSUERS_HEADER);
            String[] preExistingProxiedIssuers = ProxiedEntityUtils.splitProxiedDNs(proxiedIssuers, false);
            if (preExistingProxiedIssuers.length > 0) {
                proxiedEntitiesList.addAll(Arrays.asList(preExistingProxiedIssuers));
            }
        }
        String issuerDN = DnUtils.normalizeDN(clientCert.getIssuerDN().getName());
        proxiedIssuersList.add(issuerDN);
        String[] newProxiedIssuers = new String[proxiedIssuersList.size()];
        proxiedIssuersList.toArray(newProxiedIssuers);
        headers.put(TimelyAuthenticationToken.PROXIED_ISSUERS_HEADER,
                ProxiedEntityUtils.buildProxiedDN(newProxiedIssuers));
    }
}
 

public static byte[] injectMethods(String name, byte[] bytes, Multimap<String, MethodInjector> injectors) {
	if (injectors.containsKey(name)) {
		ClassNode cnode = createClassNode(bytes);

		for (MethodInjector injector : injectors.get(name)) {
			MethodNode method = findMethod(injector.method, cnode);
			if (method == null) {
				throw new RuntimeException("Method not found: " + injector.method);
			}
			Game.logger().info("Injecting into {}\n{}", injector.method, printInsnList(injector.injection));

			List<AbstractInsnNode> callNodes;
			if (injector.before) {
				callNodes = InstructionComparator.insnListFindStart(method.instructions, injector.needle);
			} else {
				callNodes = InstructionComparator.insnListFindEnd(method.instructions, injector.needle);
			}

			if (callNodes.isEmpty()) {
				throw new RuntimeException("Needle not found in Haystack: " + injector.method + "\n" + printInsnList(injector.needle));
			}

			for (AbstractInsnNode node : callNodes) {
				if (injector.before) {
					Game.logger().info("Injected before: {}", printInsn(node));
					method.instructions.insertBefore(node, cloneInsnList(injector.injection));
				} else {
					Game.logger().info("Injected after: {}+", printInsn(node));
					method.instructions.insert(node, cloneInsnList(injector.injection));
				}
			}
		}

		bytes = createBytes(cnode, ClassWriter.COMPUTE_FRAMES);
	}
	return bytes;
}
 

@Override
public boolean processDeclarations(@NotNull PsiScopeProcessor processor, @NotNull ResolveState state, PsiElement lastParent, @NotNull PsiElement place) {
    boolean result = PsiScopesUtil.walkChildrenScopes(this, processor, state, lastParent, place);
    if (!result) {
        //processing is done here
        return false;
    }

    //fixme right file?
    PsiFile containingFile = getContainingFile();
    PsiFile includedFile = BashPsiUtils.findIncludedFile(this);

    Multimap<VirtualFile, PsiElement> visitedFiles = state.get(visitedIncludeFiles);
    if (visitedFiles == null) {
        visitedFiles = Multimaps.newListMultimap(Maps.newHashMap(), Lists::newLinkedList);
    }

    visitedFiles.put(containingFile.getVirtualFile(), null);

    if (includedFile != null && !visitedFiles.containsKey(includedFile.getVirtualFile())) {
        //mark the file as visited before the actual visit, otherwise we'll get a stack overflow
        visitedFiles.put(includedFile.getVirtualFile(), this);

        state = state.put(visitedIncludeFiles, visitedFiles);

        return includedFile.processDeclarations(processor, state, null, place);
    }

    return true;
}
 

@AddCuries
@Override
public Response apply(ContainerRequestContext context) {
  logger.fine("Serving dynamic request");
  Multimap<String, Object> paramMap = MultivaluedMapUtils.merge(context.getUriInfo());
  paramMap = resolveCuries(paramMap);
  try (Transaction tx = graphDb.beginTx()) {
    long start = System.currentTimeMillis();
    start = System.currentTimeMillis();
    Result result = cypherUtil.execute((String)path.getVendorExtensions().get("x-query"), paramMap);
    logger.fine((System.currentTimeMillis() - start) + " to execute query" );
    start = System.currentTimeMillis();
    TinkerGraphUtil tgu = new TinkerGraphUtil(curieUtil);
    Graph graph = tgu.resultToGraph(result);
    tgu.setGraph(graph);
    logger.fine((System.currentTimeMillis() - start) + " to convert to graph" );
    start = System.currentTimeMillis();
    for (String key: aspectMap.keySet()) {
      if ("true".equals(getFirst(paramMap.get(key), "false"))) {
        aspectMap.get(key).invoke(graph);
      }
    }
    if (paramMap.containsKey("project")) {
      @SuppressWarnings("unchecked")
      Collection<String> projection = (Collection<String>)(Collection<?>)paramMap.get("project");
      tgu.project(projection);
    }
    ArrayPropertyTransformer.transform(graph);
    tx.success();
    Object cacheControlNode = path.getVendorExtensions().get("x-cacheControl");
    if (cacheControlNode != null) {
        try {
          CacheControl cacheControl = new ObjectMapper().readValue(cacheControlNode.toString(), CacheControl.class);
          return Response.ok(graph).cacheControl(cacheControl).build();
        }
        catch (Throwable e) {
          return Response.ok(graph).cacheControl(null).build();
        }
    }
    return Response.ok(graph).cacheControl(null).build();
  }
}
 

/**
 * Fetch the list of un-notified anomalies, whose create time is after last notify time
 * @param current the current DateTime
 * @param alertSnapShot the snapshot of the AnomalyFeed
 * @return a list of un-notified anomalies
 */
@Override
public Collection<MergedAnomalyResultDTO> getAlertCandidates(DateTime current, AlertSnapshotDTO alertSnapShot) {
  if (!this.active) {
    LOG.warn("UnnotifiedAnomalyFetcher is not active for fetching anomalies");
    return Collections.emptyList();
  }
  if (StringUtils.isBlank(this.anomalyFetcherConfig.getAnomalySource()) ||
      this.anomalyFetcherConfig.getAnomalySourceType() == null) {
    LOG.error("No entry of {} or {} in the AnomalyFetcherConfig", ANOMALY_SOURCE_TYPE, ANOMALY_SOURCE);
    return Collections.emptyList();
  }

  Period maxAnomalyLookBack = TimeGranularity.fromString(
      this.properties.getProperty(MAXIMUM_ANOMALY_LOOK_BACK_LENGTH, DEFAULT_MAXIMUM_ANOMALY_LOOK_BACK_LENGTH)).toPeriod();

  // Fetch anomalies who are created MAXIMUM_ANOMALY_LOOK_BACK_LENGTH ago
  AnomalySource anomalySourceType = anomalyFetcherConfig.getAnomalySourceType();
  String anomalySource = anomalyFetcherConfig.getAnomalySource();
  Predicate predicate = Predicate.AND(anomalySourceType.getPredicate(anomalySource),
      Predicate.GE("createTime",
          new Timestamp(current.minus(maxAnomalyLookBack).getMillis())));
  Set<MergedAnomalyResultDTO> alertCandidates = new HashSet<>(mergedAnomalyResultDAO.findByPredicate(predicate));

  // parse snapshot to a map, getting the last notified time of given metric::dimension pair
  Multimap<String, AnomalyNotifiedStatus> snapshot = alertSnapShot.getSnapshot();
  if (snapshot.size() == 0) {
    return new ArrayList<>(alertCandidates);
  }

  // filter out alert candidates by snapshot
  Iterator<MergedAnomalyResultDTO> iterator = alertCandidates.iterator();
  while (iterator.hasNext()) {
    MergedAnomalyResultDTO mergedAnomaly = iterator.next();
    String snapshotKey = AlertSnapshotDTO.getSnapshotKey(mergedAnomaly);

    if (snapshot.containsKey(snapshotKey)) {
      // If the mergedAnomaly's create time is before last notify time, discard
      long lastNotifyTime = alertSnapShot.getLatestStatus(snapshot, snapshotKey).getLastNotifyTime();
      if (mergedAnomaly.getCreatedTime() < lastNotifyTime) {
        iterator.remove();
      }
    }
  }

  return alertCandidates;
}
 

/**
 * Fetch continuum anomalies whose end time is after last notify time; that is, the anomaly continues after last alert
 * @param current current DateTime
 * @param alertSnapShot the snapshot of the AnomalyFeed
 * @return a list of continuing merged anomalies
 */
@Override
public Collection<MergedAnomalyResultDTO> getAlertCandidates(DateTime current, AlertSnapshotDTO alertSnapShot) {
  if (!this.active) {
    LOG.warn("ContinuumAnomalyFetcher is not active for fetching anomalies");
    return Collections.emptyList();
  }
  if (StringUtils.isBlank(this.anomalyFetcherConfig.getAnomalySource()) ||
      this.anomalyFetcherConfig.getAnomalySourceType() == null) {
    LOG.error("No entry of {} or {} in the AnomalyFetcherConfig", ANOMALY_SOURCE_TYPE, ANOMALY_SOURCE);
    return Collections.emptyList();
  }

  Period realertFrequency = TimeGranularity.fromString(
      this.properties.getProperty(REALERT_FREQUENCY, DEFAULT_REALERT_FREQUENCY)).toPeriod();
  long maxAnomalyRealertTimestamp = current.minus(realertFrequency).getMillis();

  long lastNotifyTime = Math.max(alertSnapShot.getLastNotifyTime(), maxAnomalyRealertTimestamp);
  AnomalySource anomalySourceType = anomalyFetcherConfig.getAnomalySourceType();
  String anomalySource = anomalyFetcherConfig.getAnomalySource();
  Predicate predicate = Predicate.AND(anomalySourceType.getPredicate(anomalySource),
      Predicate.GE("endTime", lastNotifyTime));
  Set<MergedAnomalyResultDTO> alertCandidates = new HashSet<>(mergedAnomalyResultDAO.findByPredicate(predicate));

  Multimap<String, AnomalyNotifiedStatus> snapshot = alertSnapShot.getSnapshot();
  if (snapshot.size() == 0) {
    return new ArrayList<>(alertCandidates);
  }

  // filter out alert candidates by snapshot
  Iterator<MergedAnomalyResultDTO> alertCandidatesIterator = alertCandidates.iterator();
  while (alertCandidatesIterator.hasNext()) {
    MergedAnomalyResultDTO mergedAnomaly = alertCandidatesIterator.next();
    if (mergedAnomaly.getStartTime() > alertSnapShot.getLastNotifyTime()) {
      // this anomaly start after last notify time, pass without check
      continue;
    }

    String snapshotKey = AlertSnapshotDTO.getSnapshotKey(mergedAnomaly);
    if (snapshot.containsKey(snapshotKey)){
      // If the mergedAnomaly's start time is before last notify time and
      // the last notify time of the metric-dimension isn't REALERT_FREQUENCY ahead, discard
      long metricLastNotifyTime = alertSnapShot.getLatestStatus(snapshot, snapshotKey).getLastNotifyTime();
      if (mergedAnomaly.getStartTime() < metricLastNotifyTime &&
          metricLastNotifyTime < current.minus(realertFrequency).getMillis()) {
        alertCandidatesIterator.remove();
      }
    }
  }

  return alertCandidates;
}
 

public boolean isConnectedToLinkedCompany() {
    Multimap<MapHex,Station> lStations;
    Multimap<MapHex,Station> iStations;
    NetworkGraph nwGraph = NetworkGraph.createMapGraph(getRoot());
    NetworkGraph companyGraph =
            NetworkGraph.createRouteGraph(nwGraph, this, true, false);
    SimpleGraph<NetworkVertex, NetworkEdge> graph =
            companyGraph.getGraph();
    Set<NetworkVertex> verticies = graph.vertexSet();



    PublicCompany_1880 linkedCompany =
            (PublicCompany_1880) ((Investor_1880) this).getLinkedCompany();

    if (linkedCompany != null) {
        NetworkGraph linkedCompanyGraph=NetworkGraph.createRouteGraph(nwGraph, linkedCompany, true, false);
        // Creating a list of stations blocked by tokens.
        // The connection between investor and Linked Company is NOT blocked by any token of any company.
        // A token that is counted as blocked can be reached by the company for which it blocks the route.
        // Based on that logic a blocking token is reachable by both actors.
        lStations = linkedCompanyGraph.getNonPassableStations();
        iStations = companyGraph.getNonPassableStations();
        //Case A) the token in Question from a linked Company is actually on the route of the Investor
        for (BaseToken token : linkedCompany.getLaidBaseTokens()) {
            Owner holder = token.getOwner();
            if (!(holder instanceof Stop)) continue;
            Stop stop = (Stop) holder;
            for (NetworkVertex vertex : verticies) {
                if (vertex.getType() == NetworkVertex.VertexType.STATION) {
                    if ((stop.getRelatedStation() == vertex.getStation())
                            && (stop.getParent() == vertex.getHex())) {
                        return true;
                    }
                }
            }
        }
        // Case B) the Blocking Token is not from the linked Company
        // so we need to check if the MapHex of a blocking station is showing up in the
        // List of non Passable Stations
         for (MapHex blockedHex:lStations.keys()) {
             if (iStations.containsKey(blockedHex)) {
                 //Make sure its not an Offboard Map Hex
                 if (blockedHex.getCurrentTile().getColour().toString() == "RED" ) continue;
                 if (blockedHex.getStopName().equals("Beijing")) continue;
                 return true;
                }
         }

    }
    return false;
}