Exemple #1
0
  // 私有函数,广度优先遍历
  private void broadFirstSearch(boolean[] isVisited, int i) {
    int u, w;
    LinkedList queue = new LinkedList();

    // 访问结点i
    System.out.print(getValueByIndex(i) + "  ");
    isVisited[i] = true;
    // 结点入队列
    queue.addLast(i);
    while (!queue.isEmpty()) {
      u = ((Integer) queue.removeFirst()).intValue();
      w = getFirstNeighbor(u);
      while (w != -1) {
        if (!isVisited[w]) {
          // 访问该结点
          System.out.print(getValueByIndex(w) + "  ");
          // 标记已被访问
          isVisited[w] = true;
          // 入队列
          queue.addLast(w);
        }
        // 寻找下一个邻接结点
        w = getNextNeighbor(u, w);
      }
    }
  }
  private boolean addItem(LinkedList<ItemInfo> items, ItemInfo itemInfo) {
    boolean added = false;

    int idx = items.indexOf(itemInfo);
    if (idx != -1) {
      // HACK: Always swap existing ItemInfos with our new one, since it will
      // more up-to-date information
      ItemInfo existing = items.set(idx, itemInfo);
      assert (existing != null);
      return (true);
    }
    if (itemInfo.hasCurrentPrice())
      assert (itemInfo.getCurrentPrice() > 0) : "Negative current price for " + itemInfo;

    // If we have room, shove it right in
    // We'll throw it in the back because we know it hasn't been used yet
    if (items.size() < AuctionMarkConstants.ITEM_ID_CACHE_SIZE) {
      items.addLast(itemInfo);
      added = true;

      // Otherwise, we can will randomly decide whether to pop one out
    } else if (this.rng.nextBoolean()) {
      items.pop();
      items.addLast(itemInfo);
      added = true;
    }
    return (added);
  }
  void mixLists(
      LinkedList<Integer> left,
      LinkedList<Integer> right,
      ArrayList<LinkedList<Integer>> mix,
      LinkedList<Integer> before) {
    if (before.isEmpty() || right.isEmpty()) {
      LinkedList<Integer> l = new LinkedList<>();
      l = (LinkedList<Integer>) before.clone();
      l.addAll(left);
      l.addAll(right);
      mix.add(l);
      return;
    }
    int hl = left.removeFirst();
    before.addLast(hl);
    mixLists(left, right, mix, before);
    before.removeLast();
    left.addFirst(hl);

    int hr = right.removeFirst();
    before.addLast(hr);
    mixLists(left, right, mix, before);
    before.removeLast();
    right.addFirst(hr);
  }
