@Override
  public Command getCommand() {
    // edit command
    final ArrayList<Command> changes = new ArrayList<>();
    super.addEditCommands.accept(changes);

    if (productOwnerProperty().get() != modelWrapper.get().getProductOwner()) {
      changes.add(
          new EditCommand<>(modelWrapper.get(), "productOwner", productOwnerProperty().get()));
    }

    if (scrumMasterProperty().get() != modelWrapper.get().getScrumMaster()) {
      changes.add(
          new EditCommand<>(modelWrapper.get(), "scrumMaster", scrumMasterProperty().get()));
    }

    if (!(teamMembersProperty().get().containsAll(modelWrapper.get().getTeamMembers())
        && modelWrapper.get().getTeamMembers().containsAll(teamMembersProperty().get()))) {
      // BEWARE: magic
      ArrayList<Person> teamMembers = new ArrayList<>();
      teamMembers.addAll(teamMembersProperty().get());
      changes.add(new EditCommand<>(modelWrapper.get(), "teamMembers", teamMembers));
    }

    if (!(devTeamProperty().get().containsAll(modelWrapper.get().getDevTeam())
        && modelWrapper.get().getDevTeam().containsAll(devTeamProperty().get()))) {
      // BEWARE: magic
      ArrayList<Person> devTeam = new ArrayList<>();
      devTeam.addAll(devTeamProperty().get());
      changes.add(new EditCommand<>(modelWrapper.get(), "devTeam", devTeam));
    }

    final ArrayList<Person> newMembers = new ArrayList<>(teamMembersProperty().get());
    newMembers.removeAll(modelWrapper.get().observableTeamMembers());
    final ArrayList<Person> oldMembers =
        new ArrayList<>(modelWrapper.get().observableTeamMembers());
    oldMembers.removeAll(teamMembersProperty().get());

    // Loop through all the new members and add a command to set their team
    // Set the person's team field to this team
    changes.addAll(
        newMembers
            .stream()
            .map(person -> new EditCommand<>(person, "team", modelWrapper.get()))
            .collect(Collectors.toList()));

    // Loop through all the old members and add a command to remove their team
    // Set the person's team field to null, since they're no longer in the team
    changes.addAll(
        oldMembers
            .stream()
            .map(person -> new EditCommand<>(person, "team", null))
            .collect(Collectors.toList()));

    return new CompoundCommand("Edit Team", changes);
  }
Exemple #2
0
  @Override
  public void sendMessage(Message message) throws MessagingException {
    ArrayList<Address> addresses = new ArrayList<Address>();
    {
      addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.TO)));
      addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.CC)));
      addresses.addAll(Arrays.asList(message.getRecipients(RecipientType.BCC)));
    }
    message.setRecipients(RecipientType.BCC, null);

    HashMap<String, ArrayList<String>> charsetAddressesMap =
        new HashMap<String, ArrayList<String>>();
    for (Address address : addresses) {
      String addressString = address.getAddress();
      String charset = MimeUtility.getCharsetFromAddress(addressString);
      ArrayList<String> addressesOfCharset = charsetAddressesMap.get(charset);
      if (addressesOfCharset == null) {
        addressesOfCharset = new ArrayList<String>();
        charsetAddressesMap.put(charset, addressesOfCharset);
      }
      addressesOfCharset.add(addressString);
    }

    for (Map.Entry<String, ArrayList<String>> charsetAddressesMapEntry :
        charsetAddressesMap.entrySet()) {
      String charset = charsetAddressesMapEntry.getKey();
      ArrayList<String> addressesOfCharset = charsetAddressesMapEntry.getValue();
      message.setCharset(charset);
      sendMessageTo(addressesOfCharset, message);
    }
  }
