public static void main(String[] args) {
    int n = 10000;
    if (args.length > 0) n = Integer.parseInt(args[0]);

    List<Integer> sorted = new ArrayList<Integer>(n);
    for (int i = 0; i < n; i++) sorted.add(new Integer(i));
    List<Integer> shuffled = new ArrayList<Integer>(sorted);
    Collections.shuffle(shuffled);

    Queue<Integer> pq = new PriorityQueue<Integer>(n, new MyComparator());
    for (Iterator<Integer> i = shuffled.iterator(); i.hasNext(); ) pq.add(i.next());

    List<Integer> recons = new ArrayList<Integer>();
    while (!pq.isEmpty()) recons.add(pq.remove());
    if (!recons.equals(sorted)) throw new RuntimeException("Sort test failed");

    recons.clear();
    pq = new PriorityQueue<Integer>(shuffled);
    while (!pq.isEmpty()) recons.add(pq.remove());
    if (!recons.equals(sorted)) throw new RuntimeException("Sort test failed");

    // Remove all odd elements from queue
    pq = new PriorityQueue<Integer>(shuffled);
    for (Iterator<Integer> i = pq.iterator(); i.hasNext(); )
      if ((i.next().intValue() & 1) == 1) i.remove();
    recons.clear();
    while (!pq.isEmpty()) recons.add(pq.remove());

    for (Iterator<Integer> i = sorted.iterator(); i.hasNext(); )
      if ((i.next().intValue() & 1) == 1) i.remove();

    if (!recons.equals(sorted)) throw new RuntimeException("Iterator remove test failed.");
  }
  @Override
  public void update(GameContainer gc, int delta) throws SlickException {
    rand.nextDouble();
    if (System.currentTimeMillis() - lastUpdate > simulationDelay) {
      lastUpdate = System.currentTimeMillis();
      runSimulation();
    }

    Airplane airplaneHandle;
    Iterator<Airplane> it;
    it = airQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.update(delta);
    }
    it = groundQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.update(delta);
    }
    airplaneHandle = runway.getCurrentAirplane();
    if (airplaneHandle != null) airplaneHandle.update(delta);
  }
  @Override
  public void render(GameContainer gc, Graphics g) throws SlickException {
    backgroundImage.draw();

    Airplane airplaneHandle;
    Iterator<Airplane> it;
    it = airQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.render(g, airplaneImage);
    }
    it = groundQueue.iterator();
    while (it.hasNext()) {
      airplaneHandle = it.next();

      airplaneHandle.render(g, airplaneImage);
    }
    airplaneHandle = runway.getCurrentAirplane();
    if (airplaneHandle != null) airplaneHandle.render(g, airplaneImage);

    g.setColor(Color.white);
    g.drawString("Airport Simulator", gc.getWidth() - 170, 10);
    g.drawString("Update: " + currentUpdate, gc.getWidth() - 130, gc.getHeight() - 30);
  }
  public static void assertEqual(Queue<NdPoint> expected, Queue<NdPoint> actual) {
    String error = String.format("expected: %s but was: %s", expected, actual);
    assertEquals(error, expected.size(), actual.size());

    Iterator<NdPoint> iexpect = expected.iterator();
    Iterator<NdPoint> iactual = actual.iterator();
    while (iexpect.hasNext()) {
      NdPoint e = iexpect.next();
      NdPoint a = iactual.next();
      assertTrue(error, e.equals(a));
    }
  }
 void checkIterationSanity(Queue q) {
   if (rnd.nextBoolean()) return;
   int size = q.size();
   Object[] a = q.toArray();
   Object[] b = new Object[size + 2];
   Arrays.fill(b, Boolean.TRUE);
   Object[] c = q.toArray(b);
   equal(a.length, size);
   check(b == c);
   check(b[size] == null);
   check(b[size + 1] == Boolean.TRUE);
   equal(q.toString(), Arrays.toString(a));
   Integer[] xx = null, yy = null;
   if (size > 0) {
     xx = new Integer[size - 1];
     Arrays.fill(xx, 42);
     yy = ((Queue<Integer>) q).toArray(xx);
     for (Integer zz : xx) equal(42, zz);
   }
   Iterator it = q.iterator();
   for (int i = 0; i < size; i++) {
     check(it.hasNext());
     Object x = it.next();
     check(x == a[i]);
     check(x == b[i]);
     if (xx != null) check(x == yy[i]);
   }
   check(!it.hasNext());
 }
  public MessageReference removeReferenceByID(final long messageID) throws Exception {
    if (browseOnly) {
      return null;
    }

    // Expiries can come in out of sequence with respect to delivery order

    Iterator<MessageReference> iter = deliveringRefs.iterator();

    MessageReference ref = null;

    while (iter.hasNext()) {
      MessageReference theRef = iter.next();

      if (theRef.getMessage().getMessageID() == messageID) {
        iter.remove();

        ref = theRef;

        break;
      }
    }

    return ref;
  }
  private void addMainSession(Session session) {
    InetSocketAddress remoteSocketAddress = session.getRemoteSocketAddress();
    log.warn(
        "Add a session: "
            + SystemUtils.getRawAddress(remoteSocketAddress)
            + ":"
            + remoteSocketAddress.getPort());
    Queue<Session> sessions = this.sessionMap.get(remoteSocketAddress);
    if (sessions == null) {
      sessions = new ConcurrentLinkedQueue<Session>();
      Queue<Session> oldSessions = this.sessionMap.putIfAbsent(remoteSocketAddress, sessions);
      if (null != oldSessions) {
        sessions = oldSessions;
      }
    }
    // If it is in failure mode,remove closed session from list
    if (this.failureMode) {
      Iterator<Session> it = sessions.iterator();
      while (it.hasNext()) {
        Session tmp = it.next();
        if (tmp.isClosed()) {
          it.remove();
          break;
        }
      }
    }

    sessions.offer(session);
    // Remove old session and close it
    while (sessions.size() > this.connectionPoolSize) {
      Session oldSession = sessions.poll();
      ((MemcachedSession) oldSession).setAllowReconnect(false);
      oldSession.close();
    }
  }
