示例#1
1
  /**
   * This method should setup the flags/switches for the java command which will determine the
   * actual command to be executed.
   *
   * <p>Sets up flags like :
   *
   * <ul>
   *   <li>-Dem.home
   *   <li>-Dprocess.name
   * </ul>
   *
   * <br>
   * add computes the classpath.
   */
  protected void updateFlags(ServerCommand serverCmd) {

    String bootDir = System.getProperty("em.home");
    String appType = System.getProperty("appType");
    String appInst = System.getProperty("appInst");

    String javaClasspath = serverCmd.getClasspath();
    String processName = getProcessNameForLog();

    List jvmFlags = serverCmd.getJVMFlags();

    int cpToken = -1;

    for (int i = 0; i < jvmFlags.size(); i++) {
      String token = (String) jvmFlags.get(i);
      if (token.startsWith("-classpath")) {
        cpToken = i;
        javaClasspath = null;
      } else if (token.startsWith("-Dem.home")) {
        bootDir = null;
      } else if (token.startsWith("-Dprocess.name")) {
        processName = null;
      }
    }

    List addonJVMFlags = new LinkedList();

    if (bootDir != null) {
      addonJVMFlags.add("-Dem.home=" + bootDir);
    }

    if (processName != null) {
      addonJVMFlags.add("-Dprocess.name=" + processName);
    }

    if (!(appType == null || appType.trim().equals(""))) {
      addonJVMFlags.add("-DappType=" + appType);
    }

    if (!(appInst == null || appInst.trim().equals(""))) {
      addonJVMFlags.add("-DappInst=" + appInst);
    }

    if (cpToken != -1) {
      jvmFlags.remove(cpToken);
      String str = (String) jvmFlags.remove(cpToken);
      serverCmd.setClasspath(str);
    }

    jvmFlags.addAll(addonJVMFlags);
  }
示例#2
0
 /**
  * @param table_list lista de tabelas
  * @param visited_tables lista de tabelas visitadas
  * @param final_table tabela final/pretendida
  */
 public static Node iterativeDepthFirstSearch(
     int[][] initial_table, int[][] final_table, int max_depth) {
   List table_list = new List();
   table_list.addFirst(initial_table, 0, "");
   List visited_tables = new List();
   int[][] current_table = new int[3][3];
   int depth = 0;
   String path = new String();
   while (!table_list.isEmpty()) {
     List child_nodes = new List();
     path = table_list.getPath();
     depth = table_list.getDepth();
     current_table = table_list.remove();
     if (isSolution(current_table, final_table)) return new Node(current_table, depth, path, null);
     visited_tables.addFirst(current_table, depth, path);
     if (depth < max_depth) {
       child_nodes = playDFS(child_nodes, current_table, depth, path);
       // verifica se algum dos filhos já foi visitado
       while (!child_nodes.isEmpty()) {
         int d = child_nodes.getDepth();
         String s = child_nodes.getPath();
         int[][] child_table = child_nodes.remove();
         if (!visited_tables.contains(child_table)) table_list.addFirst(child_table, d, s);
       }
     }
   }
   return iterativeDepthFirstSearch(initial_table, final_table, max_depth + 1);
 }
  public void compareArrays() {
    int decrement_index = -1;
    int increment_index = -1;

    for (int i = 0; i < listX.size(); i++) {
      Integer elemX = listX.get(i);
      Integer elemY = listY.get(i);
      if ((elemX < elemY) && increment_index == -1) {
        increment_index = i;
      } else if ((elemY < elemX) && decrement_index == -1) {
        decrement_index = i;
      }

      if (increment_index != -1 && decrement_index != -1) {
        int elemI = listX.remove(increment_index);
        listX.add(increment_index, ++elemI);
        increment_index = 1;

        int elemD = listX.remove(decrement_index);
        listX.add(decrement_index, --elemD);
        decrement_index = -1;
        if (nop == -1) nop = 0;
        nop++;
      }
    }
  }