Exemple #3
0
 public Astar(
     long startId,
     long endId,
     DBHelper db,
     Map<Long, Node> nodes,
     LinkedList<Segment> segments,
     LinkedList<CostFunction> costs) {
   this.db = db;
   this.nodes = nodes;
   this.segments = segments;
   this.costs = costs;
   this.db.Connect();
   this.fakeNodes.put(startId, new FakeNode(this.nodes.get(startId)));
   this.fakeNodes.put(endId, new FakeNode(this.nodes.get(endId)));
   this.startNode = this.fakeNodes.get(startId);
   this.endNode = this.fakeNodes.get(endId);
   this.startNode.g_scores = 0;
   ArrayList<Segment> fakeStart = createFalseSegments(startNode.node, true);
   ArrayList<Segment> fakeEnd = createFalseSegments(endNode.node, false);
   if (fakeStart != null) {
     fakeSegments.addAll(fakeStart);
   }
   if (fakeEnd != null) {
     fakeSegments.addAll(fakeEnd);
   }
   /*if(!fakeSegments.isEmpty()) {
       segments.addAll(fakeSegments);
       if(!fakeCosts.isEmpty()){
           costs.addAll(fakeCosts);
       }
   }*/
 }
  public List<TokenHook> compile() throws InvalidOperationException {
    if (this.compiled) {
      throw new IllegalStateException("XMLEditableString already compiled");
    }

    if (tokenMask != null) {
      for (int[] positions : this.tokenMask) {
        int startPosition = positions[0];
        int length = positions[1];
        TokenHook hook = new TokenHook(startPosition, length, TokenHook.TokenType.Word);
        hook.processedString = this.currentString.substring(startPosition, startPosition + length);
        this.tokens.add(hook);
      }
    }

    this.reverseChangeLog();
    this.compiled = true;

    ArrayList<TokenHook> hooks = new ArrayList<>(this.tokens.size() + this.xml.size());
    hooks.addAll(this.tokens);
    hooks.addAll(this.xml);

    Collections.sort(hooks, (t1, t2) -> t1.startIndex - t2.startIndex);

    return hooks;
  }
  @NotNull
  public static Collection<PsiFileSystemItem> getAbsoluteTopLevelDirLocations(
      final @NotNull PsiFile file) {

    final VirtualFile virtualFile = file.getVirtualFile();
    if (virtualFile == null) {
      return Collections.emptyList();
    }
    final Project project = file.getProject();
    PsiDirectory parent = file.getParent();
    final Module module = ModuleUtil.findModuleForPsiElement(parent == null ? file : parent);
    if (module == null) {
      return Collections.emptyList();
    }
    final FileReferenceHelper[] helpers = FileReferenceHelperRegistrar.getHelpers();
    final ArrayList<PsiFileSystemItem> list = new ArrayList<PsiFileSystemItem>();
    for (FileReferenceHelper helper : helpers) {
      if (helper.isMine(project, virtualFile)) {
        final Collection<PsiFileSystemItem> roots = helper.getRoots(module);
        for (PsiFileSystemItem root : roots) {
          LOG.assertTrue(root != null, "Helper " + helper + " produced a null root for " + file);
        }
        list.addAll(roots);
      }
    }

    if (list.size() == 0) {
      list.addAll(FileReferenceHelperRegistrar.getNotNullHelper(file).getRoots(module));
    }
    return list;
  }
  @NotNull
  @Override
  public Collection<PsiReference> findReferences(final PsiElement element) {
    if (element instanceof GrField) {
      ArrayList<PsiReference> refs = new ArrayList<PsiReference>();

      GrField field = (GrField) element;
      PsiMethod setter = GroovyPropertyUtils.findSetterForField(field);
      GlobalSearchScope projectScope = GlobalSearchScope.projectScope(element.getProject());
      if (setter != null && setter instanceof GrAccessorMethod) {
        refs.addAll(
            RenameAliasedUsagesUtil.filterAliasedRefs(
                MethodReferencesSearch.search(setter, projectScope, true).findAll(), setter));
      }
      GrAccessorMethod[] getters = field.getGetters();
      for (GrAccessorMethod getter : getters) {
        refs.addAll(
            RenameAliasedUsagesUtil.filterAliasedRefs(
                MethodReferencesSearch.search(getter, projectScope, true).findAll(), getter));
      }
      refs.addAll(
          RenameAliasedUsagesUtil.filterAliasedRefs(
              ReferencesSearch.search(field, projectScope, true).findAll(), field));
      return refs;
    }
    return super.findReferences(element);
  }