Example #8
0
  @NotNull
  private static Collection<CallableMemberDescriptor> extractMembersOverridableInBothWays(
      @NotNull CallableMemberDescriptor overrider,
      @NotNull Queue<CallableMemberDescriptor> extractFrom,
      @NotNull DescriptorSink sink) {
    Collection<CallableMemberDescriptor> overridable = new ArrayList<CallableMemberDescriptor>();
    overridable.add(overrider);
    for (Iterator<CallableMemberDescriptor> iterator = extractFrom.iterator();
        iterator.hasNext(); ) {
      CallableMemberDescriptor candidate = iterator.next();
      if (overrider == candidate) {
        iterator.remove();
        continue;
      }

      OverrideCompatibilityInfo.Result result1 =
          DEFAULT.isOverridableBy(candidate, overrider).getResult();
      OverrideCompatibilityInfo.Result result2 =
          DEFAULT.isOverridableBy(overrider, candidate).getResult();
      if (result1 == OVERRIDABLE && result2 == OVERRIDABLE) {
        overridable.add(candidate);
        iterator.remove();
      } else if (result1 == CONFLICT || result2 == CONFLICT) {
        sink.conflict(overrider, candidate);
        iterator.remove();
      }
    }
    return overridable;
  }
  public void setNextPosition() {
    if (mMovableMaskQueue.size() == 0) return;

    Iterator<MovableMask> it = mMovableMaskQueue.iterator();
    while (it.hasNext()) {
      MovableMask mask = it.next();
      int x = mask.getCenterX();
      int y = mask.getCenterY();
      int step = mask.getStep();
      int direction = mask.getDirection();
      switch (direction) {
        case Utils.NORTH:
          Utils.log(TAG, "moving north");
          mask.setCenter(x, y - step);
          break;
        case Utils.SOUTH:
          Utils.log(TAG, "moving south");
          mask.setCenter(x, y + step);
          break;
        case Utils.WEST:
          Utils.log(TAG, "moving west");
          mask.setCenter(x - step, y);
          break;
        case Utils.EAST:
          Utils.log(TAG, "moving east");
          mask.setCenter(x + step, y);
          break;
        default:
          break;
      }
      // Utils.log(TAG, "get next position,x:" + x + ",y" + y);

    }
  }