示例#4
0
  public static void main(String[] args) {

    List<Card> cards = new LinkedList<Card>();
    for (Value v : Value.values()) {
      for (Suit s : Suit.values()) {
        cards.add(new Card(v, s));
      }
    }

    Random rand = new Random();
    Card[] cards1 = new Card[7];
    Card[] cards2 = new Card[7];

    for (int i = 0; i < 7; i++) {
      // Card c = cards.remove(rand.nextInt(cards.size())) ;
      Card c1 = cards.remove(2 + i * 3);
      cards1[i] = c1;
      Card c2 = cards.remove(rand.nextInt(cards.size()));
      cards2[i] = c2;
    }

    System.out.println("------ Card 1 ---------");
    for (Card c : cards1) {
      System.out.println(c.getSuit() + " " + c.getValue());
    }
    System.out.println(Round.getRank(cards1));
    System.out.println("------ Card 2 ---------");
    for (Card c : cards2) {
      System.out.println(c.getSuit() + " " + c.getValue());
    }
    System.out.println(Round.getRank(cards2));
  }
示例#5
0
 public RubyValue replace(int start, int length, RubyValue value) {
   int index = getRealIndex(start);
   if (value == RubyConstant.QNIL) {
     for (int i = 0; i < length; i++) {
       array_.remove(index);
     }
     return value;
   }
   if (length < 0) {
     throw new RubyException(RubyRuntime.IndexErrorClass, "negative length (" + length + ")");
   } else if (0 == length) {
     if (value instanceof RubyArray) {
       array_.addAll(index, ((RubyArray) value).array_);
     } else {
       array_.add(index, value);
     }
   } else {
     for (int i = 0; i < length - 1; ++i) {
       array_.remove(index);
     }
     if (value instanceof RubyArray) {
       array_.remove(index);
       array_.addAll(index, ((RubyArray) value).array_);
     } else {
       array_.set(index, value);
     }
   }
   return value;
 }
  public static void main(String[] args) {
    // ArrayList list = new ArrayList();
    // List list1 = new ArrayList();

    List list1 = new Vector();
    list1.add(1);
    list1.add(2);
    list1.add("Hello");
    list1.add(5.5);
    // Add an element at index 4
    list1.add(4, "Yeah");
    // list1.add(new Book("Book 1"));

    list1.set(2, 100);
    list1.remove("Hello");
    list1.remove(1);

    if (list1.contains("Yeah")) {
      System.out.println("----EXISTS-------");
    }

    //		for (int i = 0; i < list1.size(); i++) {
    //			Object element = list1.get(i);
    //			System.out.println(element);
    //		}
    // Enhanced For Loop
    for (Object element : list1) {
      System.out.println(element);
    }
  }
  public static Phylogeny generateRandomTree(int size, boolean randomNames) {
    Random random = new Random();

    List<PhylogenyNode> nodes = new ArrayList<>();
    for (int i = 0; i < size; i++) {
      PhylogenyNode newNode = new PhylogenyNode();
      newNode.setName(i + "");
      nodes.add(newNode);
    }

    while (nodes.size() > 1) {
      int i = random.nextInt(nodes.size());
      PhylogenyNode node1 = nodes.get(i);
      nodes.remove(i);
      int j = random.nextInt(nodes.size());
      PhylogenyNode node2 = nodes.get(j);
      nodes.remove(j);
      PhylogenyNode newNode = new PhylogenyNode();
      newNode.setChild1(node1);
      newNode.setChild2(node2);
      nodes.add(newNode);
      newNode.setName(newNode.getId() + "");
    }

    Phylogeny tree = new Phylogeny();
    tree.setRoot(nodes.get(0));

    if (!randomNames) {
      renameTreeLeavesLeftToRight(tree);
    }
    return tree;
  }
 private void setResultIds(Item item, int index) {
   if (item != null && item instanceof CatalogItem) {
     CatalogItem catalogItem = (CatalogItem) item;
     if (catalogItem.IsChecked) {
       int insertIndex = index <= 0 ? -1 : (index - 1);
       if (mySelectedItems.contains(catalogItem)) {
         mySelectedItems.remove(catalogItem);
       }
       if (insertIndex >= 0) {
         mySelectedItems.add(insertIndex, catalogItem);
       } else {
         mySelectedItems.add(catalogItem);
       }
     } else {
       mySelectedItems.remove(catalogItem);
     }
     final ArrayList<String> ids = new ArrayList<String>();
     for (Item selectedItem : mySelectedItems) {
       if (selectedItem instanceof CatalogItem) {
         final CatalogItem ci = (CatalogItem) selectedItem;
         if (ci.IsChecked) {
           ids.add(ci.Id);
         }
       }
     }
     setResult(
         RESULT_OK,
         new Intent()
             .putStringArrayListExtra(NetworkLibraryActivity.ENABLED_CATALOG_IDS_KEY, ids));
   }
 }
