Example #1
0
 private boolean isAnyFieldSetForSelectedEntry(List<String> fieldnames) {
   if (panel.getMainTable().getSelectedRowCount() == 1) {
     BibEntry entry = panel.getMainTable().getSelected().get(0);
     return !Collections.disjoint(fieldnames, entry.getFieldNames());
   }
   return false;
 }
  @Override
  public int compare(Policy p1, Policy p2) {

    // Give precedence to stanzas with inner package mappings
    if (p1.hasInnerPackages() != p2.hasInnerPackages()) {
      return p1.hasInnerPackages() ? -1 : 1;
    }

    // Check for duplicate entries
    if (p1.getSignatures().equals(p2.getSignatures())) {
      // Checks if signer w/o inner package names
      if (p1.hasGlobalSeinfo()) {
        duplicateFound = true;
        Slog.e(SELinuxMMAC.TAG, "Duplicate policy entry: " + p1.toString());
      }

      // Look for common inner package name mappings
      final Map<String, String> p1Packages = p1.getInnerPackages();
      final Map<String, String> p2Packages = p2.getInnerPackages();
      if (!Collections.disjoint(p1Packages.keySet(), p2Packages.keySet())) {
        duplicateFound = true;
        Slog.e(SELinuxMMAC.TAG, "Duplicate policy entry: " + p1.toString());
      }
    }

    return 0;
  }
  @Override
  public boolean isModuleAllowed(IModule iModule, ItemStack itemStack) {
    boolean allowed = false;
    if (itemStack.getItem() instanceof ItemBrassArmor) {
      ItemBrassArmor brassArmor = (ItemBrassArmor) itemStack.getItem();
      if (iModule instanceof IArmorModule) {
        IArmorModule iArmorModule = (IArmorModule) iModule;
        if ((iArmorModule.getApplicablePiece() == -1)
            || (iArmorModule.getApplicablePiece() == brassArmor.armorType)) {
          ArrayList<IModule> moduleIncompatibilities =
              ModuleRegistry.getModuleIncompatibilities(iModule.getModuleId());
          if ((moduleIncompatibilities == null)
              || Collections.disjoint(
                  IModuleContainer.Helper.getAllModulesEquipped(itemStack),
                  moduleIncompatibilities)) {
            if (!IModuleContainer.Helper.getAllModulesEquipped(itemStack).contains(iModule)) {
              allowed = true;
            }
          }
        }
      }
    }

    return allowed;
  }