Exemple #7
0
  public static void main(String args[]) {
    int N;
    Scanner in = new Scanner(System.in);
    N = in.nextInt();
    int arr[] = new int[N];
    ArrayList even = new ArrayList();
    ArrayList odd = new ArrayList();
    ArrayList list = new ArrayList();

    for (int i = 0; i < N; i++) {
      arr[i] = in.nextInt();
    }
    int evenSum = 0;
    int oddSum = 0;
    for (int i = 0; i < N; i++) {
      if (arr[i] % 2 == 0) {
        even.add(arr[i]);
        evenSum = evenSum + arr[i];
      } else {
        odd.add(arr[i]);
        oddSum = oddSum + arr[i];
      }
    }
    even.add(evenSum);
    odd.add(oddSum);
    Collections.sort(even);
    Collections.sort(odd);
    list.addAll(even);
    list.addAll(odd);
    Iterator itr = list.iterator();
    while (itr.hasNext()) {
      System.out.println(itr.next());
    }
  }
Exemple #8
0
 public static ArrayList<Integer> QSort(ArrayList<Integer> L) {
   Random r = new Random();
   if (L.size() <= 1) {
     return L;
   } else {
     int pivot = r.nextInt(L.size());
     ArrayList<Integer> lower = new ArrayList(pivot); // holds indices 0--> one before pivot
     ArrayList<Integer> upper =
         new ArrayList(
             L.size() - pivot); // holds pivot --> end.  basically string slicing in python
     int pivotInt = L.get(pivot);
     for (int i = 0; i < L.size(); i++) {
       if (i != pivot) { // dont put pivot back into list
         if (L.get(i) < pivotInt) {
           lower.add(L.get(i));
         } else {
           upper.add(L.get(i));
         }
       }
     }
     lower = QSort(lower);
     upper = QSort(upper);
     // System.out.println(lower);
     // System.out.println(upper);
     ArrayList<Integer> ans = new ArrayList<Integer>();
     ans.addAll(lower);
     ans.add(pivotInt);
     ans.addAll(upper); // builtin way to concatenate arraylists.
     return ans;
   }
 }
