Example usage for java.util LinkedList poll

Introduction

In this page you can find the example usage for java.util LinkedList poll.

Prototype

public E poll() 

Source Link

Document

Retrieves and removes the head (first element) of this list.

Usage

From source file:Main.java

public static void main(String[] args) {

    // create a LinkedList
    LinkedList<String> list = new LinkedList<String>();

    // add some elements
    list.add("Hello");
    list.add("from java2s.com");
    list.add("10");

    // print the list
    System.out.println("LinkedList:" + list);

    // retrieve and remove the head of the list
    System.out.println("Head element of the list:" + list.poll());

    // print the list
    System.out.println("LinkedList:" + list);
}

---

From source file:de.cubeisland.engine.core.util.McUUID.java

private static void getProfiles(List<Profile> profiles, LinkedList<String> players) {
    int amount = players.size();
    CubeEngine.getLog().debug("Query UUID for: " + StringUtils.implode(",", players));
    ArrayNode node = mapper.createArrayNode();
    while (!players.isEmpty()) {
        ObjectNode criteria = mapper.createObjectNode();
        criteria.put("name", players.poll());
        criteria.put("agent", AGENT);
        node.add(criteria);/*from   w  w  w  .j  a  va2 s.  c om*/
    }
    int page = 1;
    try {
        CubeEngine.getLog().info("Query Mojang for {} UUIDs", amount);
        while (amount > 0) {
            int read = readProfilesFromInputStream(postQuery(node, page++).getInputStream(), profiles);
            if (read == 0) {
                CubeEngine.getLog().info("No Answer for {} players", amount);
            } else if (read != amount) {
                amount -= read;
                continue;
            }
            return;
        }
    } catch (IOException e) {
        CubeEngine.getLog().error(e, "Could not retrieve UUID for given names!");
    }
}

---

From source file:org.accelio.jxio.jxioConnection.impl.JxioResourceManager.java

public static MsgPool getMsgPool(int size, int in, int out) {
    MsgPool pool = null;/*from  w  w  w  .  j a v  a  2s.  co  m*/
    String key = getMsgPoolKey(size, in, out);

    synchronized (msgPools) {
        LinkedList<MsgPool> list = msgPools.get(key);

        if (list == null) {
            list = new LinkedList<MsgPool>();
            msgPools.put(key, list);
            pool = new MsgPool(size, in, out);
        } else if (list.isEmpty()) {
            pool = new MsgPool(size, in, out);
        } else {
            pool = list.poll();
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("returning " + pool);
    }
    return pool;
}

---

From source file:org.apache.hadoop.hive.ql.exec.SerializationUtilities.java

/**
 * Clones using the powers of XML. Do not use unless necessary.
 * @param roots The roots.//w  w w.  j  a v a  2  s.c o m
 * @return The clone.
 */
public static List<Operator<?>> cloneOperatorTree(List<Operator<?>> roots) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
    CompilationOpContext ctx = roots.isEmpty() ? null : roots.get(0).getCompilationOpContext();
    serializePlan(roots, baos, true);
    @SuppressWarnings("unchecked")
    List<Operator<?>> result = deserializePlan(new ByteArrayInputStream(baos.toByteArray()), roots.getClass(),
            true);
    // Restore the context.
    LinkedList<Operator<?>> newOps = new LinkedList<>(result);
    while (!newOps.isEmpty()) {
        Operator<?> newOp = newOps.poll();
        newOp.setCompilationOpContext(ctx);
        List<Operator<?>> children = newOp.getChildOperators();
        if (children != null) {
            newOps.addAll(children);
        }
    }
    return result;
}

---

From source file:org.apache.hadoop.hive.ql.exec.SerializationUtilities.java