Example #4
0
 /**
  * Returns true if events in general can be sent. This method checks basic conditions common to
  * all type of event notifications (e.g. item was published, node configuration has changed, new
  * child node was added to collection node, etc.).
  *
  * @return true if events in general can be sent.
  */
 private boolean canSendEvents() {
   // Check if the subscription is active
   if (!isActive()) {
     return false;
   }
   // Check if delivery of notifications is disabled
   if (!shouldDeliverNotifications()) {
     return false;
   }
   // Check if delivery is subject to presence-based policy
   if (!getPresenceStates().isEmpty()) {
     Collection<String> shows = service.getShowPresences(jid);
     if (shows.isEmpty() || Collections.disjoint(getPresenceStates(), shows)) {
       return false;
     }
   }
   // Check if node is only sending events when user is online
   if (node.isPresenceBasedDelivery()) {
     // Check that user is online
     if (service.getShowPresences(jid).isEmpty()) {
       return false;
     }
   }
   return true;
 }
  /**
   * Recursive method to add list layers get by the WMSServer into tree list
   *
   * @param children Represents child layers of parentNode
   * @param tree Tree of layers
   * @param crs CRS that must have the layers to add these to the tree
   * @param parentNode Represents parent layer
   * @param layersMap Represents the map that contains the layers obtained
   * @param isCalledByWizard Indicate if the method is called by the wizard
   */
  private void generateWMSChildrenNodes(
      ArrayList<WMSLayer> children,
      List<TreeNode> tree,
      TreeSet<String> listCrs,
      TreeNode parentNode,
      Map<String, org.gvsig.framework.web.ogc.WMSLayer> layersMap,
      WMSInfo wmsInfo) {
    for (WMSLayer layerChild : children) {
      // get crs (srs) (belong to layer)
      Vector crsVector = layerChild.getAllSrs();
      // Only get the layers with have crs parameter or if crs is null
      if (listCrs.isEmpty() || !Collections.disjoint(crsVector, listCrs)) {

        ArrayList<WMSLayer> layerChildChildren = layerChild.getChildren();
        TreeNode layerChildNode = new TreeNode(layerChild.getName());
        layerChildNode.setTitle(layerChild.getTitle());

        // Get the children and their information
        if (layerChildChildren.isEmpty()) {
          layerChildNode.setFolder(false);

          // Add layer to layer map
          org.gvsig.framework.web.ogc.WMSLayer wmsLayer =
              new org.gvsig.framework.web.ogc.WMSLayer();
          TreeSet<String> crsSet = new TreeSet<String>();
          crsSet.addAll(layerChild.getAllSrs());
          wmsLayer.setCrs(crsSet);
          List<WMSStyle> wmsStyles = createListWMSStyles(layerChild.getStyles());
          wmsLayer.setStyles(wmsStyles);
          wmsLayer.setTitle(layerChild.getTitle());
          wmsLayer.setName(layerChild.getName());
          layersMap.put(layerChild.getName(), wmsLayer);

          // add to wmsinfo the layers supported by this layer
          TreeSet<String> crsSupported = wmsInfo.getCrsSupported();
          crsSupported.addAll(layerChild.getAllSrs());
          wmsInfo.setCrsSupported(crsSupported);

          // create one child for each crs of the layer
          if (listCrs.isEmpty() || listCrs.size() > 1) {
            for (String crs : crsSet) {
              if (StringUtils.isNotEmpty(crs) && (listCrs.isEmpty() || listCrs.contains(crs))) {
                TreeNode crsNode = new TreeNode(crs);
                crsNode.setHideCheckbox(true);
                crsNode.setUnselectable(true);
                crsNode.setIconclass(" ");
                layerChildNode.addChild(crsNode);
              }
            }
          }
        } else {
          layerChildNode.setFolder(true);
          layerChildNode.setExpanded(true);
          generateWMSChildrenNodes(
              layerChildChildren, tree, listCrs, layerChildNode, layersMap, wmsInfo);
        }
        parentNode.addChild(layerChildNode);
      }
    }
  }
  /**
   * Check that the item matches the requirements expressed in the three lists
   *
   * @param item the item to check
   * @param query query that must be fulfilled
   * @return true if the item match all requirements
   */
  protected boolean match(T item, Query<T> query) {
    Set<String> existingEvents = new HashSet<>();
    Set<String> successEvents = new HashSet<>();
    Set<String> oldEvents = new HashSet<>();
    for (Event event : filterNewestEvent(item.getEventList())) {
      existingEvents.add(event.getEventID());
      if (event.isSuccess()) {
        successEvents.add(event.getEventID());
      }
      if (item.getLastModified() != null) {
        if (!event.getDate().after(item.getLastModified())) {
          oldEvents.add(event.getEventID());
        }
      }
    }
    final boolean successEventsGood = successEvents.containsAll(query.getPastSuccessfulEvents());

    boolean oldEventsGood = true;
    for (String oldEvent : query.getOldEvents()) {
      oldEventsGood =
          oldEventsGood && (oldEvents.contains(oldEvent) || !existingEvents.contains(oldEvent));
    }
    boolean futureEventsGood = Collections.disjoint(existingEvents, query.getFutureEvents());

    // TODONT we do not check for types for now
    return successEventsGood
        && oldEventsGood
        && futureEventsGood
        && (query.getItems().isEmpty() || query.getItems().contains(item));
  }
  void RemoveColidingBids(
      HashSet<Integer> regions,
      HashSet<Integer> companies,
      Double minValue,
      HashSet<Integer> AvailSet) {
    HashSet<Integer> RemoveSet =
        new HashSet<Integer>(); // HashSet to hold the items to remove from the AvailSet

    // Get an iterator to iterate over all the integers in the availble HashSet
    Iterator<Integer> it = AvailSet.iterator();

    // While there are any left
    while (it.hasNext()) {

      // Get the next integer
      Integer k = it.next();

      if ((_bids.get(k).value <= minValue)
          || // if the value is less than the target
          (companies.contains(_bids.get(k).company))
          || // if the company is already represented
          !Collections.disjoint(
              _bids.get(k).region, regions)) { // if it contains a region already bid on
        // add K to the "Remove" set
        RemoveSet.add(k);
      }
    }
    // Remove every bid from the remove set from the Avail list.
    AvailSet.removeAll(RemoveSet);
  }
  public void waitUntilDone(Set<String> workIDs) throws KeeperException, InterruptedException {

    final String condVar = new String("cond");

    Watcher watcher =
        new Watcher() {
          @Override
          public void process(WatchedEvent event) {
            switch (event.getType()) {
              case NodeChildrenChanged:
                synchronized (condVar) {
                  condVar.notify();
                }
                break;
              case NodeCreated:
              case NodeDataChanged:
              case NodeDeleted:
              case None:
                log.info("Got unexpected zookeeper event: " + event.getType() + " for " + path);
                break;
            }
          }
        };

    List<String> children = zoo.getChildren(path, watcher);

    while (!Collections.disjoint(children, workIDs)) {
      synchronized (condVar) {
        condVar.wait(10000);
      }
      children = zoo.getChildren(path, watcher);
    }
  }