Exemple #9
0
  private void attachOrphanRoadsToNearestPath(List<Path> paths) {

    findOrphanRoads();

    ArrayList<Road> orRoads = new ArrayList<Road>();

    orRoads.addAll(orphanRoads);

    while (!orphanRoads.isEmpty()) {

      for (Road road : orRoads) {
        boolean isAdded = false;
        for (Road connectedRoad : roadHelper.getConnectedRoads(road.getID())) {
          EntityID rPathId = roadHelper.getPathId(connectedRoad.getID());
          if (rPathId != null) {
            isAdded = true;
            addToPath(road, rPathId, paths);
            orphanRoads.remove(road);
            break;
          }
        }
        if (!isAdded) {
          Path nearestPath = getNearestPath(road, paths);
          if (nearestPath != null) {
            adding(road, nearestPath);
            orphanRoads.remove(road);
          }
        }
      }

      if (orphanRoads.size() == orRoads.size()) break;
      orRoads.clear();
      orRoads.addAll(orphanRoads);
    }
  }
  /**
   * Creates a java process that executes the given main class and waits for the process to
   * terminate.
   *
   * @return a {@link ProcessOutputReader} that can be used to get the exit code and stdout+stderr
   *     of the terminated process.
   */
  public static ProcessOutputReader fg(Class main, String[] vmArgs, String[] mainArgs)
      throws IOException {
    File javabindir = new File(System.getProperty("java.home"), "bin");
    File javaexe = new File(javabindir, "java");

    int bits = Integer.getInteger("sun.arch.data.model", 0).intValue();
    String vmKindArg = (bits == 64) ? "-d64" : null;

    ArrayList argList = new ArrayList();
    argList.add(javaexe.getPath());
    if (vmKindArg != null) {
      argList.add(vmKindArg);
    }
    // argList.add("-Dgemfire.systemDirectory=" +
    // GemFireConnectionFactory.getDefaultSystemDirectory());
    argList.add("-Djava.class.path=" + System.getProperty("java.class.path"));
    argList.add("-Djava.library.path=" + System.getProperty("java.library.path"));
    if (vmArgs != null) {
      argList.addAll(Arrays.asList(vmArgs));
    }
    argList.add(main.getName());
    if (mainArgs != null) {
      argList.addAll(Arrays.asList(mainArgs));
    }
    String[] cmd = (String[]) argList.toArray(new String[argList.size()]);
    return new ProcessOutputReader(Runtime.getRuntime().exec(cmd));
  }
 /**
  * Return certificates for signed bundle, otherwise null.
  *
  * @return An array of certificates or null.
  */
 public ArrayList getCertificateChains(boolean onlyTrusted) {
   if (checkCerts) {
     Certificate[] c = archive.getCertificates();
     checkCerts = false;
     if (c != null) {
       ArrayList failed = new ArrayList();
       untrustedCerts = Util.getCertificateChains(c, failed);
       if (!failed.isEmpty()) {
         // NYI, log Bundle archive has invalid certificates
         untrustedCerts = null;
       }
     }
   }
   ArrayList res = trustedCerts;
   if (!onlyTrusted && untrustedCerts != null) {
     if (res == null) {
       res = untrustedCerts;
     } else {
       res = new ArrayList(trustedCerts.size() + untrustedCerts.size());
       res.addAll(trustedCerts);
       res.addAll(untrustedCerts);
     }
   }
   return res;
 }
  protected synchronized String getProcedureName(Connection dConn, Connection gConn) {
    /// avoid #42569
    ResultSet rs = null;

    try {
      rs = gConn.getMetaData().getProcedures(null, null, null);
      List procNames = ResultSetHelper.asList(rs, false);
      Log.getLogWriter().info("procedure names are " + ResultSetHelper.listToString(procNames));
      rs.close();
    } catch (SQLException se) {
      SQLHelper.handleSQLException(se);
    }

    try {
      rs = gConn.getMetaData().getFunctions(null, null, null);
    } catch (SQLException se) {
      SQLHelper.handleSQLException(se);
    }
    List funcNames = ResultSetHelper.asList(rs, false);
    Log.getLogWriter().info("function names are " + ResultSetHelper.listToString(funcNames));

    if (procedureNames == null) {
      ArrayList<String> procs = new ArrayList<String>();
      procs.addAll(ProcedureDDLStmt.modifyProcNameList);
      procs.addAll(ProcedureDDLStmt.nonModifyProcNameList);
      procedureNames = new ArrayList<String>(procs);
    }

    return procedureNames.get(SQLTest.random.nextInt(procedureNames.size()));
  }