Exemple #4
0
  public synchronized HandleStatus handle(final MessageReference reference) {
    if (statusToReturn == HandleStatus.BUSY) {
      return HandleStatus.BUSY;
    }

    if (filter != null) {
      if (filter.match(reference.getMessage())) {
        references.addLast(reference);
        reference.getQueue().referenceHandled();
        notify();

        return HandleStatus.HANDLED;
      } else {
        return HandleStatus.NO_MATCH;
      }
    }

    if (newStatus != null) {
      if (delayCountdown == 0) {
        statusToReturn = newStatus;

        newStatus = null;
      } else {
        delayCountdown--;
      }
    }

    if (statusToReturn == HandleStatus.HANDLED) {
      reference.getQueue().referenceHandled();
      references.addLast(reference);
      notify();
    }

    return statusToReturn;
  }
  /**
   * process a task multi threaded synchronized by the internal task queue. The task will be
   * processed by a dedicated thread. The given worker pool <i>can</i> be used to perform this tasks
   * (as well as other task of the queue).
   *
   * @param task the task to process
   * @param workerpool the workerpool
   */
  public void performMultiThreaded(Runnable task, Executor workerpool) {

    // add task to queue
    synchronized (multithreadedTaskQueue) {

      // (Multithreaded) worker is not running
      if (multithreadedTaskQueue.isEmpty()) {
        multithreadedTaskQueue.addLast(task);

        try {
          workerpool.execute(multithreadedTaskProcessor);
        } catch (RejectedExecutionException ree) {
          if (LOG.isLoggable(Level.FINE)) {
            LOG.fine(
                "task has been rejected by worker pool "
                    + workerpool
                    + " (worker pool cosed?) performing task by starting a new thread");
          }
          Thread t = new Thread(multithreadedTaskProcessor, "SerializedTaskQueueFallbackThread");
          t.setDaemon(true);
          t.start();
        }

      } else {
        multithreadedTaskQueue.addLast(task);
      }
    }
  }
 /*
  *(non-Javadoc)
  * @see android.widget.AdapterView#setSelection(int)
  */
 @Override
 public void setSelection(int position) {
   mNextScreen = INVALID_SCREEN;
   mScroller.forceFinished(true);
   if (mAdapter != null) {
     position = Math.max(position, 0);
     position = Math.min(position, mAdapter.getCount() - 1);
     recycleViews();
     View currentView = makeAndAddView(position, true);
     mLoadedViews.addLast(currentView);
     for (int offset = 1; mBufferedItemCount - offset >= 0; offset++) {
       int leftIndex = position - offset;
       int rightIndex = position + offset;
       if (leftIndex >= 0) {
         mLoadedViews.addFirst(makeAndAddView(leftIndex, false));
       }
       if (rightIndex < mAdapter.getCount()) {
         mLoadedViews.addLast(makeAndAddView(rightIndex, true));
       }
     }
     mCurrentBufferIndex = mLoadedViews.indexOf(currentView);
     mCurrentAdapterIndex = position;
     requestLayout();
     setVisibleView(mCurrentBufferIndex, false);
     if (viewSwitchListener != null) {
       viewSwitchListener.onSwitched(currentView, mCurrentAdapterIndex);
     }
   }
 }
 protected void add(
     boolean list,
     boolean warning,
     int type,
     String text,
     BaseNode b,
     BranchNode ba,
     BranchNode bb) {
   ConflictEntry ce = new ConflictEntry();
   ce.text = text;
   ce.type = type;
   ce.b = b;
   // let b1=left and b2=right
   if (ba == null) {
     ba = bb;
     bb = null;
   }
   if (ba != null && ba.isLeftTree()) {
     ce.b1 = ba;
     ce.b2 = bb;
   } else {
     ce.b1 = bb;
     ce.b2 = ba;
   }
   if (list) {
     ce.mergePath = pt.getPathString();
   } else ce.mergePath = pt.getFullPathString();
   if (warning) warnings.addLast(ce);
   else conflicts.addLast(ce);
 }
Exemple #8
0
  public static void postOrderNoIn(TreeNode root) {

    if (root == null) return;
    LinkedList<TreeNode> stack = new LinkedList<>();
    LinkedList<Boolean> flag = new LinkedList<>();

    boolean curFlag;
    while (!stack.isEmpty() || root != null) {
      while (root != null) {
        stack.addLast(root);
        flag.addLast(true);
        root = root.left;
      }
      root = stack.getLast();
      curFlag = flag.getLast();
      flag.removeLast();
      if (curFlag) { //
        flag.addLast(false);
        root = root.right;
      } else {
        stack.removeLast();
        System.out.print(root.val + " ");
        root = null; // 第一次的时候缺少这一句,陷入死循环。
      }
    }
  }