示例#9
0
 static void recursive(List<List<String>> nqueens, List<Integer> list, int n) {
   if (list.size() == n) {
     List<String> board = new ArrayList<String>();
     for (int i = 0; i < n; i++) {
       StringBuilder row = new StringBuilder();
       for (int j = 0; j < n; j++) row.append(list.get(i) == j ? "Q" : ".");
       board.add(row.toString());
     }
     nqueens.add(board);
     list.remove(list.size() - 1);
     return;
   }
   for (int i = 0; i < n; i++) {
     boolean isValid = true;
     int x1 = list.size();
     int y1 = i;
     for (int j = 0; j < list.size(); j++) {
       int x2 = j;
       int y2 = list.get(j);
       if (y1 == y2 || Math.abs(x1 - x2) == Math.abs(y1 - y2)) {
         isValid = false;
         break;
       }
     }
     if (isValid) {
       list.add(i);
       recursive(nqueens, list, n);
     }
   }
   if (!list.isEmpty()) list.remove(list.size() - 1);
 }
示例#10
0
  /**
   * If the user has selected random colors, pick them randomly for the user.
   *
   * @param selectedColors a string of the colors selected.
   * @return a String representation of the new colors chosen.
   */
  private static String getRandomColors(String selectedColors) {

    Random random = new Random();
    List<Character> availableColors = new ArrayList<>();
    for (ColoredManaSymbol cms : ColoredManaSymbol.values()) {
      availableColors.add(cms.toString().charAt(0));
    }

    StringBuilder generatedColors = new StringBuilder();
    int randomColors = 0;
    for (int i = 0; i < selectedColors.length(); i++) {
      char currentColor = selectedColors.charAt(i);
      if (currentColor != 'X') {
        generatedColors.append(currentColor);
        availableColors.remove(new Character(currentColor));
      } else {
        randomColors++;
      }
    }
    for (int i = 0; i < randomColors && !availableColors.isEmpty(); i++) {
      int index = random.nextInt(availableColors.size());
      generatedColors.append(availableColors.remove(index));
    }
    return generatedColors.toString();
  }
示例#11
0
  protected static String[] reorder(String[] enabled, String[] known, String[] blacklisted) {
    List<String> unknown = new ArrayList<String>();
    Collections.addAll(unknown, enabled);

    // Remove blacklisted items
    if (blacklisted != null) {
      for (String item : blacklisted) {
        unknown.remove(item);
      }
    }

    // Order known items
    List<String> result = new ArrayList<String>();
    for (String item : known) {
      if (unknown.remove(item)) {
        result.add(item);
      }
    }

    // Add unknown items at the end. This way security won't get worse when unknown ciphers
    // start showing up in the future.
    result.addAll(unknown);

    return result.toArray(new String[result.size()]);
  }