Example #10
0
  protected void handleView(View view) {
    this.view = view;
    if (log.isDebugEnabled()) log.debug("view=" + view);
    List<Address> members = view.getMembers();

    _consumerLock.lock();
    try {
      // This removes the consumers that were registered that are now gone
      Iterator<Owner> iterator = _consumersAvailable.iterator();
      while (iterator.hasNext()) {
        Owner owner = iterator.next();
        if (!members.contains(owner.getAddress())) {
          iterator.remove();
          sendRemoveConsumerRequest(owner);
        }
      }

      // This removes the tasks that those requestors are gone
      iterator = _runRequests.iterator();
      while (iterator.hasNext()) {
        Owner owner = iterator.next();
        if (!members.contains(owner.getAddress())) {
          iterator.remove();
          sendRemoveRunRequest(owner);
        }
      }

      synchronized (_awaitingReturn) {
        for (Entry<Owner, Runnable> entry : _awaitingReturn.entrySet()) {
          // The person currently servicing our request has gone down
          // without completing so we have to keep our request alive by
          // sending ours back to the coordinator
          Owner owner = entry.getKey();
          if (!members.contains(owner.getAddress())) {
            Runnable runnable = entry.getValue();
            // We need to register the request id before sending the request back to the coordinator
            // in case if our task gets picked up since another was removed
            _requestId.put(runnable, owner.getRequestId());
            _awaitingConsumer.add(runnable);
            sendToCoordinator(RUN_REQUEST, owner.getRequestId(), local_addr);
          }
        }
      }
    } finally {
      _consumerLock.unlock();
    }
  }
 @Override
 protected void execute(TaskListener listener) throws IOException {
   for (Iterator<PullRequestInstance> iter = terminatingInstances.iterator(); iter.hasNext(); ) {
     if (deleteInstance(iter.next(), listener)) {
       iter.remove();
     }
   }
 }
 public StreamsResultSet readRange(DateTime start, DateTime end) {
   LOGGER.debug("{} readRange", STREAMS_ID);
   this.start = start;
   this.end = end;
   readCurrent();
   StreamsResultSet result = (StreamsResultSet) providerQueue.iterator();
   return result;
 }