Exemple #9
0
  public void weavelists(
      LinkedList<Integer> first,
      LinkedList<Integer> second,
      ArrayList<LinkedList<Integer>> results,
      LinkedList<Integer> prefix) {
    if (first.size() == 0 || second.size() == 0) {
      LinkedList<Integer> result = (LinkedList<Integer>) prefix.clone();
      result.addAll(first);
      result.addAll(second);
      results.add(result);
      return;
    }

    int headFirst = first.removeFirst();
    prefix.addLast(headFirst);
    weavelists(first, second, results, prefix);
    prefix.removeLast();
    first.addFirst(headFirst);

    int secondHead = second.removeFirst();
    prefix.addLast(secondHead);
    weavelists(first, second, results, prefix);
    prefix.removeLast();
    second.addFirst(secondHead);
  }
 /**
  * Constructs a path to a given node, for a given set of predecessors. The result is a list of
  * alternating Node/Relationship.
  *
  * @param node The start node
  * @param predecessors The predecessors set
  * @param includeNode Boolean which determines if the start node should be included in the paths
  * @param backwards Boolean, if true the order of the nodes in the paths will be reversed
  * @return A path as a list of alternating Node/Relationship.
  */
 public static List<PropertyContainer> constructSinglePathToNode(
     Node node,
     Map<Node, List<Relationship>> predecessors,
     boolean includeNode,
     boolean backwards) {
   LinkedList<PropertyContainer> path = new LinkedList<PropertyContainer>();
   if (includeNode) {
     if (backwards) {
       path.addLast(node);
     } else {
       path.addFirst(node);
     }
   }
   Node currentNode = node;
   List<Relationship> currentPreds = predecessors.get(currentNode);
   // Traverse predecessors until we have added a node without predecessors
   while (currentPreds != null && currentPreds.size() != 0) {
     // Get next node
     Relationship currentRelationship = currentPreds.get(0);
     currentNode = currentRelationship.getOtherNode(currentNode);
     // Add current
     if (backwards) {
       path.addLast(currentRelationship);
       path.addLast(currentNode);
     } else {
       path.addFirst(currentRelationship);
       path.addFirst(currentNode);
     }
     // Continue with the next node
     currentPreds = predecessors.get(currentNode);
   }
   return path;
 }
  public static void main(String[] args) throws Exception {
    // explicit configuration
    for (int i = 0; i < PDGs.pdgs.length; i++) {
      String file = PDGs.pdgs[i];
      /* 1 */
      g = SDG.readFrom(file);
      ThreadInstance ti = g.getThreadsInfo().iterator().next();
      LinkedList<ThreadInstance> l = new LinkedList<ThreadInstance>();
      l.add(ti);
      ThreadsInformation info = new ThreadsInformation(l);
      g.setThreadsInfo(info);
      int[] threads = new int[] {0};
      for (SDGNode n : g.vertexSet()) {
        n.setThreadNumbers(threads);
      }

      System.out.println("initializing the slicers");
      LinkedList<Slicer> array = new LinkedList<Slicer>();

      array.addLast(new SummarySlicerBackward(g));
      array.addLast(new Phase1SlicerBackward(g));

      System.out.println(file);
      System.out.println("criteria: " + g.vertexSet().size());

      String str = compare(array, g.vertexSet());

      System.out.println(str);
    }
  }