示例#12
0
  public static void main(String[] args) {
    Scanner cin = new Scanner(System.in);
    List<String> s1 = new ArrayList<String>();
    List<String> s2 = new ArrayList<String>();
    int indexS1 = 0;
    int indexS2 = 0;
    s1.add(cin.nextLine());
    while (s1.get(indexS1).charAt(0) != 'X') {
      indexS1++;
      s1.add(cin.nextLine());
    }
    s1.remove(indexS1);
    Collections.sort(s1);

    s2.add(cin.nextLine());
    while (s2.get(indexS2).charAt(0) != 'X') {
      indexS2++;
      s2.add(cin.nextLine());
    }
    s2.remove(indexS2);

    for (int i = 0; i < s2.size(); i++) {
      boolean out = false;
      for (int j = 0; j < s1.size(); j++) {
        if (isSame(s2.get(i), s1.get(j))) {
          System.out.println(s1.get(j));
          out = true;
        }
      }
      if (!out) {
        System.out.println("NOT A VALID WORD");
      }
      System.out.println("******");
    }
  }
  private void clearOutTheINEventAndIrpListForISO(List listOfPipeEvents, List listOfIrps) {
    // all of the IRPs and events in which we are interested SHOULD have a non zero length
    // amount of data returned.
    // Once the zero length data IRPs and events are removed, only the IRPs and events that received
    // the
    // expected OUT data should be left in the lists
    printDebug("Total pipe events for IN ISO is " + listOfPipeEvents.size());

    for (int i = (listOfPipeEvents.size() - 1); i >= 0; i--) {
      // all of the IRPs in which we are interested SHOULD have a non zero length
      // amount of data returned.
      // Once the zero length data IRP events are removed, only the IRP events that received the
      // expected OUT data should be left in the list

      Assert.assertTrue(
          "There should be no error events in the list.",
          ((UsbPipeEvent) listOfPipeEvents.get(i)).getClass() == UsbPipeDataEvent.class);
      if (((UsbPipeDataEvent) listOfPipeEvents.get(i)).getUsbIrp().getActualLength() == 0) {
        listOfPipeEvents.remove(i);
        Assert.assertEquals(
            "Original Irps and pipe event Irps should be zero actual length in the same position in the list.",
            0,
            ((UsbIrp) listOfIrps.get(i)).getActualLength());
        listOfIrps.remove(i);
      } else {
        Assert.assertEquals(
            "Original Irps and pipe event Irps actual length should be the same at the same position in the list.",
            ((UsbPipeDataEvent) listOfPipeEvents.get(i)).getUsbIrp().getActualLength(),
            ((UsbIrp) listOfIrps.get(i)).getActualLength());
        printDebug("Non-zero actual length pipe event found at index " + i);
      }
    }
    Assert.assertFalse(
        "None of the Isochronous IN IRPs received any data", 0 == listOfPipeEvents.size());
  };
示例#14
0
  /**
   * fileReader builds a scene from a file
   *
   * @return sceneOfInput
   * @throws IOException
   */
  public static Scene fileReader() throws IOException {
    long startTime = System.currentTimeMillis();

    //		FileReader fr = new FileReader("file/LogManager-short.dat");
    FileReader fr = new FileReader("file/LogManager-live-tool-2.dat");
    //		FileReader fr = new FileReader("file/LogManager-example.dat");
    //		FileReader fr = new FileReader("file/LogManager-long.dat");
    BufferedReader br = new BufferedReader(fr);

    String line = "";
    List<Tick> tmpTickList = new ArrayList<Tick>();

    /*
     * Read file, split lines into Type and Timestamp, generate Ticks
     */
    while ((line = br.readLine()) != null) {

      String[] parts = line.split(";", -1);
      int tmpTimestamp = Integer.parseInt(parts[0]);
      Tick tmpTick = new Tick(tmpTimestamp, parts[1], parts[2]);
      tmpTickList.add(tmpTick);
    }
    br.close();
    /*
     * filtering out special hashmarks and adding their content to mark before
     */
    int lastHashMark = 0;
    for (int i = 0; i < tmpTickList.size(); i++) {
      Tick currentTick = tmpTickList.get(i);

      if (currentTick.getType().compareTo("########") == 0) {

        lastHashMark = i;

      } else if (currentTick.getType().compareTo("#+#+#+#+") == 0) {

        if (lastHashMark == 0) { // if first mark is special hash

          tmpTickList.remove(i); // remove it

        } else {

          tmpTickList.remove(lastHashMark); // otherwise remove last normal hash
          currentTick.setType("########"); // and convert special to normal hash
          // thus adding special object to normal
          lastHashMark = i - 1; // set new hashmark
        }
      }
    }
    List<Sequence> sequenceList = structureCreator(tmpTickList);

    Sequence[] sequenceArray = new Sequence[sequenceList.size()];
    sequenceArray = sequenceList.toArray(sequenceArray);

    Scene sceneFromInput = new Scene(sequenceArray);

    System.out.println((System.currentTimeMillis() - startTime) + " milliseconds to read log");
    return sceneFromInput;
  }