Example #9
0
  public List<Computer> getComputers() {
    Computer[] computers = Jenkins.getInstance().getComputers();

    if (!isFilterExecutors()) {
      return Arrays.asList(computers);
    }

    List<Computer> result = new ArrayList<Computer>();

    boolean roam = false;
    HashSet<Label> labels = new HashSet<Label>();
    for (Item item : getItems()) {
      if (item instanceof AbstractProject<?, ?>) {
        AbstractProject<?, ?> p = (AbstractProject<?, ?>) item;
        Label l = p.getAssignedLabel();
        if (l != null) {
          labels.add(l);
        } else {
          roam = true;
        }
      }
    }

    for (Computer c : computers) {
      Node n = c.getNode();
      if (n != null) {
        if (roam && n.getMode() == Mode.NORMAL
            || !Collections.disjoint(n.getAssignedLabels(), labels)) {
          result.add(c);
        }
      }
    }

    return result;
  }
  /** @inheritDoc */
  public FilterResult checkEligibility(Person person, FilterChain filterChain) throws Exception {

    if (!Collections.disjoint(person.getGroupMemberships(), eligibleGroupMemberships)) {
      return new FilterResult(true, "has membership in eligible group");
    } else {
      return filterChain.checkEligibility(person);
    }
  }
Example #11
0
  /**
   * Adds ban to ban list and saves
   *
   * @param ban the IpBan to add
   * @return 0 - Success<br>
   *     1 - Already banned<br>
   *     2 - Error saving
   */
  public synchronized byte addBan(IpBan ban) {
    for (IpBan ipban : ipBans) {
      if (!Collections.disjoint(ipban.getIps(), ban.getIps())) // Any in common
      {
        if (ipban.isOver()) {
          this.removeBan(ipban);
          break;
        }
        if (ipban.isExpired()) {
          this.removeBan(ipban);
          ipban = ipban.expire();
          if (ipban == null) break; // Ban is over, continue on
          else {
            this.addBan(ipban);
            return 1;
          }
        }
      }
    }

    this.ipBans.add(ban);
    try {
      FileWriter fOut = new FileWriter(file, true);
      String line = "IP: ";
      for (int i = 0; i < ban.getIps().size() - 1; i++) {
        line += (ban.getIps().get(i) + ",");
      }
      line += ban.getIps().get(ban.getIps().size() - 1); // No comma for last
      line += " ";
      line += ban.getReason();
      line += "\u00C4";
      line += ban.getInfo();
      line += "\u00C4";
      line += ban.getEndTime();
      line += " ";
      line += (ban.getUUID() == null) ? "null" : ban.getUUID().toString();
      line += " ";
      line += (ban.getBannerUUID() == null) ? "null" : ban.getBannerUUID().toString();
      line += " ";
      line += ban.isRequest();
      if (ban.isRequest()) {
        line += " ";
        line += ban.getExpireTime();
        line += " ";
        line += ban.isApproveOnExpire();
      }

      line += "\n";
      fOut.write(line);
      fOut.close();
    } catch (IOException e) {
      pl.getLogger().severe("Could not write to " + file.getName());
      pl.getLogger().throwing(this.getClass().getName(), "add", e);
      return 2; // TODO:
    }

    return 0;
  }
 public PatternSetWithExplicitIRIBoundVariables(
     Set<Variable> explicitIRIBoundVariables, Set<Variable> explicitNotIRIBoundVariables) {
   super();
   this.explicitIRIBoundVariables = explicitIRIBoundVariables;
   this.explicitNotIRIBoundVariables = explicitNotIRIBoundVariables;
   if (explicitIRIBoundVariables != null && explicitNotIRIBoundVariables != null) {
     assert Collections.disjoint(explicitIRIBoundVariables, explicitNotIRIBoundVariables);
   }
 }
 @Override
 public boolean isAffected(Delta delta, IResourceDescription candidate)
     throws IllegalArgumentException {
   if (!hasChanges(delta, candidate)) return false;
   Set<QualifiedName> names = Sets.newHashSet();
   addExportedNames(names, delta.getOld());
   addExportedNames(names, delta.getNew());
   return !Collections.disjoint(names, getImportedNames(candidate));
 }
 /** @generated */
 public boolean canExistAssociation_4011(
     Package container, Association linkInstance, Type source, Type target) {
   try {
     if ((source instanceof Class)
         || (source instanceof Component)
         || (source instanceof Actor)
         || (source instanceof UseCase)) {
       if ((target instanceof Class)
           || (target instanceof Component)
           || (target instanceof Actor)
           || (target instanceof UseCase)) {
         if ((source instanceof UseCase) && (target instanceof UseCase)) {
           return (Collections.disjoint(
               ((UseCase) source).getSubjects(), ((UseCase) target).getSubjects()));
         }
         return true;
       }
     } else {
       return false;
     }
     if ((source instanceof Class)
         || (source instanceof Component)
         || (source instanceof Actor)
         || (source instanceof UseCase)) {
       if ((target instanceof Class)
           || (target instanceof Component)
           || (target instanceof Actor)
           || (target instanceof UseCase)) {
         if ((source instanceof UseCase) && (target instanceof UseCase)) {
           return (Collections.disjoint(
               ((UseCase) source).getSubjects(), ((UseCase) target).getSubjects()));
         }
         return true;
       }
     } else {
       return false;
     }
     return true;
   } catch (Exception e) {
     UMLDiagramEditorPlugin.getInstance()
         .logError("Link constraint evaluation error", e); // $NON-NLS-1$
     return false;
   }
 }