Exemple #12
0
  @Override
  protected void processDelivery(Delivery delivery) {
    final MessageDelivery md = (MessageDelivery) delivery.getContext();
    if (delivery.remotelySettled()) {
      if (delivery.getTag().length > 0) {
        checkinTag(delivery.getTag());
      }

      final DeliveryState state = delivery.getRemoteState();
      if (state == null || state instanceof Accepted) {
        if (!delivery.remotelySettled()) {
          delivery.disposition(new Accepted());
        }
      } else if (state instanceof Rejected) {
        // re-deliver /w incremented delivery counter.
        md.delivery = null;
        md.incrementDeliveryCount();
        outbound.addLast(md);
      } else if (state instanceof Released) {
        // re-deliver && don't increment the counter.
        md.delivery = null;
        outbound.addLast(md);
      } else if (state instanceof Modified) {
        Modified modified = (Modified) state;
        if (modified.getDeliveryFailed()) {
          // increment delivery counter..
          md.incrementDeliveryCount();
        }
      }
      delivery.settle();
    }
    md.fireWatches();
  }
  protected void setUp() throws Exception {
    carreras = new LinkedList<Carrera>();
    for (int j = 0; j < CANTIDAD_CARRERAS; j++) {
      Carrera carrera = new Carrera(new ReglamentoValeTodo());
      for (int i = 0; i < CANTIDAD_PARTICIPANTES; i++) {

        Participante participante = new Participante(new Caballo(), new Jockey(), carrera);
        carrera.addParticipante(participante);
      }
      carreras.add(carrera);
    }

    LinkedList<Participante> participantesApostados = new LinkedList<Participante>();
    participantesApostados.addLast(carreras.get(0).getParticipantes().get(0));
    participantesApostados.addLast(carreras.get(1).getParticipantes().get(0));
    participantesApostados.addLast(carreras.get(2).getParticipantes().get(0));
    participantesApostados.addLast(carreras.get(3).getParticipantes().get(0));

    apuesta1 =
        ApuestaFactory.getInstance()
            .crear(ApuestaCuaterna.class, participantesApostados, MONTO_APUESTA);

    participantesApostados = new LinkedList<Participante>();
    participantesApostados.addLast(carreras.get(0).getParticipantes().get(0));
    participantesApostados.addLast(carreras.get(1).getParticipantes().get(2));
    participantesApostados.addLast(carreras.get(2).getParticipantes().get(0));
    participantesApostados.addLast(carreras.get(3).getParticipantes().get(1));
    apuesta2 =
        ApuestaFactory.getInstance()
            .crear(ApuestaCuaterna.class, participantesApostados, MONTO_APUESTA);
  }
  public static String obfuscate(String email) {
    LinkedList<String> emailList = new LinkedList<>();

    // Attack the dots
    String[] chunks = email.split(Pattern.quote("."));
    String[] atChunks = null;
    int dotCounter = chunks.length - 1;

    for (int i = 0; i < chunks.length; i++) {
      emailList.addLast(chunks[i]);
      if (dotCounter != 0) {
        emailList.addLast("[.]");
        dotCounter--;
      }
    }
    // Attack the @
    for (int j = 0; j < emailList.size(); j++) {
      if (emailList.get(j).contains("@")) {
        atChunks = emailList.get(j).split(Pattern.quote("@"));
        emailList.remove(j);
        emailList.add(j, atChunks[0]);
        emailList.add(j + 1, "[at]");
        emailList.add(j + 2, atChunks[1]);
      }
    }

    System.out.println(toString(emailList));
    return toString(emailList);
  }
  private void buildValuePermutation() {

    for (int i = 0; i < inputValues.size(); i++) {
      LinkedList<String> lst2 = new LinkedList<String>(inputValues);
      lst2.remove(i);

      for (int j = 0; j < lst2.size(); j++) {
        LinkedList<String> lst3 = new LinkedList<String>(lst2);
        lst3.remove(j);

        for (int k = 0; k < lst3.size(); k++) {
          LinkedList<String> lst4 = new LinkedList<String>(lst3);
          lst4.remove(k);

          for (int l = 0; l < lst4.size(); l++) {
            LinkedList<String> rslt = new LinkedList<String>();
            rslt.addLast(inputValues.get(i));
            rslt.addLast(lst2.get(j));
            rslt.addLast(lst3.get(k));
            rslt.addLast(lst4.get(l));
            permutations.add(rslt);
          }
        }
      }
    }
  }
Exemple #16
0
 public void print() {
   int height = height();
   //			System.out.println("height of tree: "+height);
   //			System.out.println();
   if (height == 0) return;
   int distance = 2;
   int offset = distance * height;
   LinkedList<Node> nodeList = new LinkedList<Node>();
   nodeList.addLast(root);
   int hIdx = 0;
   while (!nodeList.isEmpty()) {
     int size = nodeList.size();
     int innerOffset = offset;
     for (Node node : nodeList) {
       System.out.printf("%" + innerOffset + "s", node.data);
       innerOffset += distance * hIdx;
     }
     System.out.println();
     hIdx++;
     offset = offset - distance;
     for (int i = 0; i < size; i++) {
       Node node = nodeList.poll();
       if (node.left != null) nodeList.addLast(node.left);
       if (node.right != null) nodeList.addLast(node.right);
     }
   }
 }