示例#15
0
 private void removePlayer(Player player) {
   int index = players.indexOf(player);
   if (index < 0) return;
   players.remove(index);
   Game game = games.remove(index);
   removeController(player, index);
   game.destroy();
 }
 public void deleteChangeList(final ShelvedChangeList changeList) {
   deleteListImpl(changeList);
   if (!changeList.isRecycled()) {
     myShelvedChangeLists.remove(changeList);
   } else {
     myRecycledShelvedChangeLists.remove(changeList);
   }
   notifyStateChanged();
 }
示例#17
0
 public void addBookToRecentList(Book book) {
   final List<Long> ids = myDatabase.loadRecentBookIds();
   final Long bookId = book.getId();
   ids.remove(bookId);
   ids.add(0, bookId);
   if (ids.size() > 12) {
     ids.remove(12);
   }
   myDatabase.saveRecentBookIds(ids);
 }
  /**
   * Removes an object from the collection of choices.
   *
   * @param object The object to be removed
   */
  public void remove(T object) {
    int index = choices.indexOf(object);

    total -= currentFreqs.get(index);
    choices.remove(index);
    baseFreqs.remove(index);
    currentFreqs.remove(index);

    while (pregenerated.remove(object)) /* nothing inside loop */ ;
  }
示例#19
0
  private static void filter(List<Class> tests) {
    // Requires separate datasets project
    tests.remove(ParseFolderTestBig.class);
    // Too slow
    tests.remove(ConcurrentKeyTest.class);
    tests.remove(ValueArrayToFrameTestAll.class);
    // Pure JUnit test
//    tests.remove(CBSChunkTest.class);
    //tests.remove(GBMDomainTest.class);
  }
示例#20
0
 public static void main(String[] args) {
   Random rand = new Random(47);
   List<Pet> pets = Pets.arrayList(7);
   print("1: " + pets);
   Hamster h = new Hamster();
   pets.add(h); // Automatically resizes
   print("2: " + pets);
   print("3: " + pets.contains(h));
   pets.remove(h); // Remove by object
   Pet p = pets.get(2);
   print("4: " + p + " " + pets.indexOf(p));
   Pet cymric = new Cymric();
   print("5: " + pets.indexOf(cymric));
   print("6: " + pets.remove(cymric));
   // Must be the exact object:
   print("7: " + pets.remove(p));
   print("8: " + pets);
   pets.add(3, new Mouse()); // Insert at an index
   print("9: " + pets);
   List<Pet> sub = pets.subList(1, 4);
   print("subList: " + sub);
   print("10: " + pets.containsAll(sub));
   Collections.sort(sub); // In-place sort
   print("sorted subList: " + sub);
   // Order is not important in containsAll():
   print("11: " + pets.containsAll(sub));
   Collections.shuffle(sub, rand); // Mix it up
   print("shuffled subList: " + sub);
   print("12: " + pets.containsAll(sub));
   List<Pet> copy = new ArrayList<Pet>(pets);
   sub = Arrays.asList(pets.get(1), pets.get(4));
   print("sub: " + sub);
   copy.retainAll(sub);
   print("13: " + copy);
   copy = new ArrayList<Pet>(pets); // Get a fresh copy
   copy.remove(2); // Remove by index
   print("14: " + copy);
   copy.removeAll(sub); // Only removes exact objects
   print("15: " + copy);
   copy.set(1, new Mouse()); // Replace an element
   print("16: " + copy);
   copy.addAll(2, sub); // Insert a list in the middle
   print("17: " + copy);
   print("18: " + pets.isEmpty());
   pets.clear(); // Remove all elements
   print("19: " + pets);
   print("20: " + pets.isEmpty());
   pets.addAll(Pets.arrayList(4));
   print("21: " + pets);
   Object[] o = pets.toArray();
   print("22: " + o[3]);
   Pet[] pa = pets.toArray(new Pet[0]);
   print("23: " + pa[3].id());
 }