Example #15
0
  private void mergeIntermediateStates() {
    Map<Adjacency, Set<FSANode>> adjToNodes = new HashMap<>();
    Set<FSANode> newCurMergeLevel = new HashSet<>();
    Map<FSANode, FSANode> formerNodeToMergedNode = new HashMap<>();
    for (FSANode node : curMergeLevel) {
      boolean needToBreak = false;
      for (Set<FSANode> targets : node.getLabelToTargets().values()) {
        if (targets.size() > 1) {
          updateBasedOnMerges(targets, formerNodeToMergedNode);
          FSANode newNode = mergeNodes(targets);
          targets.stream().forEach(n -> formerNodeToMergedNode.put(n, newNode));
          if (newNode.needsToMergeOutgoingEdges()) {
            newCurMergeLevel.add(newNode);
          }
          needToBreak = true;
        }
      }

      if (needToBreak) {
        break;
      }

      for (FSAEdge edge : node.getOutgoingEdges()) {
        Adjacency adj = new Adjacency(edge);
        Set<FSANode> nodesWithSameLabelToSameTarget = adjToNodes.get(adj);
        if (nodesWithSameLabelToSameTarget == null) {
          nodesWithSameLabelToSameTarget = new HashSet<>();
          adjToNodes.put(adj, nodesWithSameLabelToSameTarget);
        }
        nodesWithSameLabelToSameTarget.add(node);
      }
    }

    for (FSANode node : curMergeLevel) {
      newCurMergeLevel.addAll(
          node.getIncomingEdges().stream().map(e -> e.getSource()).collect(Collectors.toSet()));
    }

    for (Set<FSANode> nodes : adjToNodes.values()) {
      updateBasedOnMerges(nodes, formerNodeToMergedNode);
      if (nodes.size() > 1) {
        FSANode newNode = mergeNodes(nodes);
        if (!Collections.disjoint(newCurMergeLevel, nodes)) {
          newCurMergeLevel.removeAll(nodes);
          newCurMergeLevel.add(newNode);
        }
        for (FSANode node : nodes) {
          formerNodeToMergedNode.put(node, newNode);
        }
      }
    }
    // remove any nodes that are now contained by other nodes
    curMergeLevel =
        newCurMergeLevel.stream().filter(n -> this.nodes.contains(n)).collect(Collectors.toSet());
  }