Exemple #13
0
    // Generates a new polygon by dragging a polygon by a vector and taking all the points it
    // touched.
    public static Polygon stroke(double x, double y, Polygon poly) {
      Polygon polyTrans = mul(Mat.translation(x, y), poly);
      ArrayList<Mat> vertices = new ArrayList<Mat>();
      ArrayList<TreeSet<Integer>> edgesTo = new ArrayList<TreeSet<Integer>>();
      int size = poly.vertices.size();

      // The list of possible vertices of the extrusion
      vertices.addAll(poly.vertices);
      vertices.addAll(polyTrans.vertices);

      // pre-compute some information that will make it easy to find the actual perimeter of the
      // extrusion
      for (int i = 0; i < 2 * size; i++) {
        edgesTo.add(new TreeSet<Integer>());
      }

      for (int i = 0; i < size; i++) {
        edgesTo.get(i).add(new Integer((i + 1) % size));
        edgesTo.get((i + 1) % size).add(new Integer(i));

        edgesTo.get(i + size).add(new Integer(((i + 1) % size) + size));
        edgesTo.get(((i + 1) % size) + size).add(new Integer(i + size));

        edgesTo.get(i).add(new Integer(i + size));
        edgesTo.get(i + size).add(new Integer(i));
      }

      return perimeter(vertices, edgesTo);
    }
  @Override
  public void writeExternal(Element rootElement) throws WriteExternalException {
    LOG.assertTrue(!isDisposed(), "Already disposed!");

    Element element = new Element(ELEMENT);
    if (myName != null) {
      element.setAttribute(LIBRARY_NAME_ATTR, myName);
    }
    if (myKind != null) {
      element.setAttribute(LIBRARY_TYPE_ATTR, myKind.getKindId());
      final Object state = myProperties.getState();
      if (state != null) {
        final Element propertiesElement = XmlSerializer.serialize(state, SERIALIZATION_FILTERS);
        if (propertiesElement != null
            && (!propertiesElement.getContent().isEmpty()
                || !propertiesElement.getAttributes().isEmpty())) {
          element.addContent(propertiesElement.setName(PROPERTIES_ELEMENT));
        }
      }
    }
    ArrayList<OrderRootType> storableRootTypes = new ArrayList<OrderRootType>();
    storableRootTypes.addAll(Arrays.asList(OrderRootType.getAllTypes()));
    if (myKind != null) {
      storableRootTypes.addAll(Arrays.asList(myKind.getAdditionalRootTypes()));
    }
    for (OrderRootType rootType : sortRootTypes(storableRootTypes)) {
      final VirtualFilePointerContainer roots = myRoots.get(rootType);
      if (roots.size() == 0 && rootType.skipWriteIfEmpty()) continue; // compatibility iml/ipr
      final Element rootTypeElement = new Element(rootType.name());
      roots.writeExternal(rootTypeElement, ROOT_PATH_ELEMENT);
      element.addContent(rootTypeElement);
    }
    myJarDirectories.writeExternal(element);
    rootElement.addContent(element);
  }
  /* Scan the files in the new directory, and store them in the filelist.
   * Update the UI by refreshing the list adapter.
   */
  private void loadDirectory(String newdirectory) {
    if (newdirectory.equals("../")) {
      try {
        directory = new File(directory).getParent();
      } catch (Exception e) {
      }
    } else {
      directory = newdirectory;
    }
    SharedPreferences.Editor editor = getPreferences(0).edit();
    editor.putString("lastBrowsedDirectory", directory);
    editor.commit();
    directoryView.setText(directory);

    filelist = new ArrayList<FileUri>();
    ArrayList<FileUri> sortedDirs = new ArrayList<FileUri>();
    ArrayList<FileUri> sortedFiles = new ArrayList<FileUri>();
    if (!newdirectory.equals(rootdir)) {
      String parentDirectory = new File(directory).getParent() + "/";
      Uri uri = Uri.parse("file://" + parentDirectory);
      sortedDirs.add(new FileUri(uri, parentDirectory));
    }
    try {
      File dir = new File(directory);
      File[] files = dir.listFiles();
      if (files != null) {
        for (File file : files) {
          if (file == null) {
            continue;
          }
          String filename = file.getName();
          if (file.isDirectory()) {
            Uri uri = Uri.parse("file://" + file.getAbsolutePath() + "/");
            FileUri fileuri = new FileUri(uri, uri.getPath());
            sortedDirs.add(fileuri);
          } else if (filename.endsWith(".mid")
              || filename.endsWith(".MID")
              || filename.endsWith(".midi")
              || filename.endsWith(".MIDI")) {

            Uri uri = Uri.parse("file://" + file.getAbsolutePath());
            FileUri fileuri = new FileUri(uri, uri.getLastPathSegment());
            sortedFiles.add(fileuri);
          }
        }
      }
    } catch (Exception e) {
    }

    if (sortedDirs.size() > 0) {
      Collections.sort(sortedDirs, sortedDirs.get(0));
    }
    if (sortedFiles.size() > 0) {
      Collections.sort(sortedFiles, sortedFiles.get(0));
    }
    filelist.addAll(sortedDirs);
    filelist.addAll(sortedFiles);
    adapter = new IconArrayAdapter<FileUri>(this, android.R.layout.simple_list_item_1, filelist);
    this.setListAdapter(adapter);
  }