public static List<Operator<?>> cloneOperatorTree(List<Operator<?>> roots, int indexForTezUnion) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream(4096);
    CompilationOpContext ctx = roots.isEmpty() ? null : roots.get(0).getCompilationOpContext();
    serializePlan(roots, baos, true);//from   w  w w.  ja  v a 2  s  . co  m
    @SuppressWarnings("unchecked")
    List<Operator<?>> result = deserializePlan(new ByteArrayInputStream(baos.toByteArray()), roots.getClass(),
            true);
    // Restore the context.
    LinkedList<Operator<?>> newOps = new LinkedList<>(result);
    while (!newOps.isEmpty()) {
        Operator<?> newOp = newOps.poll();
        newOp.setIndexForTezUnion(indexForTezUnion);
        newOp.setCompilationOpContext(ctx);
        List<Operator<?>> children = newOp.getChildOperators();
        if (children != null) {
            newOps.addAll(children);
        }
    }
    return result;
}

---

From source file:org.deegree.services.wms.controller.WMSController.java

private static void addHeaders(HttpResponseBuffer response, LinkedList<String> headers) {
    while (!headers.isEmpty()) {
        String s = headers.poll();
        response.addHeader("Warning", s);
    }//from   ww  w  . j  a  va2 s.  com
}

---

From source file:com.alibaba.jstorm.ui.utils.UIUtils.java

private static int bfsDepth(List<TreeNode> roots) {
    LinkedList<TreeNode> queue = Lists.newLinkedList();
    for (TreeNode root : roots) {
        root.setLayer(0);//ww  w .  java  2  s  .c  o  m
        queue.push(root);
    }

    int depth = 0;
    while (!queue.isEmpty()) {
        TreeNode cur = queue.poll();
        if (cur.getLayer() > depth) {
            depth = cur.getLayer();
        }
        for (TreeNode n : cur.getChildren()) {

            int newLayer = cur.getLayer() + 1;
            if (!n.isVisited() || n.getLayer() < newLayer) {
                if (!n.inCircle(cur)) {
                    //n and cur is not in loop
                    n.setLayer(newLayer);
                    if (!queue.contains(n)) {
                        queue.push(n);
                    }
                } else if (n.addLoopNode(cur)) {
                    // loop nodes only set layer once.
                    n.setLayer(newLayer);
                }
            }

        }
    }
    return depth;
}

---

From source file:de._13ducks.cor.game.server.movement.SubSectorPathfinder.java

/**
 * Sucht einen Weg auf Freiflchen (FreePolygon) um ein Hindernis herum.
 * Beachtet weitere Hindernisse auf der "Umleitung".
 * Sucht die Route nur bis zum nchsten Ziel.
 * Der Mover darf sich nicht bereits auf einer Umleitung befinden,
 * diese muss ggf vorher gelscht worden sein.
 * @param mover/*from ww w. ja  va 2  s  .co  m*/
 * @param obstacle
 * @return 
 */