示例#21
0
 @Override
 public void removePlayerByIp(String ip) {
   lock.writeLock().lock();
   try {
     int index = players.indexOf(findPlayerByIp(ip));
     if (index < 0) return;
     players.remove(index);
     games.remove(index);
   } finally {
     lock.writeLock().unlock();
   }
 }
  /**
   * follows the root by all its children to wrap the all up with all the extra info needed and adds
   * the tree to the matrix.
   *
   * @param currRoot - root to go over tree from
   * @param entitiesList - entities available
   * @param relationshipsList - relationship between the given entities
   * @param currRow - the current row in the matrix we are working on
   * @param rows - the matrix.
   */
  private void builtTreeFromRoot(
      GXMoreThanNode currRoot,
      List<InternalNode> entitiesList,
      List<InternalRelationship> relationshipsList,
      List<GXMoreThanNode> currRow,
      List<List<GXMoreThanNode>> rows) {

    // this is the first node that comes from the currRoot
    // we'll use the mark to know where to continue laying out from
    GXMoreThanNode mark = null;

    List<InternalRelationship> relationshipsListCopy =
        new ArrayList<InternalRelationship>(relationshipsList);
    // Orders the children of the currRoot in the given row (the row under it)
    for (InternalRelationship rel : relationshipsListCopy) {
      if (currRoot.getNode().equals(rel.getSource())) {
        InternalNode destNode = rel.getDestination();

        // if the destination node hasn't been laid out yet
        if (entitiesList.contains(destNode)) {

          // place it in the row (as in lay it out)
          GXMoreThanNode currNode = new GXMoreThanNode(destNode, currRoot.getNode());
          currRoot.addChild(currNode);
          currRow.add(currNode);
          currNode.addedToRow(currRow);
          entitiesList.remove(destNode);

          // if this is the first node, save it as a mark.
          if (mark == null) {
            mark = currNode;
          }

          // remove the relationship since both of its ends have been laid out.
          relationshipsList.remove(rel);
        }
      }
    }

    // if new children have been added
    if (mark != null) {

      // Create a next row if necessary
      if (rows.size() - 1 <= rows.indexOf(currRow)) {
        rows.add(new ArrayList<GXMoreThanNode>());
      }

      List<GXMoreThanNode> nextRow = rows.get(rows.indexOf(currRow) + 1);
      for (int i = currRow.indexOf(mark); i < currRow.size(); i++) {
        builtTreeFromRoot(currRow.get(i), entitiesList, relationshipsList, nextRow, rows);
      }
    }
  }
 private static void pathto(World world, int i, int j, int k) {
   List<ChunkCoordinates> blocks = Lists.newLinkedList();
   List<ChunkCoordinates> portals = Lists.newLinkedList();
   List<ChunkCoordinates> repath = Lists.newLinkedList();
   List<ChunkCoordinates> redraw = Lists.newLinkedList();
   blocks.add(new ChunkCoordinates(i, j, k));
   while ((portals.size() > 0) || (blocks.size() > 0)) {
     while (blocks.size() > 0) {
       ChunkCoordinates coords = blocks.remove(0);
       directPortal(world, coords.posX + 1, coords.posY, coords.posZ, 5, blocks, portals);
       directPortal(world, coords.posX, coords.posY + 1, coords.posZ, 1, blocks, portals);
       directPortal(world, coords.posX, coords.posY, coords.posZ + 1, 3, blocks, portals);
       directPortal(world, coords.posX - 1, coords.posY, coords.posZ, 6, blocks, portals);
       directPortal(world, coords.posX, coords.posY - 1, coords.posZ, 2, blocks, portals);
       directPortal(world, coords.posX, coords.posY, coords.posZ - 1, 4, blocks, portals);
       redraw.add(coords);
     }
     if (portals.size() > 0) {
       ChunkCoordinates coords = portals.remove(0);
       directPortal(world, coords.posX + 1, coords.posY, coords.posZ, 5, blocks, portals);
       directPortal(world, coords.posX, coords.posY + 1, coords.posZ, 1, blocks, portals);
       directPortal(world, coords.posX, coords.posY, coords.posZ + 1, 3, blocks, portals);
       directPortal(world, coords.posX - 1, coords.posY, coords.posZ, 6, blocks, portals);
       directPortal(world, coords.posX, coords.posY - 1, coords.posZ, 2, blocks, portals);
       directPortal(world, coords.posX, coords.posY, coords.posZ - 1, 4, blocks, portals);
       if (world.getBlock(coords.posX, coords.posY, coords.posZ) == NailedBlocks.portal) {
         repath.add(coords);
       }
     }
   }
   while (repath.size() > 0) {
     ChunkCoordinates coords = repath.remove(0);
     if (world.getBlock(coords.posX, coords.posY, coords.posZ) == NailedBlocks.portal) {
       if (!BlockPortal.isValidPortal(world, coords.posX, coords.posY, coords.posZ)) {
         repathNeighbors(world, coords.posX, coords.posY, coords.posZ);
         world.setBlock(coords.posX, coords.posY, coords.posZ, Blocks.air, 0, 0);
         addSurrounding(repath, coords.posX, coords.posY, coords.posZ);
       } else {
         redraw.add(coords);
       }
     }
   }
   for (ChunkCoordinates coords : redraw) {
     if (world.blockExists(coords.posX, coords.posY, coords.posZ)) {
       world.markBlockForUpdate(coords.posX, coords.posY, coords.posZ);
       world.notifyBlocksOfNeighborChange(
           coords.posX,
           coords.posY,
           coords.posZ,
           world.getBlock(coords.posX, coords.posY, coords.posZ));
     }
   }
 }
 @Override
 public String readLine() throws IOException {
   if (buffer.size() > 0) {
     return buffer.remove(0);
   } else {
     String line = super.readLine();
     if (line == null) {
       return null;
     }
     buffer.addAll(lineExpander.expandLine(line));
     return buffer.remove(0);
   }
 }
  public static Pair<Phylogeny, Phylogeny> generateIdenticalRandomTrees(
      int size, boolean randomNames) {
    Random random = new Random();

    List<PhylogenyNode> t1Nodes = new ArrayList<>();
    List<PhylogenyNode> t2Nodes = new ArrayList<>();
    for (int i = 0; i < size; i++) {
      PhylogenyNode t1NewNode = new PhylogenyNode();
      PhylogenyNode t2NewNode = new PhylogenyNode();
      t1NewNode.setName(i + "");
      t2NewNode.setName(i + "");
      t1Nodes.add(t1NewNode);
      t2Nodes.add(t2NewNode);
    }

    while (t1Nodes.size() > 1) {
      int i = random.nextInt(t1Nodes.size());
      PhylogenyNode t1Child1 = t1Nodes.get(i);
      PhylogenyNode t2Child1 = t2Nodes.get(i);
      t1Nodes.remove(i);
      t2Nodes.remove(i);
      int j = random.nextInt(t1Nodes.size());
      PhylogenyNode t1Child2 = t1Nodes.get(j);
      PhylogenyNode t2Child2 = t2Nodes.get(j);
      t1Nodes.remove(j);
      t2Nodes.remove(j);
      PhylogenyNode t1NewNode = new PhylogenyNode();
      PhylogenyNode t2NewNode = new PhylogenyNode();
      t1NewNode.setChild1(t1Child1);
      t1NewNode.setChild2(t1Child2);
      t2NewNode.setChild1(t2Child1);
      t2NewNode.setChild2(t2Child2);
      t1Nodes.add(t1NewNode);
      t2Nodes.add(t2NewNode);
      t1NewNode.setName(t1NewNode.getId() + "");
      t2NewNode.setName(t2NewNode.getId() + "");
    }

    Phylogeny tree1 = new Phylogeny();
    Phylogeny tree2 = new Phylogeny();
    tree1.setRoot(t1Nodes.get(0));
    tree2.setRoot(t2Nodes.get(0));

    if (!randomNames) {
      renameTreeLeavesLeftToRight(tree1);
      renameTreeLeavesLeftToRight(tree2);
    }
    return new Pair<>(tree1, tree2);
  }