Exemple #16
0
 /** The union of an OclSet and an OclBag is an OclBag. */
 public OclBag union(OclBag bag) {
   if (isUndefined()) return new OclBag(0, getUndefinedReason());
   if (bag.isUndefined()) return bag;
   ArrayList list = new ArrayList(collection.size() + bag.collection.size());
   list.addAll(collection);
   list.addAll(bag.collection);
   return new OclBag(list);
 }
Exemple #17
0
  public void buildPopulationBox() {
    rebuilding = true;
    populationBox.removeAll();
    peopleList = new ArrayList<Object>();
    famList = new ArrayList<Family>();
    peopleList.addAll(ctxt.individualCensus);
    String plur = (peopleList.size() == 1 ? "" : "s");
    populationBox.setLayout(new BoxLayout(populationBox, BoxLayout.PAGE_AXIS));
    populationBox.setBorder(
        BorderFactory.createTitledBorder(
            BorderFactory.createLineBorder(Color.blue), "Current Population"));
    populationBox.setAlignmentX(0.5f);
    populationBox.add(Box.createRigidArea(new Dimension(8, 0)));
    indivLabel = new JLabel("Contains " + peopleList.size() + " Individual" + plur);
    indivLabel.setAlignmentX(0.5f);
    populationBox.add(indivLabel);
    if (peopleList.size() > 0) {
      JPanel indivBtnBox = new JPanel();
      indivBtnBox.setLayout(new BoxLayout(indivBtnBox, BoxLayout.LINE_AXIS));
      Dimension sizer2 = new Dimension(350, 50);
      String[] indMenu = genIndMenu(peopleList);
      indPick = new JComboBox(indMenu);
      indPick.addActionListener(listener);
      indPick.setActionCommand("view/edit person");
      indPick.setMinimumSize(sizer2);
      indPick.setMaximumSize(sizer2);
      indPick.setBorder(
          BorderFactory.createTitledBorder(
              BorderFactory.createLineBorder(Color.blue), "View/Edit Person"));
      indivBtnBox.add(indPick);
      populationBox.add(indivBtnBox);
    } //  end of if-any-people-exist

    famList.addAll(ctxt.familyCensus); //  end of filtering deleted records
    plur = (famList.size() == 1 ? "y" : "ies");
    famLabel = new JLabel("Contains " + famList.size() + " Famil" + plur);
    famLabel.setAlignmentX(0.5f);
    populationBox.add(Box.createRigidArea(new Dimension(0, 4)));
    populationBox.add(famLabel);
    if (famList.size() > 0) {
      JPanel famBtnBox = new JPanel();
      famBtnBox.setLayout(new BoxLayout(famBtnBox, BoxLayout.LINE_AXIS));
      Dimension sizer2 = new Dimension(350, 50);
      String[] famMenu = genFamMenu(famList);
      famPick = new JComboBox(famMenu);
      famPick.addActionListener(listener);
      famPick.setActionCommand("view/edit family");
      famPick.setMinimumSize(sizer2);
      famPick.setMaximumSize(sizer2);
      famPick.setBorder(
          BorderFactory.createTitledBorder(
              BorderFactory.createLineBorder(Color.blue), "View/Edit Family"));
      famBtnBox.add(famPick);
      populationBox.add(famBtnBox);
    } //  end of if-any-families-exist
    rebuilding = false;
  } //  end of method buildPopulationBox
Exemple #18
0
 public void putAll(K key, Collection<O> values) {
   ArrayList<O> recs = hashtable.get(key);
   if (recs == null) {
     recs = new ArrayList<O>(listInitialCapacity == -1 ? 1 : listInitialCapacity);
     recs.addAll(values);
     hashtable.put(key, recs);
   } else {
     recs.addAll(values);
   }
 }
 /**
  * Returns an iterator over active and initializing shards. Making sure though that its random
  * within the active shards, and initializing shards are the last to iterate through.
  */
 public ShardIterator activeInitializingShardsIt(int seed) {
   if (allInitializingShards.isEmpty()) {
     return new PlainShardIterator(shardId, shuffler.shuffle(activeShards, seed));
   }
   ArrayList<ShardRouting> ordered =
       new ArrayList<>(activeShards.size() + allInitializingShards.size());
   ordered.addAll(shuffler.shuffle(activeShards, seed));
   ordered.addAll(allInitializingShards);
   return new PlainShardIterator(shardId, ordered);
 }