static List<SubSectorEdge> searchDiversion(Moveable mover, Moveable obstacle, SimplePosition target) {
    // Vorberprfung: Ist das Ziel berhaupt noch frei?
    List<Moveable> moversAroundTarget = Server.getInnerServer().moveMan.moveMap
            .moversAroundPoint(target.toFPP(), mover.getRadius() + 5);
    moversAroundTarget.remove(mover); // Falls drin
    for (Moveable m : moversAroundTarget) {
        if (m.getPrecisePosition().getDistance(target.toFPP()) < m.getRadius() + mover.getRadius()
                + ServerBehaviourMove.MIN_DISTANCE) {
            System.out.println("No div, target blocked!");
            return null;
        }
    }

    /**
     * Wegsuche in 2 Schritten:
     * 1. Aufbauen eines geeigneten Graphen, der das gesamte Problem enthlt.
     * 2. Suchen einer Route in diesem Graphen mittels A* (A-Star).
     */
    // Aufbauen des Graphen:
    ArrayList<SubSectorObstacle> graph = new ArrayList<SubSectorObstacle>(); // Der Graph selber
    LinkedList<Moveable> openObstacles = new LinkedList<Moveable>(); // Die Liste mit noch zu untersuchenden Knoten
    ArrayList<Moveable> closedObstacles = new ArrayList<Moveable>(); // Bearbeitete Knoten

    openObstacles.add(obstacle); // Startpunkt des Graphen.
    closedObstacles.add(mover); // Wird im Graphen nicht mitbercksichtigt.
    double radius = mover.getRadius() + ServerBehaviourMove.MIN_DISTANCE;

    while (!openObstacles.isEmpty()) {
        // Neues Element aus der Liste holen und als bearbeitet markieren.
        Moveable work = openObstacles.poll();
        closedObstacles.add(work);
        SubSectorObstacle next = new SubSectorObstacle(work.getPrecisePosition().x(),
                work.getPrecisePosition().y(), work.getRadius());
        // Zuerst alle Punkte des Graphen lschen, die jetzt nichtmehr erreichbar sind:
        for (SubSectorObstacle obst : graph) {
            obst.removeNearNodes(next, radius);
        }
        // Mit Graph vernetzen
        for (SubSectorObstacle node : graph) {
            if (node.inColRange(next, radius)) {
                // Schnittpunkte suchen
                SubSectorNode[] intersections = node.calcIntersections(next, radius);
                for (SubSectorNode n2 : intersections) {
                    boolean reachable = true;
                    for (SubSectorObstacle o : graph) {
                        if (o.equals(node)) {
                            continue; // Um den gehts jetzt ja gerade, natrlich liegen wir auf diesem Kreis
                        }
                        if (o.moveCircleContains(n2, radius)) {
                            reachable = false;
                            break;
                        }
                    }
                    if (reachable) {
                        // Schnittpunkt einbauen
                        next.addNode(n2);
                        node.addNode(n2);
                    }
                }
            }
        }
        // Bearbeitetes selbst in Graph einfgen
        graph.add(next);
        // Weitere Hindernisse suchen, die jetzt relevant sind.
        List<Moveable> moversAround = Server.getInnerServer().moveMan.moveMap.moversAround(work,
                (work.getRadius() + radius) * 2);
        for (Moveable pmove : moversAround) {
            if (!closedObstacles.contains(pmove) && !openObstacles.contains(pmove)) {
                openObstacles.add(pmove);
            }
        }
    }

    // Jetzt drber laufen und Graph aufbauen:
    for (SubSectorObstacle obst : graph) {
        // Vorgensweise:
        // In jedem Hinderniss die Linie entlanglaufen und Knoten mit Kanten verbinden.
        // Ein Knoten darf auf einem Kreis immer nur in eine Richtung gehen.
        // (das sollte mithilfe seiner beiden, bekannten hindernisse recht einfach sein)
        // Die Lnge des Kreissegments lsst sich einfach mithilfe des winkels ausrechnen (Math.atan2(y,x)
        // Dann darf der A*. Bzw. Dijkstra, A* ist hier schon fast Overkill.
        // Alle Knoten ihrem Bogenma nach sortieren.
        obst.sortNodes();
        obst.interConnectNodes(radius);
    }

    // Start- und Zielknoten einbauen und mit dem Graph vernetzten.
    SubSectorNode startNode = new SubSectorNode(mover.getPrecisePosition().x(), mover.getPrecisePosition().y());
    SubSectorNode targetNode = new SubSectorNode(target.x(), target.y());
    double min = Double.POSITIVE_INFINITY;
    SubSectorObstacle minObstacle = null;
    for (SubSectorObstacle obst : graph) {
        double newdist = Math.sqrt((obst.getX() - startNode.getX()) * (obst.getX() - startNode.getX())
                + (obst.getY() - startNode.getY()) * (obst.getY() - startNode.getY()));
        newdist -= obst.getRadius() + radius; // Es interessiert uns der nchstmgliche Kreis, nicht das nchste Hinderniss
        if (newdist < min) {
            min = newdist;
            minObstacle = obst;
        }
    }
    // Punkt auf Laufkreis finden
    Vector direct = new Vector(startNode.getX() - minObstacle.getX(), startNode.getY() - minObstacle.getY());
    direct = direct.normalize().multiply(minObstacle.getRadius() + radius);

    SubSectorNode minNode = new SubSectorNode(minObstacle.getX() + direct.getX(),
            minObstacle.getY() + direct.getY(), minObstacle);

    // In das Hinderniss integrieren:
    minObstacle.lateIntegrateNode(minNode);
    SubSectorEdge startEdge = new SubSectorEdge(startNode, minNode, min);

    if (!startNode.equals(minNode)) {

        startNode.addEdge(startEdge);
        minNode.addEdge(startEdge);

    } else {
        // Wir stehen schon auf dem minNode.
        // Die Einsprungkante ist nicht notwendig.
        startNode = minNode;
    }

    double min2 = Double.POSITIVE_INFINITY;
    SubSectorObstacle minObstacle2 = null;
    for (SubSectorObstacle obst : graph) {
        double newdist = Math.sqrt((obst.getX() - targetNode.getX()) * (obst.getX() - targetNode.getX())
                + (obst.getY() - targetNode.getY()) * (obst.getY() - targetNode.getY()));
        newdist -= obst.getRadius() + radius; // Es interessiert uns der nchstmgliche Kreis, nicht das nchste Hinderniss
        if (newdist < min2) {
            min2 = newdist;
            minObstacle2 = obst;
        }
    }
    // Punkt auf Laufkreis finden
    Vector direct2 = new Vector(targetNode.getX() - minObstacle2.getX(),
            targetNode.getY() - minObstacle2.getY());
    direct2 = direct2.normalize().multiply(minObstacle2.getRadius() + radius);

    SubSectorNode minNode2 = new SubSectorNode(minObstacle2.getX() + direct2.getX(),
            minObstacle2.getY() + direct2.getY(), minObstacle2);

    // In das Hinderniss integrieren:
    minObstacle2.lateIntegrateNode(minNode2);
    SubSectorEdge targetEdge = new SubSectorEdge(minNode2, targetNode, min2);

    if (!targetNode.equals(minNode2)) {

        targetNode.addEdge(targetEdge);
        minNode2.addEdge(targetEdge);

    } else {
        // Das Ziel ist schon auf dem Laufkreis.
        // Die Aussprungkante ist nicht ntig.
        targetNode = minNode2;
    }

    /**
     * Hier jetzt einen Weg suchen von startNode nach targetNode.
     * Die Kanten sind in node.myEdges
     * Die Ziele bekommt man mit edge.getOther(startNode)
     * Die Lnge (Wegkosten) stehen in edge.length (vorsicht: double-Wert!)
     */
    PriorityBuffer open = new PriorityBuffer(); // Liste fr entdeckte Knoten
    LinkedHashSet<SubSectorNode> containopen = new LinkedHashSet<SubSectorNode>(); // Auch fr entdeckte Knoten, hiermit kann viel schneller festgestellt werden, ob ein bestimmter Knoten schon enthalten ist.
    LinkedHashSet<SubSectorNode> closed = new LinkedHashSet<SubSectorNode>(); // Liste fr fertig bearbeitete Knoten

    double cost_t = 0; //Movement Kosten (gerade 5, diagonal 7, wird spter festgelegt)

    open.add(startNode);

    while (open.size() > 0) {
        SubSectorNode current = (SubSectorNode) open.remove();
        containopen.remove(current);

        if (current.equals(targetNode)) { //Abbruch, weil Weg von Start nach Ziel gefunden wurde
            //targetNode.setParent(current.getParent());   //"Vorgngerfeld" von Ziel bekannt
            break;
        }

        // Aus der open wurde current bereits gelscht, jetzt in die closed verschieben
        closed.add(current);

        ArrayList<SubSectorEdge> neighbors = current.getMyEdges();

        for (SubSectorEdge edge : neighbors) {

            SubSectorNode node = edge.getOther(current);

            if (closed.contains(node)) {
                continue;
            }

            // Kosten dort hin berechnen
            cost_t = edge.getLength();

            if (containopen.contains(node)) { //Wenn sich der Knoten in der openlist befindet, muss berechnet werden, ob es einen krzeren Weg gibt

                if (current.getCost() + cost_t < node.getCost()) { //krzerer Weg gefunden?

                    node.setCost(current.getCost() + cost_t); //-> Wegkosten neu berechnen
                    //node.setValF(node.cost + node.getHeuristic());  //F-Wert, besteht aus Wegkosten vom Start + Luftlinie zum Ziel
                    node.setParent(current); //aktuelles Feld wird zum Vorgngerfeld
                }
            } else {
                node.setCost(current.getCost() + cost_t);
                //node.setHeuristic(Math.sqrt(Math.pow(Math.abs((targetNode.getX() - node.getX())), 2) + Math.pow(Math.abs((targetNode.getY() - node.getY())), 2)));   // geschtzte Distanz zum Ziel
                //Die Zahl am Ende der Berechnung ist der Aufwand der Wegsuche
                //5 ist schnell, 4 normal, 3 dauert lange

                node.setParent(current); // Parent ist die RogPosition, von dem der aktuelle entdeckt wurde
                //node.setValF(node.cost + node.getHeuristic());  //F-Wert, besteht aus Wegkosten vom Start aus + Luftlinie zum Ziel
                open.add(node); // in openlist hinzufgen
                containopen.add(node);
            }
        }
    }

    if (targetNode.getParent() == null) { //kein Weg gefunden
        return null;
    }

    ArrayList<SubSectorNode> pathrev = new ArrayList<SubSectorNode>(); //Pfad aus parents erstellen, von Ziel nach Start
    while (!targetNode.equals(startNode)) {
        pathrev.add(targetNode);
        targetNode = targetNode.getParent();
    }
    pathrev.add(startNode);

    ArrayList<SubSectorNode> path = new ArrayList<SubSectorNode>(); //Pfad umkehren, sodass er von Start nach Ziel ist
    for (int k = pathrev.size() - 1; k >= 0; k--) {
        path.add(pathrev.get(k));
    }

    // Nachbearbeitung:
    // Wir brauchen eine Kanten-Liste mit arc/direct Informationen

    ArrayList<SubSectorEdge> finalPath = new ArrayList<SubSectorEdge>();
    for (int i = 0; i < path.size() - 1; i++) {
        SubSectorNode from = path.get(i);
        SubSectorNode to = path.get(i + 1);
        SubSectorEdge edge = shortestCommonEdge(from, to);
        if (edge != null) {
            finalPath.add(edge);
        } else {
            throw new RuntimeException("ERROR Cannot find edge from " + from + " to " + to
                    + " but it is part of the calculated path!!!");
        }
    }

    return finalPath; //Pfad zurckgeben
}