Exemple #17
0
  /**
   * Return a list of source ports connected to this port on the same layer that can send data to
   * this port. This includes output ports that are connected on the outside to this port, and input
   * ports that are connected on the inside to this port.
   *
   * @param input TypedIOPort
   * @return A list of IOPort objects.
   */
  private LinkedList _shallowSourcePortList(TypedIOPort input) {
    try {
      _workspace.getReadAccess();

      Actor container = (Actor) input.getContainer();
      Director excDirector = ((Actor) container).getExecutiveDirector();
      int depthOfContainer = ((NamedObj) container).depthInHierarchy();
      LinkedList result = new LinkedList();
      Iterator ports = input.connectedPortList().iterator();

      while (ports.hasNext()) {
        IOPort port = (IOPort) ports.next();
        int depth = port.depthInHierarchy();

        if (port.isInput() && (depth <= depthOfContainer)) {
          result.addLast(port);
        } else if (port.isOutput() && (depth == (depthOfContainer + 1))) {
          result.addLast(port);
        }
      }

      return result;
    } finally {
      _workspace.doneReading();
    }
  }
  public static boolean isBinaryTreeBST(BinaryTreeNode<Integer> tree) {
    LinkedList<QueueEntry> BFSQueue = new LinkedList<>();
    BFSQueue.addLast(new QueueEntry(tree, Integer.MIN_VALUE, Integer.MAX_VALUE));

    while (!BFSQueue.isEmpty()) {
      if (BFSQueue.getFirst().treeNode != null) {
        if (BFSQueue.getFirst().treeNode.getData() < BFSQueue.getFirst().lowerBound
            || BFSQueue.getFirst().treeNode.getData() > BFSQueue.getFirst().upperBound) {
          return false;
        }

        BFSQueue.addLast(
            new QueueEntry(
                BFSQueue.getFirst().treeNode.getLeft(),
                BFSQueue.getFirst().lowerBound,
                BFSQueue.getFirst().treeNode.getData()));
        BFSQueue.addLast(
            new QueueEntry(
                BFSQueue.getFirst().treeNode.getRight(),
                BFSQueue.getFirst().treeNode.getData(),
                BFSQueue.getFirst().upperBound));
      }
      BFSQueue.removeFirst();
    }
    return true;
  }
Exemple #19
0
 private void openExpression(QueryTranslatorImpl q, String lcToken) {
   nots.addLast(Boolean.FALSE);
   booleanTests.addLast(Boolean.FALSE);
   joins.addLast(new StringBuilder());
   if (!"(".equals(lcToken)) {
     appendToken(q, "(");
   }
 }
Exemple #20
0
 public void enqueue(Animal a) {
   a.setOrder(order);
   order++;
   if (a instanceof Dog) {
     dogs.addLast((Dog) a);
   } else if (a instanceof Cat) {
     cats.addLast((Cat) a);
   }
 }
Exemple #21
0
  /*
    case_label =
    {constant} case minus? integer_constant |
    {default}  default;
  */
  public void outAConstantCaseLabel(AConstantCaseLabel node) {
    String s = (String) mProductions.removeLast();
    int sign = 1;
    if (node.getMinus() != null) sign = -1;

    if (s.endsWith("L")) {
      mProductions.addLast(LongConstant.v(sign * Long.parseLong(s.substring(0, s.length() - 1))));
    } else mProductions.addLast(IntConstant.v(sign * Integer.parseInt(s)));
  }
 private void select() {
   out();
   indent++;
   newline();
   parenCounts.addLast(new Integer(parensSinceSelect));
   afterByOrFromOrSelects.addLast(new Boolean(afterByOrSetOrFromOrSelect));
   parensSinceSelect = 0;
   afterByOrSetOrFromOrSelect = true;
 }
 @SuppressWarnings({"UnnecessaryBoxing"})
 private void select() {
   out();
   indent++;
   newline();
   parenCounts.addLast(Integer.valueOf(parensSinceSelect));
   afterByOrFromOrSelects.addLast(Boolean.valueOf(afterByOrSetOrFromOrSelect));
   parensSinceSelect = 0;
   afterByOrSetOrFromOrSelect = true;
 }
Exemple #24
0
 public void addRule(String key, Rule rule) {
   if (hasRules(key)) {
     LinkedList ruleGroup = (LinkedList) rules.get(key);
     ruleGroup.addLast(rule);
   } else {
     LinkedList ruleGroup = new LinkedList();
     ruleGroup.addLast(rule);
     rules.put(key, ruleGroup);
   }
 }