Exemple #20
0
  static ArrayList<BSA> getBSAs() {
    loadResourceLoadOrder();
    loadPluginLoadOrder();
    deleteOverlap();

    ArrayList<BSA> order = new ArrayList<>(resourceLoadOrder.size() + pluginLoadOrder.size());
    order.addAll(resourceLoadOrder);
    order.addAll(pluginLoadOrder.values());
    return order;
  }
Exemple #21
0
 /* Recursive, returns an array list
  * containing this node and all child nodes */
 public ArrayList<avPair> enumeratePairs() {
   ArrayList<avPair> myAV = new ArrayList<avPair>();
   if (leaf) {
     myAV.add(this);
     return myAV;
   } else {
     myAV.add(this);
     myAV.addAll(leftChild.enumeratePairs());
     myAV.addAll(rightChild.enumeratePairs());
     return myAV;
   }
 }
  /**
   * getEquippedEnchantedCreatures.
   *
   * @param cards a {@link java.util.ArrayList} object.
   * @return a {@link java.util.ArrayList} object.
   */
  public static ArrayList<Card> getEquippedEnchantedCreatures(ArrayList<Card> cards) {
    ArrayList<Card> ret = new ArrayList<Card>();
    for (Card c : cards) {
      if (c.isCreature() && (c.isEquipped() || c.isEnchanted())) {
        if (c.isEquipped()) ret.addAll(c.getEquippedBy());
        if (c.isEnchanted()) ret.addAll(c.getEnchantedBy());

        ret.add(c);
      }
    }
    return ret;
  }
Exemple #23
0
 public ArrayList<Integer> preorderTraversal_Recur(TreeNode root) {
   ArrayList<Integer> result = new ArrayList<Integer>();
   if (root != null) {
     result.add(root.val);
     if (root.left != null) {
       result.addAll(preorderTraversal_Recur(root.left));
     }
     if (root.right != null) {
       result.addAll(preorderTraversal_Recur(root.right));
     }
   }
   return result;
 }
 public List<Integer> inorderTraversal(TreeNode root) {
   ArrayList<Integer> answer = new ArrayList<>();
   if (root == null) {
     return answer;
   }
   if (root.left != null) {
     answer.addAll(inorderTraversal(root.left));
   }
   answer.add(root.val);
   if (root.right != null) {
     answer.addAll(inorderTraversal(root.right));
   }
   return answer;
 }
Exemple #25
0
  /**
   * @param root: The root of binary tree.
   * @return: Preorder in ArrayList which contains node values.
   */
  public ArrayList<Integer> preorderTraversal(TreeNode root) {
    // write your code here
    ArrayList<Integer> preoder = new ArrayList<Integer>();

    if (root == null) {
      return preoder;
    }

    preoder.add(root.val);
    preoder.addAll(preorderTraversal(root.left));
    preoder.addAll(preorderTraversal(root.right));

    return preoder;
  }