Example #13
0
 /**
  * Calculates the total weight of trucks currently on bridge
  *
  * @param None
  * @return totalWeight
  */
 public int getTotalWeight() {
   int totalWeight = 0;
   Iterator<Truck> it = theBridgeQueue.iterator();
   while (it.hasNext()) {
     totalWeight += it.next().getWeight();
   }
   return totalWeight;
 }
  public void generateBranches(
      World world, Random rand, int x, int y, int z, int height, double radius) {
    int branchCount = BRANCHES_BASE_NUMBER + rand.nextInt(BRANCHES_EXTRA);
    double curAngle = 0.0D;

    double[] average = {0, 0, 0};
    int[] start = {x, y, z};
    Queue<int[]> branches = new LinkedList<int[]>();

    // Generate the branches
    for (int i = 0; i < branchCount; i++) {
      // Get the branch radius and height
      double angle = (rand.nextInt(50) + 35) / 90.0D;
      double thisHeight = (height + 1) * Math.sin(angle) / 1.3;
      double thisRadius = radius * Math.cos(angle);

      // Get the branch rotation
      curAngle +=
          (rand.nextInt(360 / branchCount) + (360 / branchCount))
              / 90.0D; //  + (360.0D/branchCount) / 180.0D ;

      int x1 = (int) ((thisRadius) * Math.cos(curAngle));
      int z1 = (int) ((thisRadius) * Math.sin(curAngle));

      // Add the the average count
      average[0] += x1;
      average[1] += thisHeight;
      average[2] += z1;

      // Add to the branch list
      int[] node = new int[] {x1 + x, (int) thisHeight + y, z1 + z};

      // Add the branch end for leaf generation
      branches.add(node);

      // Generate the branch
      placeBlockLine(start, node, TreeBlock.TRUNK.get(), world);
    }

    // Place the branch tips
    Iterator<int[]> itt = branches.iterator();
    while (itt.hasNext()) {
      int[] cluster = itt.next();
      generateLeafCluster(world, cluster[0], cluster[1], cluster[2], 2, 1, TreeBlock.LEAVES.get());
    }

    // Calculate the center position
    average[0] /= branchCount;
    average[1] = (branchCount / average[1]) + 2.3D;
    average[2] /= branchCount;

    // Generate the canopy
    generateCanopy(
        world, rand, average[0] + x, y, average[2] + z, radius, height, TreeBlock.LEAVES.get());

    // Generate the center cone
    generateVerticalCone(world, x, y, z, height - 1, .75, 2, TreeBlock.LEAVES.get());
  }
  public void printQueue() {
    Queue<Neighbor> copy = new PriorityQueue<Neighbor>(neighbors);

    Iterator<Neighbor> itr = copy.iterator();
    System.out.println("SIZE: " + copy.size());
    while (itr.hasNext()) {
      Neighbor n = copy.poll();
      System.out.println(n.index + " - " + n.distance);
    }
  }
Example #16
0
 // Check if given node ID is in request queue
 private boolean elementInQueue(Queue que, int element) {
   Iterator iterator = que.iterator();
   while (iterator.hasNext()) {
     int e = (int) iterator.next();
     if (e == element) {
       return true;
     }
   }
   return false;
 }
Example #17
0
 /**
  * 删除ack对应的请求包
  *
  * @param ack
  */
 public synchronized void remove(InPacket ack) {
   for (Iterator<OutPacket> i = timeoutQueue.iterator(); i.hasNext(); ) {
     OutPacket packet = i.next();
     if (ack.equals(packet)) {
       toPort.remove(packet);
       i.remove();
       break;
     }
   }
 }
Example #18
0
 private void removeTerminatedClients() {
   Iterator<ISyncRequestClient> it = m_syncRequestClients.iterator();
   while (it.hasNext()) {
     ISyncRequestClient client = it.next();
     if (client.isTerminated()) {
       it.remove();
       m_terminatedClients.add(client);
     }
   }
 }
 /** Removes a listener for updated cluster states. */
 public void remove(ClusterStateListener listener) {
   clusterStateListeners.remove(listener);
   priorityClusterStateListeners.remove(listener);
   lastClusterStateListeners.remove(listener);
   postAppliedListeners.remove(listener);
   for (Iterator<NotifyTimeout> it = onGoingTimeouts.iterator(); it.hasNext(); ) {
     NotifyTimeout timeout = it.next();
     if (timeout.listener.equals(listener)) {
       timeout.cancel();
       it.remove();
     }
   }
 }