示例#26
0
  private void backwardsConditioning(List<Node> pc, Node target) {
    for (Node x : new LinkedList<>(pc)) {
      List<Node> _pc = new LinkedList<>(pc);
      _pc.remove(x);
      _pc.remove(target);

      List<Node> minAssoc = minAssoc(x, target, _pc);

      numIndTests++;

      if (independenceTest.isIndependent(x, target, minAssoc)) {
        pc.remove(x);
      }
    }
  }
示例#27
0
 public static void removeInactiveMyPet(InactiveMyPet inactiveMyPet) {
   if (inactiveMyPet == null) {
     return;
   }
   lInactivePets.remove(inactiveMyPet);
   if (mInctivePets.containsKey(inactiveMyPet.getPetOwner())) {
     List<InactiveMyPet> myPetList = mInctivePets.get(inactiveMyPet.getPetOwner());
     if (myPetList.contains(inactiveMyPet)) {
       myPetList.remove(inactiveMyPet);
     }
     if (myPetList.size() == 0) {
       mInctivePets.remove(inactiveMyPet.getPetOwner());
     }
   }
 }
示例#28
0
  /**
   * Merge list of expressions into a tree of logical/relational expressions. This is done
   * recursively in several passes, one per level of precedence starting at the highest precedence
   * level. Recursion exits when a single expression remains.
   *
   * @param listExpressions list of expressions to merge
   * @param precedenceLevel the precedence level that is to be merged
   * @return tree of expressions with a single root expression
   */
  private List<Expression> mergeExpressions(List<Expression> listExpressions, int precedenceLevel) {
    if (listExpressions.size() > 1) {
      Stack<Expression> stack = new Stack<Expression>();

      stack.push(listExpressions.remove(0));
      while (!listExpressions.isEmpty()) {
        Expression exp = stack.pop();
        Expression left = stack.empty() ? null : stack.pop();
        Expression right = listExpressions.remove(0);
        stack.addAll(exp.merge(left, right, precedenceLevel));
      }
      return mergeExpressions(new ArrayList<Expression>(stack), precedenceLevel - 1);
    }
    return listExpressions;
  }
  public Map<String, List> fetchBibHolding(boolean cursor) throws SQLException {
    String holdingId = "";
    String tempHoldingId = "";
    List bibIds = new ArrayList();
    Map<String, List> map = null;

    if (cursor) {
      while (bibHoldingsResultSet.next()) {
        holdingId = "who-" + bibHoldingsResultSet.getString("HOLDINGS_ID");
        if (StringUtils.isNotEmpty(tempHoldingId) && !tempHoldingId.equals(holdingId)) {

          if (bibIds.size() > 0) {
            map = new HashMap<>();
            bibIds.remove(0);
            map.put(tempHoldingId, bibIds);
            return map;
          }
        }

        bibIds.add("wbm-" + bibHoldingsResultSet.getString("BIB_ID"));
        tempHoldingId = holdingId;
      }

    } else {
      while (bibHoldingsResultSet.next()) {
        holdingId = "who-" + bibHoldingsResultSet.getString("HOLDINGS_ID");
        if (StringUtils.isNotEmpty(tempHoldingId) && !tempHoldingId.equals(holdingId)) {

          map = new HashMap<>();
          map.put(tempHoldingId, bibIds);
          return map;
        }
        bibIds.add("wbm-" + bibHoldingsResultSet.getString("BIB_ID"));
        tempHoldingId = holdingId;
      }
    }

    if (bibIds.size() > 0) {
      map = new HashMap<>();
      bibIds.remove(0);
      map.put(tempHoldingId, bibIds);
      return map;
    } else {
      map = null;
    }
    bibHoldingsResultSet.close();
    return map;
  }
  /**
   * Builds the matrix of nodes. each node will be wrapped with necessary innformation such as who
   * are the direct children and parent (only visually in the graph not the actual relationships)
   * the returned matrix is organized more or less as the real tree.
   *
   * @param entitiesList - entities to place in the matrix
   * @param relationshipsList - the relationships between the entities given
   * @return the matrix - (a list of rows of nodes)
   */
  private List<List<GXMoreThanNode>> buildNodeMatrix(
      List<InternalNode> entitiesList, List<InternalRelationship> relationshipsList) {
    List<List<GXMoreThanNode>> rows = new ArrayList<List<GXMoreThanNode>>();
    while (!entitiesList.isEmpty()) {
      InternalNode root = getFirstEntity(entitiesList, relationshipsList);

      // add root row if necessary
      if (rows.isEmpty()) {
        rows.add(new ArrayList<GXMoreThanNode>());
        rows.add(new ArrayList<GXMoreThanNode>());
      }

      // lay out the current root node and remove it from the list of entities left
      entitiesList.remove(root);
      GXMoreThanNode moreThanRoot = new GXMoreThanNode(root, null);
      rows.get(0).add(moreThanRoot);

      // build the tree that spreads from this current root.
      builtTreeFromRoot(moreThanRoot, entitiesList, relationshipsList, rows.get(1), rows);
    }

    trimEmptyRows(rows);

    return rows;
  }