Exemple #26
0
 public static boolean callCheat(ArrayList<Card> caller) {
   // If the last person cheated
   if (lastPlayerCheated) {
     // gives the person who cheated the card
     lastPlayerHand.addAll(pile);
     pile.clear();
     return true;
   } else {
     // If the last person did not cheat
     // Gives the cards to the caller
     caller.addAll(pile);
     pile.clear();
     return false;
   }
 }
  public static SafeDeleteProcessor createInstance(
      Project project,
      @Nullable Runnable prepareSuccessfulCallBack,
      PsiElement[] elementsToDelete,
      boolean isSearchInComments,
      boolean isSearchNonJava,
      boolean askForAccessors) {
    ArrayList<PsiElement> elements = new ArrayList<PsiElement>(Arrays.asList(elementsToDelete));
    HashSet<PsiElement> elementsToDeleteSet =
        new HashSet<PsiElement>(Arrays.asList(elementsToDelete));

    for (PsiElement psiElement : elementsToDelete) {
      for (SafeDeleteProcessorDelegate delegate :
          Extensions.getExtensions(SafeDeleteProcessorDelegate.EP_NAME)) {
        if (delegate.handlesElement(psiElement)) {
          Collection<PsiElement> addedElements =
              delegate.getAdditionalElementsToDelete(
                  psiElement, elementsToDeleteSet, askForAccessors);
          if (addedElements != null) {
            elements.addAll(addedElements);
          }
          break;
        }
      }
    }

    return new SafeDeleteProcessor(
        project,
        prepareSuccessfulCallBack,
        PsiUtilCore.toPsiElementArray(elements),
        isSearchInComments,
        isSearchNonJava);
  }
 private String[] splitAndRemoveEmpty(String[] sts, String splitSeparator) {
   ArrayList<String> result = new ArrayList<String>();
   for (String st : sts) {
     result.addAll(Arrays.asList(splitAndRemoveEmpty(st, splitSeparator)));
   }
   return result.toArray(new String[result.size()]);
 }
  @NotNull
  public UsageInfo[] findUsages() {
    myRenamers.clear();
    ArrayList<UsageInfo> result = new ArrayList<UsageInfo>();

    List<PsiElement> elements = new ArrayList<PsiElement>(myAllRenames.keySet());
    //noinspection ForLoopReplaceableByForEach
    for (int i = 0; i < elements.size(); i++) {
      PsiElement element = elements.get(i);
      final String newName = myAllRenames.get(element);
      final UsageInfo[] usages =
          RenameUtil.findUsages(
              element, newName, mySearchInComments, mySearchTextOccurrences, myAllRenames);
      final List<UsageInfo> usagesList = Arrays.asList(usages);
      result.addAll(usagesList);

      for (AutomaticRenamerFactory factory : myRenamerFactories) {
        if (factory.isApplicable(element)) {
          myRenamers.add(factory.createRenamer(element, newName, usagesList));
        }
      }

      for (AutomaticRenamerFactory factory :
          Extensions.getExtensions(AutomaticRenamerFactory.EP_NAME)) {
        if (factory.getOptionName() == null && factory.isApplicable(element)) {
          myRenamers.add(factory.createRenamer(element, newName, usagesList));
        }
      }
    }
    UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]);
    usageInfos = UsageViewUtil.removeDuplicatedUsages(usageInfos);
    return usageInfos;
  }
  private static List<XmlElementDescriptor> computeRequiredSubTags(XmlElementsGroup group) {

    if (group.getMinOccurs() < 1) return Collections.emptyList();
    switch (group.getGroupType()) {
      case LEAF:
        XmlElementDescriptor descriptor = group.getLeafDescriptor();
        return descriptor == null
            ? Collections.<XmlElementDescriptor>emptyList()
            : Collections.singletonList(descriptor);
      case CHOICE:
        LinkedHashSet<XmlElementDescriptor> set = null;
        for (XmlElementsGroup subGroup : group.getSubGroups()) {
          List<XmlElementDescriptor> descriptors = computeRequiredSubTags(subGroup);
          if (set == null) {
            set = new LinkedHashSet<XmlElementDescriptor>(descriptors);
          } else {
            set.retainAll(descriptors);
          }
        }
        if (set == null || set.isEmpty()) {
          return Collections.singletonList(null); // placeholder for smart completion
        }
        return new ArrayList<XmlElementDescriptor>(set);

      default:
        ArrayList<XmlElementDescriptor> list = new ArrayList<XmlElementDescriptor>();
        for (XmlElementsGroup subGroup : group.getSubGroups()) {
          list.addAll(computeRequiredSubTags(subGroup));
        }
        return list;
    }
  }