Example #20
0
 protected void processRegistrationQueue() {
   // add any elements in queue
   for (Iterator<Object[]> it = registrationQueue.iterator(); it.hasNext(); ) {
     Object[] args = it.next();
     SelectableChannel ch = (SelectableChannel) args[0];
     try {
       ch.register(selector, (Integer) args[1], args[2]);
     } catch (ClosedChannelException e) {
       e.printStackTrace();
     }
     it.remove();
   }
 }
  /**
   * Este método tiene ocmo objetivo crear el modulo de persistencia de la fabrica.
   *
   * @return Retorna un elemento para persistir
   */
  public Element persistir() {
    Element xmlElement = new Element("FabricaDeEnemigos");

    xmlElement.setAttribute("Nivel", String.valueOf(this.NumeroNivel));
    xmlElement.setAttribute("Cantidad_Enemigos", String.valueOf(this.Cantidad_Enemigos));

    Iterator it = ColaEnemigos.iterator();

    while (it.hasNext()) {
      xmlElement.addContent(((Enemigo) it.next()).persistir());
    }

    return xmlElement;
  }
 /**
  * 将一个等待中的任务从下等待队列中移除
  *
  * @param downloadId
  */
 protected synchronized void removeWaitQueueTask(int downloadId) {
   Iterator<FileDownloaderModel> iterator = mWaitQueue.iterator();
   while (iterator.hasNext()) {
     FileDownloaderModel model = iterator.next();
     if (model != null && model.getId() == downloadId) {
       try {
         iterator.remove();
       } catch (Exception e) {
         ILogger.e(e);
       }
       return;
     }
   }
 }
Example #23
0
 public boolean isValidMovePrefix(Move otherMove) {
   Piece otherPiece = otherMove.getPiece();
   if (otherPiece.getPieceColor() != piece.getPieceColor()
       || otherMove.getPieceColumn() != pieceColumn
       || otherMove.getPieceRow() != pieceRow) {
     return false;
   }
   Iterator<ChessboardPosition> it = steps.iterator();
   for (ChessboardPosition cp : otherMove.getSteps()) {
     if (!it.hasNext() || !cp.equals(it.next())) {
       return false;
     }
   }
   return true;
 }
  public void removeBookedTicket(String projectionId, Integer place) {
    deleterThread.interrupt();
    Iterator<Ticket> iterator = ticketExpirationTimes.iterator();
    while (iterator.hasNext()) {
      Ticket ticket = iterator.next();
      if (ticket.getProjection().getId().equals(Long.parseLong(projectionId))) {
        if (ticket.getSeat() == place) {
          ticketExpirationTimes.remove(ticket);
          break;
        }
      }
    }

    deleterThread = new Thread(thread);
    deleterThread.start();
  }
  // this is called before session commit a local tx
  public void finishTx() throws Exception {
    MessageInfo lastMi = null;

    MessageInfo mi = null;
    Iterator<MessageInfo> iter = deliveringRefs.iterator();
    while (iter.hasNext()) {
      mi = iter.next();
      if (mi.isLocalAcked()) {
        iter.remove();
        lastMi = mi;
      }
    }

    if (lastMi != null) {
      session.getCoreSession().acknowledge(nativeId, lastMi.nativeId);
    }
  }
  public void rollbackTx(Set<Long> acked) throws Exception {
    MessageInfo lastMi = null;

    MessageInfo mi = null;
    Iterator<MessageInfo> iter = deliveringRefs.iterator();
    while (iter.hasNext()) {
      mi = iter.next();
      if (mi.isLocalAcked()) {
        acked.add(mi.nativeId);
        lastMi = mi;
      }
    }

    if (lastMi != null) {
      session.getCoreSession().acknowledge(nativeId, lastMi.nativeId);
    }
  }
  public void renderScreen() {
    if (mMovableMaskQueue.size() == 0) {
      if (mMaskType == MOVABLE_MASK) {
        mScreenView.removeAllViews();
      }
      return;
    }

    mScreenView.removeAllViews();
    Iterator<MovableMask> it = mMovableMaskQueue.iterator();
    while (it.hasNext()) {
      MovableMask mask = it.next();
      Rect rect = mask.getRect();
      mScreenView.addView(mask);
      mask.layout(rect.left, rect.top, rect.right, rect.bottom);
    }
  }
Example #28
0
    public void publishMessages() {
      Iterator<String> itr = serializedMessages.iterator();
      while (itr.hasNext()) {
        String message = itr.next();

        for (Session session : sessions) {
          session.push(key, message);
        }

        itr.remove();
      }

      synchronized (this) {
        submittedForPublishing = false;

        if (!serializedMessages.isEmpty()) {
          submitForPublishing();
        }
      }
    }