Exemple #25
0
  private Orderable parseMove(ParseContext pc, OrderPrefix op, final String[] tokens)
      throws OrderException {
    /*

    	3-StP: Army St Petersburg -> Moscow.  (*bounce*)

    	1-Smy: Army Constantinople -> Aegean Sea -> Greece.


    	keep parsing Locations until END or a -> is reached.
    	so we keep looking for a -> until no more are found.

    	if we have more than one, we'll add them to a list
    	and then add that to the order Move order.
    */

    LinkedList pathList = new LinkedList();
    int idx = op.tokenIndex;
    int movTokIdx = findNextMoveToken(idx, tokens);

    while (movTokIdx != -1) {
      Location loc = parseLocation(pc, idx, movTokIdx, tokens);
      pathList.addLast(loc.getProvince());

      idx = movTokIdx + 1;
      movTokIdx = findNextMoveToken(idx, tokens);
    }

    // add last location
    final Location loc = parseLocation(pc, idx, tokens.length, tokens);
    pathList.addLast(loc.getProvince());

    // create Move order
    if (pathList.size() == 1) {
      if (pc.isRetreatPhase()) {
        return pc.orderFactory.createRetreat(op.power, op.location, op.unit, loc);
      } else {
        return pc.orderFactory.createMove(op.power, op.location, op.unit, loc);
      }
    } else if (pathList.size() > 1) {
      if (pc.isRetreatPhase()) {
        throw new OrderException("Convoyed Retreat orders are not allowed. Order: " + pc.orderText);
      }

      // add source location at beginning of move list
      pathList.addFirst(op.location.getProvince());

      final Province[] route = (Province[]) pathList.toArray(new Province[pathList.size()]);

      return pc.orderFactory.createMove(op.power, op.location, op.unit, loc, route);
    } else {
      // this probably will not occur....
      throw new OrderException("Invalid movement path in Move order: " + pc.orderText);
    }
  } // parseMove()
 public String getLevelTraversal(EvaluationNode rootEvalNode, String correctTraversal) {
   LinkedList<EvaluationNode> nodeList = new LinkedList<EvaluationNode>();
   String solution = "";
   EvaluationNode currentNode = rootEvalNode;
   nodeList.addLast(currentNode);
   while (nodeList.size() != 0) { // solution.length()<correctTraversal.length()
     if (nodeList.size() != 0) {
       currentNode = nodeList.removeFirst();
       solution += currentNode.node.getValue() + " ";
       if (currentNode != null) {
         if (currentNode.left != null) {
           nodeList.addLast(convertNodeToEvalNode(treeNodes, currentNode.left));
         }
         if (currentNode.right != null) {
           nodeList.addLast(convertNodeToEvalNode(treeNodes, currentNode.right));
         }
       }
     } else {
       solution += ".";
     }
   }
   if (solution.contains(".")) {
     errorMessage =
         "FeedBack: Your heap is incomplete, make sure that all valid "
             + "nodes are connected with edges.";
   } else if (!solution.equals(correctTraversal)) {
     String[] splitCorrect = correctTraversal.split(" ");
     String[] splitSolution = solution.split(" ");
     String correct = "";
     boolean done = false;
     for (int i = 0; i < splitSolution.length; i++) {
       if (done == false) {
         if (splitCorrect[i] == splitSolution[i]) {
           correct += splitSolution[i] + " ";
         } else done = true;
       }
     }
     errorMessage =
         "Feedback: Incorrect MinHeap. The level traversal of your"
             + " MinHeap is correct through the segment: "
             + correct.trim()
             + " but the next visited node is incorrect.";
     if (splitSolution.length > splitCorrect.length) { // Make sure there are not to many nodes
       errorMessage =
           "Feedback: Incorrect MinHeap. Make sure you removed all of"
               + " the edges connected to the node specified to be removed.";
     }
     if (splitSolution[0] != splitCorrect[0]) { // Check to see if root is correct
       errorMessage =
           "Feedback: Incorrect Root Node. Remember, in a MinHeap the lowest"
               + " valued node should always be the root.";
     }
   }
   return solution.trim();
 }
  /**
   * 使用拓扑排序解决
   *
   * @param numCourses
   * @param prerequisites
   * @return
   */
  public boolean canFinish2(int numCourses, int[][] prerequisites) {

    if (prerequisites == null || prerequisites.length < 2) return true;

    Map<Integer, ArrayList<Integer>> graph = new HashMap<>();
    int edgeLen = prerequisites.length;
    if (prerequisites[0].length != 2) return false;

    // 满足下面条件肯定有回路
    if (edgeLen > (numCourses - 1) * numCourses / 2) return false;
    int[] degrees = new int[numCourses];
    int a, b;
    ArrayList<Integer> list;
    for (int i = 0; i < edgeLen; i++) {
      a = prerequisites[i][0];
      b = prerequisites[i][1];
      degrees[b]++; // 认为没有重复的边
      if (graph.containsKey(a)) {
        list = graph.get(a);
      } else {
        list = new ArrayList<Integer>();
      }
      list.add(b);
      graph.put(a, list);
    }

    int countZero = 0;
    LinkedList<Integer> zerosDegree = new LinkedList<>();
    for (int i = 0; i < numCourses; i++) {
      if (degrees[i] == 0) {
        zerosDegree.addLast(i);
        countZero++;
      }
    }
    if (zerosDegree.isEmpty()) return false;
    List<Integer> lst;
    while (!zerosDegree.isEmpty()) {
      int top = zerosDegree.getFirst();
      zerosDegree.removeFirst();
      lst = graph.get(top);
      if (lst != null) {
        for (int a1 : lst) {
          degrees[a1]--;
          if (degrees[a1] == 0) {
            zerosDegree.addLast(a1);
            countZero++;
          }
        }
      }
    }
    if (countZero == numCourses) return true;
    return false;
  }