---

From source file:org.apache.jackrabbit.oak.console.impl.Console.java

private NodeState browseDown(NodeState father, LinkedList<String> path) {
    String node = path.poll();
    NodeState child = null;//  w  w w  .  j  av a2s.  c  o m

    if (!StringUtils.isEmpty(node)) {
        if (father.hasChildNode(node)) {
            child = father.getChildNode(node);
        } else {
            System.err.println("Wrong path. Node doesn't exists. " + node);
            return null;
        }
    } else {
        child = father;
    }

    if (!path.isEmpty()) {
        child = browseDown(child, path);
    }

    return child;
}

---

From source file:de._13ducks.cor.game.server.movement.SectorPathfinder.java

/**
 * Der Start und Zielknoten sind von weit mehr als nur den Knoten ihres Polygons erreichbar.
 * Dies muss bereits whrend der Basic-Berechnung beachtet werden, das kann die Pfadoptimierung nachtrglich nichtmehr leisten.
 * Also alle Nodes suchen, die ohne Hinderniss direkt erreichbar sind
 * @param from alle vollstndig im Mesh liegenden Kanten von hier zu Nachbarknoten suchen
 * @param basicPolygon Der Polygon, in dem der Node drinliegt.
 * @return alle direkt erreichbaren Knoten (natrlich sind die des basicPolygons auch dabei)
 *///from   www  .j  a va2s  .  c o  m