Example #29
0
  private void tearDown(String reason) {
    List<UncancellableFuture<RpcResult<NetconfMessage>>> futuresToCancel = Lists.newArrayList();
    sessionLock.lock();
    try {
      if (session != null) {
        session = null;

        /*
         * Walk all requests, check if they have been executing
         * or cancelled and remove them from the queue.
         */
        final Iterator<Request> it = requests.iterator();
        while (it.hasNext()) {
          final Request r = it.next();
          if (r.future.isUncancellable()) {
            futuresToCancel.add(r.future);
            it.remove();
          } else if (r.future.isCancelled()) {
            // This just does some house-cleaning
            it.remove();
          }
        }

        remoteDevice.onRemoteSessionDown();
      }
    } finally {
      sessionLock.unlock();
    }

    // Notify pending request futures outside of the sessionLock to avoid unnecessarily
    // blocking the caller.
    for (UncancellableFuture<RpcResult<NetconfMessage>> future : futuresToCancel) {
      if (Strings.isNullOrEmpty(reason)) {
        future.set(createSessionDownRpcResult());
      } else {
        future.set(createErrorRpcResult(RpcError.ErrorType.TRANSPORT, reason));
      }
    }
  }
  protected void replay(long windowId) {
    // This operator can partition itself dynamically. When that happens a file can be re-hashed
    // to a different partition than the previous one. In order to handle this, the partition loads
    // all the recovery data for a window and then processes only those files which would be hashed
    // to it in the current run.
    try {
      Map<Integer, Object> recoveryDataPerOperator = idempotentStorageManager.load(windowId);

      for (Object recovery : recoveryDataPerOperator.values()) {
        @SuppressWarnings("unchecked")
        LinkedList<RecoveryEntry> recoveryData = (LinkedList<RecoveryEntry>) recovery;

        for (RecoveryEntry recoveryEntry : recoveryData) {
          if (scanner.acceptFile(recoveryEntry.file)) {
            // The operator may have continued processing the same file in multiple windows.
            // So the recovery states of subsequent windows will have an entry for that file however
            // the offset changes.
            // In this case we continue reading from previously opened stream.
            if (currentFile == null
                || !(currentFile.equals(recoveryEntry.file)
                    && offset == recoveryEntry.startOffset)) {
              if (inputStream != null) {
                closeFile(inputStream);
              }
              processedFiles.add(recoveryEntry.file);
              // removing the file from failed and unfinished queues and pending set
              Iterator<FailedFile> failedFileIterator = failedFiles.iterator();
              while (failedFileIterator.hasNext()) {
                FailedFile ff = failedFileIterator.next();
                if (ff.path.equals(recoveryEntry.file) && ff.offset == recoveryEntry.startOffset) {
                  failedFileIterator.remove();
                  break;
                }
              }

              Iterator<FailedFile> unfinishedFileIterator = unfinishedFiles.iterator();
              while (unfinishedFileIterator.hasNext()) {
                FailedFile ff = unfinishedFileIterator.next();
                if (ff.path.equals(recoveryEntry.file) && ff.offset == recoveryEntry.startOffset) {
                  unfinishedFileIterator.remove();
                  break;
                }
              }
              if (pendingFiles.contains(recoveryEntry.file)) {
                pendingFiles.remove(recoveryEntry.file);
              }
              inputStream =
                  retryFailedFile(new FailedFile(recoveryEntry.file, recoveryEntry.startOffset));
              while (offset < recoveryEntry.endOffset) {
                T line = readEntity();
                offset++;
                emit(line);
              }
            } else {
              while (offset < recoveryEntry.endOffset) {
                T line = readEntity();
                offset++;
                emit(line);
              }
            }
          }
        }
      }
    } catch (IOException e) {
      throw new RuntimeException("replay", e);
    }
  }