Exemple #28
0
  public void outAIntegerConstant(AIntegerConstant node) {
    String s = (String) mProductions.removeLast();

    StringBuffer buf = new StringBuffer();
    if (node.getMinus() != null) buf.append('-');
    buf.append(s);

    s = buf.toString();
    if (s.endsWith("L")) {
      mProductions.addLast(LongConstant.v(Long.parseLong(s.substring(0, s.length() - 1))));
    } else mProductions.addLast(IntConstant.v(Integer.parseInt(s)));
  }
Exemple #29
0
 /**
  * Execute and addThread with the given priority
  *
  * @param r
  * @param priority
  */
 public void execute(Runnable r, Integer priority) {
   synchronized (mutex) {
     if (HIGH.equals(priority)) {
       highQueue.addLast(r);
     } else if (SINGLE.equals(priority)) {
       singleQueue.addLast(r);
     } else {
       lowQueue.addLast(r);
     }
     mutex.notifyAll();
   }
 }
  /** Enqueues the Runnable object, and executes it on a processor thread. */
  public void dispatch(Runnable runner, boolean isLIFO) {
    isLIFO = false;
    synchronized (queue) {
      if (threadCount < maxThreadCount) {
        if (isLIFO) {
          queue.addFirst(runner);
        } else {
          queue.addLast(runner);
        }

        Thread processor =
            new Thread(this + " Processor") {

              public void run() {
                processEvents();
              }
            };
        threadCount++;

        // The processor thread must not be a daemon,
        // or else the Java VM might stop before
        // all runnables have been processed.
        try {
          processor.setDaemon(false);
        } catch (SecurityException e) {
          e.printStackTrace();
        }
        try {
          processor.setPriority(priority);
        } catch (SecurityException e) {
          e.printStackTrace();
        }

        processor.start();
        return;

      } else if (blockingPolicy == ENQUEUE_WHEN_BLOCKED) {
        if (isLIFO) {
          queue.addFirst(runner);
        } else {
          queue.addLast(runner);
        }

        return;
      }
    }

    // implicit: if (threadCount >= maxThreadCount && blockingPolicy == RUN_WHEN_BLOCKED)
    runner.run();
  }