Example #16
0
 @Override
 public void reportInvalidOptions(EventHandler reporter, BuildOptions buildOptions) {
   if (!Collections.disjoint(translationFlags, J2OBJC_BLACKLISTED_TRANSLATION_FLAGS)) {
     String errorMsg =
         String.format(
             INVALID_TRANSLATION_FLAGS_MSG_TEMPLATE,
             Joiner.on(",").join(translationFlags),
             Joiner.on(",").join(J2OBJC_BLACKLISTED_TRANSLATION_FLAGS));
     reporter.handle(Event.error(errorMsg));
   }
 }
Example #17
0
 private static void extendGroupRec(
     List<WayData> group, WayData newGroupMember, List<WayData> remaining) {
   group.add(newGroupMember);
   for (int i = 0; i < remaining.size(); ++i) {
     WayData candidate = remaining.get(i);
     if (candidate == null) continue;
     if (!Collections.disjoint(candidate.way.getNodes(), newGroupMember.way.getNodes())) {
       remaining.set(i, null);
       extendGroupRec(group, candidate, remaining);
     }
   }
 }
  /**
   * Verifies that heap and global object sets are disjunct
   *
   * @param pLogger Logger to log the message
   * @param pSmg SMG to check
   * @return True if pSmg is consistent w.r.t. this criteria. False otherwise.
   */
  private static boolean verifyDisjunctHeapAndGlobal(LogManager pLogger, CLangSMG pSmg) {
    Map<String, SMGRegion> globals = pSmg.getGlobalObjects();
    Set<SMGObject> heap = pSmg.getHeapObjects();

    boolean toReturn = Collections.disjoint(globals.values(), heap);

    if (!toReturn) {
      pLogger.log(Level.SEVERE, "CLangSMG inconsistent, heap and global objects are not disjoint");
    }

    return toReturn;
  }
 @Override
 public int rank(
     final Set<ResourceType<?>> resourceTypes,
     final Collection<ServiceConfiguration<?>> serviceConfigs) {
   if (clusteringService == null
       || resourceTypes.size() > 1
       || Collections.disjoint(resourceTypes, CLUSTER_RESOURCES)) {
     // A ClusteredStore requires a ClusteringService *and* ClusteredResourcePool instances
     return 0;
   }
   return 1;
 }
 public PatternSetWithExplicitIRIBoundVariables(
     EPatternSetType t,
     Collection<? extends Pattern> c,
     Set<Variable> explicitIRIBoundVariables,
     Set<Variable> explicitNotIRIBoundVariables) {
   super(t, c);
   this.explicitIRIBoundVariables = explicitIRIBoundVariables;
   this.explicitNotIRIBoundVariables = explicitNotIRIBoundVariables;
   if (explicitIRIBoundVariables != null && explicitNotIRIBoundVariables != null) {
     assert Collections.disjoint(explicitIRIBoundVariables, explicitNotIRIBoundVariables);
   }
 }
 public static void main(String[] args) {
   print(list);
   print(
       "'list' disjoint (Four)?: "
           + Collections.disjoint(list, Collections.singletonList("Four")));
   print("max: " + Collections.max(list));
   print("min: " + Collections.min(list));
   print("max w/ comparator: " + Collections.max(list, String.CASE_INSENSITIVE_ORDER));
   print("min w/ comparator: " + Collections.min(list, String.CASE_INSENSITIVE_ORDER));
   List<String> sublist = Arrays.asList("Four five six".split(" "));
   print("indexOfSubList: " + Collections.indexOfSubList(list, sublist));
   print("lastIndexOfSubList: " + Collections.lastIndexOfSubList(list, sublist));
   Collections.replaceAll(list, "one", "Yo");
   print("replaceAll: " + list);
   Collections.reverse(list);
   print("reverse: " + list);
   Collections.rotate(list, 3);
   print("rotate: " + list);
   List<String> source = Arrays.asList("in the matrix".split(" "));
   Collections.copy(list, source);
   print("copy: " + list);
   Collections.swap(list, 0, list.size() - 1);
   print("swap: " + list);
   Collections.shuffle(list, new Random(47));
   print("shuffled: " + list);
   Collections.fill(list, "pop");
   print("fill: " + list);
   print("frequency of 'pop': " + Collections.frequency(list, "pop"));
   List<String> dups = Collections.nCopies(3, "snap");
   print("dups: " + dups);
   print("'list' disjoint 'dups'?: " + Collections.disjoint(list, dups));
   // Getting an old-style Enumeration:
   Enumeration<String> e = Collections.enumeration(dups);
   Vector<String> v = new Vector<String>();
   while (e.hasMoreElements()) v.addElement(e.nextElement());
   // Converting an old-style Vector
   // to a List via an Enumeration:
   ArrayList<String> arrayList = Collections.list(v.elements());
   print("arrayList: " + arrayList);
 }
  /**
   * Find the closest common superclass of multiple classes
   *
   * @param cs
   * @return
   */
  @SuppressWarnings("rawtypes")
  public static Class FindCommonSuperclass(Class[] cs) {
    if (cs.length == 0) {
      return Object.class;
    } else if (cs.length == 1) {
      return cs[0];
    }

    // if any items fail getSuperclass in the passed in array,
    // simply return object.
    boolean isSame = true;
    boolean hasNullSuperclass = false;
    for (Class c : cs) {
      if (c == null) throw new NullPointerException();
      if (c != cs[0]) isSame = false;
      if (c.getSuperclass() == null) hasNullSuperclass = true;
    }
    // no need to do further calculations.. all the same
    if (isSame) return cs[0];
    // at least one item in the list failed getSuperclass... return object
    if (hasNullSuperclass) return Object.class;

    Class c1 = cs[0];
    Class c2 = null;
    HashSet<Class> s1 = new HashSet<>();
    HashSet<Class> s2 = new HashSet<>();

    for (int i = 1; i < cs.length; i++) {
      s1.clear();
      s2.clear();
      c2 = cs[i];

      do {
        s1.add(c1);
        s2.add(c2);
        if (c1 != Object.class) {
          c1 = c1.getSuperclass();
        }
        if (c2 != Object.class) {
          c2 = c2.getSuperclass();
        }
      } while (Collections.disjoint(s1, s2));

      s1.retainAll(s2);
      c1 = s1.iterator().next(); // there can only be one
      if (c1 == Object.class) break; // no superclass above object
    }
    return c1;
  }
  protected Boolean isDelegationAllowed(final TaskInstance task) {

    if (task == null) {
      return false;
    }

    if ("Completed".equals(task.getStatus())) {
      return false;
    }

    final String actualOwner = task.getActualOwner();
    if (actualOwner != null && actualOwner.equals(identityProvider.getName())) {
      return true;
    }

    final String initiator = task.getCreatedBy();
    if (initiator != null && initiator.equals(identityProvider.getName())) {
      return true;
    }

    List<String> roles = identityProvider.getRoles();

    // TODO Needs to check if po or ba string is a group or a user
    final List<String> potentialOwners = task.getPotentialOwners();
    if (potentialOwners != null && Collections.disjoint(potentialOwners, roles) == false) {
      return true;
    }

    final List<String> businessAdministrators = task.getBusinessAdmins();
    if (businessAdministrators != null
        && Collections.disjoint(businessAdministrators, roles) == false) {
      return true;
    }

    return false;
  }
 @Override
 public Description matchCompilationUnit(CompilationUnitTree tree, VisitorState state) {
   if (tree.getTypeDecls().size() <= 1) {
     // package-info.java files have zero top-level declarations, everything
     // else should have exactly one.
     return Description.NO_MATCH;
   }
   if (tree.getPackageName() == null) {
     // Real code doesn't use the default package.
     return Description.NO_MATCH;
   }
   List<String> names = new ArrayList<>();
   for (Tree member : tree.getTypeDecls()) {
     if (member instanceof ClassTree) {
       ClassTree classMember = (ClassTree) member;
       switch (classMember.getKind()) {
         case CLASS:
         case INTERFACE:
         case ANNOTATION_TYPE:
         case ENUM:
           SuppressWarnings suppression =
               ASTHelpers.getAnnotation(classMember, SuppressWarnings.class);
           if (suppression != null
               && !Collections.disjoint(Arrays.asList(suppression.value()), allNames())) {
             // If any top-level classes have @SuppressWarnings("TopLevel"), ignore
             // this compilation unit. We can't rely on the normal suppression
             // mechanism because the only enclosing element is the package declaration,
             // and @SuppressWarnings can't be applied to packages.
             return Description.NO_MATCH;
           }
           names.add(classMember.getSimpleName().toString());
           break;
         default:
           break;
       }
     }
   }
   if (names.size() <= 1) {
     // this can happen with multiple type declarations if some of them are
     // empty (e.g. ";" at the top level counts as an empty type decl)
     return Description.NO_MATCH;
   }
   String message =
       String.format(
           "Expected at most one top-level class declaration, instead found: %s",
           Joiner.on(", ").join(names));
   return buildDescription(tree.getPackageName()).setMessage(message).build();
 }
 TestSuite computeMultimapAsMapGetTestSuite(
     FeatureSpecificTestSuiteBuilder<
             ?, ? extends OneSizeTestContainerGenerator<M, Map.Entry<K, V>>>
         parentBuilder) {
   Set<Feature<?>> features = computeMultimapAsMapGetFeatures(parentBuilder.getFeatures());
   if (Collections.disjoint(features, EnumSet.allOf(CollectionSize.class))) {
     return new TestSuite();
   } else {
     return CollectionTestSuiteBuilder.using(
             new MultimapAsMapGetGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
         .withFeatures(features)
         .named(parentBuilder.getName() + ".asMap[].get[key]")
         .suppressing(parentBuilder.getSuppressedTests())
         .createTestSuite();
   }
 }
  /**
   * Verifies that global and stack object sets are disjunct
   *
   * @param pLogger Logger to log the message
   * @param pSmg SMG to check
   * @return True if pSmg is consistent w.r.t. this criteria. False otherwise.
   */
  private static boolean verifyDisjunctGlobalAndStack(LogManager pLogger, CLangSMG pSmg) {
    Deque<CLangStackFrame> stack_frames = pSmg.getStackFrames();
    Set<SMGObject> stack = new HashSet<>();

    for (CLangStackFrame frame : stack_frames) {
      stack.addAll(frame.getAllObjects());
    }
    Map<String, SMGRegion> globals = pSmg.getGlobalObjects();

    boolean toReturn = Collections.disjoint(stack, globals.values());

    if (!toReturn) {
      pLogger.log(Level.SEVERE, "CLangSMG inconsistent, global and stack objects are not disjoint");
    }

    return toReturn;
  }
Example #27
0
  public ModelCloudProxySet hasProvidedSpaces(Object value) {
    ObjectSet neighbors = new ObjectSet();

    if (value instanceof Collection) {
      neighbors.addAll((Collection<?>) value);
    } else {
      neighbors.add(value);
    }

    ModelCloudProxySet answer = new ModelCloudProxySet();

    for (ModelCloudProxy obj : this) {
      if (!Collections.disjoint(neighbors, obj.getProvidedSpaces())) {
        answer.add(obj);
      }
    }

    return answer;
  }
Example #28
0
  public ClassModelSet hasEnumerations(Object value) {
    ObjectSet neighbors = new ObjectSet();

    if (value instanceof Collection) {
      neighbors.addAll((Collection<?>) value);
    } else {
      neighbors.add(value);
    }

    ClassModelSet answer = new ClassModelSet();

    for (ClassModel obj : this) {
      if (!Collections.disjoint(neighbors, obj.getEnumerations())) {
        answer.add(obj);
      }
    }

    return answer;
  }
Example #29
0
  public GraphSet hasGcs(Object value) {
    ObjectSet neighbors = new ObjectSet();

    if (value instanceof Collection) {
      neighbors.addAll((Collection<?>) value);
    } else {
      neighbors.add(value);
    }

    GraphSet answer = new GraphSet();

    for (Graph obj : this) {
      if (!Collections.disjoint(neighbors, obj.getGcs())) {
        answer.add(obj);
      }
    }

    return answer;
  }
Example #30
0
  /**
   * Compares this section against another section for conflicts.
   *
   * @param section The section to compare this section against.
   * @return boolean
   *     <ul>
   *       true - conflict detected
   *       <p>false - no conflict detected
   *       <ul/>
   */
  public boolean conflictsWith(Section section) {
    Log.i(
        "Section Conflict Check",
        "Comparing sections: \n" + toJSON() + " to \n" + section.toJSON().toString());
    boolean returnValue;
    if (!Collections.disjoint(
        days,
        section
            .days)) { // If there is overlap between the two sets of days conflict is possible, run
                      // checks

      if (endTime.equals(
          section.endTime)) // If this section's end time equals the other section's end time
      return true;

      if (startTime.before(section.startTime)) // If this section starts before the other section
      return section.startTime.before(
            endTime); //  check to see if this section ends before other section begins

      // If this section starts after the other section
      //  check to see if other section ends before this section begins
      returnValue = !section.startTime.before(startTime) || startTime.before(section.endTime);

    } else returnValue = false; // Days are disjoint, no conflict possible

    if (returnValue)
      Log.w(
          "Schedule Conflict Error",
          "Conflict between "
              + getSourceCourse().getCourseTitle()
              + " "
              + getSourceCourse().getCourseNumber()
              + "-"
              + getSectionNumber()
              + " and "
              + section.getSourceCourse().getCourseTitle()
              + " "
              + section.getSourceCourse().getCourseNumber()
              + "-"
              + section.getSectionNumber());
    return returnValue;
  }