private static Node[] computeDirectReachable(Node from, FreePolygon basicPolygon) {
    // Das ist eine modifizierte Breitensuche:
    LinkedList<FreePolygon> open = new LinkedList<FreePolygon>(); // Queue fr zu untersuchende Polygone
    LinkedHashSet<FreePolygon> openContains = new LinkedHashSet<FreePolygon>(); // Welche Elemente die open enthlt (schnellerer Test)
    LinkedHashSet<FreePolygon> closed = new LinkedHashSet<FreePolygon>();
    LinkedHashSet<Node> testedNodes = new LinkedHashSet<Node>();
    LinkedList<Node> result = new LinkedList<Node>();
    open.offer(basicPolygon); // Start-Polygon
    openContains.add(basicPolygon);

    while (!open.isEmpty()) {
        // Diesen hier bearbeiten wir jetzt
        FreePolygon poly = open.poll();
        openContains.remove(poly);
        closed.add(poly);

        boolean containsreachableNodes = false;
        // Alle Nodes dieses Knotens untersuchen
        for (Node node : poly.getNodes()) {
            // Schon bekannt?
            if (result.contains(node)) {
                // Bekannt und ok
                containsreachableNodes = true;
            } else {
                if (testedNodes.contains(node)) {
                    // Der geht nicht
                } else {
                    // Testen!
                    FreePolygon currentPoly = basicPolygon;
                    // Testweise Kante zwischen from und node erstellen
                    Edge edge = new Edge(from, node);
                    // Im Folgenden wird untersucht, ob der neue Weg "edge" passierbar ist.
                    // Damit wir beim Dreieckwechsel nicht wieder zurck gehen:
                    Node lastNode = null;

                    boolean routeAllowed = true;

                    // Jetzt so lange weiter laufen, bis wir im Ziel-Polygon sind
                    while (!node.getPolygons().contains(currentPoly)) {
                        // Untersuchen, ob es eine Seite des currentPolygons gibt, die sich mit der alternativRoute schneidet
                        List<Edge> edges = currentPoly.calcEdges();
                        Edge intersecting = null;
                        SimplePosition intersection = null;
                        for (Edge testedge : edges) {
                            // Gibts da einen Schnitt?
                            intersection = edge.intersectionWithEndsNotAllowed(testedge);
                            if (intersection != null && !intersection.equals(lastNode)) {
                                intersecting = testedge;
                                break;
                            }
                        }
                        // Kandidat fr den nchsten Polygon
                        FreePolygon nextPoly = null;
                        // Kante gefunden
                        if (intersecting != null) {
                            // Von dieser Kante die Enden suchen
                            nextPoly = getOtherPoly(intersecting.getStart(), intersecting.getEnd(),
                                    currentPoly);
                        }
                        if (intersecting != null && nextPoly != null) {
                            // Wir haben einen Schnittpunkt und eine Kante gefunden, sind jetzt also in einem neuen Polygon
                            // Extra Node bentigt
                            Node extraNode = intersection.toNode();

                            extraNode.addPolygon(nextPoly);
                            extraNode.addPolygon(currentPoly);
                            lastNode = extraNode;
                            currentPoly = nextPoly;
                            // Der nchste Schleifendurchlauf wird den nchsten Polygon untersuchen
                        } else {
                            // Es gab leider keinen betretbaren Polygon hier.
                            // Das bedeutet, dass wir die Suche abbrechen knnen, es gibt hier keinen direkten Weg
                            routeAllowed = false;
                            break;
                        }

                    }

                    // Wenn der neue Weg gltig war, einbauen. Sonst weiter mit dem nchsten Knoten
                    if (routeAllowed) {
                        // In die erlaubt-Liste:
                        result.add(node);
                        testedNodes.add(node);
                        containsreachableNodes = true;
                    } else {
                        testedNodes.add(node);
                    }
                }
            }
        }

        // Nur weiter in die Tiefe gehen, wenn mindestens einer erreichbar war
        if (containsreachableNodes) {
            // Alle Nachbarn untersuchen:
            for (FreePolygon n : poly.getNeighbors()) {
                // Schon bekannt/bearbeitet?
                if (!openContains.contains(n) && !closed.contains(n)) {
                    // Nein, also auch zur Bearbeitung vorsehen
                    open.add(n);
                    openContains.add(n);
                }
            }
        }
    }
    return result.toArray(new Node[0]);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »