Examples with Stack java.util.Stack used on opensource projects

Example 21 with Stack

use of java.util.Stack in project BluePower by Qmunity.

the class TubeLogic method clearNodeCaches.

public void clearNodeCaches() {
    List<PneumaticTube> clearedTubes = new ArrayList<PneumaticTube>();
    Stack<PneumaticTube> todoTubes = new Stack<PneumaticTube>();
    clearNodeCache();
    boolean firstRun = true;
    todoTubes.push(tube);
    while (!todoTubes.isEmpty()) {
        PneumaticTube tube = todoTubes.pop();
        if (tube.getParent() != null && tube.getWorld() != null) {
            for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS) {
                PneumaticTube neighbor = tube.getPartCache(d);
                if (neighbor != null) {
                    if (!clearedTubes.contains(neighbor)) {
                        neighbor.getLogic().clearNodeCache();
                        clearedTubes.add(neighbor);
                        if (firstRun || !neighbor.isCrossOver)
                            todoTubes.push(neighbor);
                    }
                }
            }
        }
        firstRun = false;
    }
}

Example 22 with Stack

use of java.util.Stack in project ElasticDownload by Tibolte.

the class VectorDrawable method inflateInternal.

private void inflateInternal(Resources res, XmlPullParser parser, AttributeSet attrs, Theme theme) throws XmlPullParserException, IOException {
    final VectorDrawableState state = mVectorState;
    final VPathRenderer pathRenderer = state.mVPathRenderer;
    boolean noPathTag = true;
    // Use a stack to help to build the group tree.
    // The top of the stack is always the current group.
    final Stack<VGroup> groupStack = new Stack<VGroup>();
    groupStack.push(pathRenderer.mRootGroup);
    int eventType = parser.getEventType();
    while (eventType != XmlPullParser.END_DOCUMENT) {
        if (eventType == XmlPullParser.START_TAG) {
            final String tagName = parser.getName();
            final VGroup currentGroup = groupStack.peek();
            if (SHAPE_PATH.equals(tagName)) {
                final VFullPath path = new VFullPath();
                path.inflate(res, attrs, theme);
                currentGroup.mChildren.add(path);
                if (path.getPathName() != null) {
                    pathRenderer.mVGTargetsMap.put(path.getPathName(), path);
                }
                noPathTag = false;
                state.mChangingConfigurations |= path.mChangingConfigurations;
            } else if (SHAPE_CLIP_PATH.equals(tagName)) {
                final VClipPath path = new VClipPath();
                path.inflate(res, attrs, theme);
                currentGroup.mChildren.add(path);
                if (path.getPathName() != null) {
                    pathRenderer.mVGTargetsMap.put(path.getPathName(), path);
                }
                state.mChangingConfigurations |= path.mChangingConfigurations;
            } else if (SHAPE_GROUP.equals(tagName)) {
                VGroup newChildGroup = new VGroup();
                newChildGroup.inflate(res, attrs, theme);
                currentGroup.mChildren.add(newChildGroup);
                groupStack.push(newChildGroup);
                if (newChildGroup.getGroupName() != null) {
                    pathRenderer.mVGTargetsMap.put(newChildGroup.getGroupName(), newChildGroup);
                }
                state.mChangingConfigurations |= newChildGroup.mChangingConfigurations;
            }
        } else if (eventType == XmlPullParser.END_TAG) {
            final String tagName = parser.getName();
            if (SHAPE_GROUP.equals(tagName)) {
                groupStack.pop();
            }
        }
        eventType = parser.next();
    }
    // Print the tree out for debug.
    if (DBG_VECTOR_DRAWABLE) {
        printGroupTree(pathRenderer.mRootGroup, 0);
    }
    if (noPathTag) {
        final StringBuffer tag = new StringBuffer();
        if (tag.length() > 0) {
            tag.append(" or ");
        }
        tag.append(SHAPE_PATH);
        throw new XmlPullParserException("no " + tag + " defined");
    }
}

Example 23 with Stack

use of java.util.Stack in project Fairphone by Kwamecorp.

the class CellLayout method findNearestArea.

/**
     * Find a vacant area that will fit the given bounds nearest the requested
     * cell location. Uses Euclidean distance to score multiple vacant areas.
     *
     * @param pixelX The X location at which you want to search for a vacant area.
     * @param pixelY The Y location at which you want to search for a vacant area.
     * @param minSpanX The minimum horizontal span required
     * @param minSpanY The minimum vertical span required
     * @param spanX Horizontal span of the object.
     * @param spanY Vertical span of the object.
     * @param ignoreOccupied If true, the result can be an occupied cell
     * @param result Array in which to place the result, or null (in which case a new array will
     *        be allocated)
     * @return The X, Y cell of a vacant area that can contain this object,
     *         nearest the requested location.
     */
int[] findNearestArea(int pixelX, int pixelY, int minSpanX, int minSpanY, int spanX, int spanY, View ignoreView, boolean ignoreOccupied, int[] result, int[] resultSpan, boolean[][] occupied) {
    lazyInitTempRectStack();
    // mark space take by ignoreView as available (method checks if ignoreView is null)
    markCellsAsUnoccupiedForView(ignoreView, occupied);
    // For items with a spanX / spanY > 1, the passed in point (pixelX, pixelY) corresponds
    // to the center of the item, but we are searching based on the top-left cell, so
    // we translate the point over to correspond to the top-left.
    pixelX -= (mCellWidth + mWidthGap) * (spanX - 1) / 2f;
    pixelY -= (mCellHeight + mHeightGap) * (spanY - 1) / 2f;
    // Keep track of best-scoring drop area
    final int[] bestXY = result != null ? result : new int[2];
    double bestDistance = Double.MAX_VALUE;
    final Rect bestRect = new Rect(-1, -1, -1, -1);
    final Stack<Rect> validRegions = new Stack<Rect>();
    final int countX = mCountX;
    final int countY = mCountY;
    if (minSpanX <= 0 || minSpanY <= 0 || spanX <= 0 || spanY <= 0 || spanX < minSpanX || spanY < minSpanY) {
        return bestXY;
    }
    for (int y = 0; y < countY - (minSpanY - 1); y++) {
        inner: for (int x = 0; x < countX - (minSpanX - 1); x++) {
            int ySize = -1;
            int xSize = -1;
            if (ignoreOccupied) {
                // First, let's see if this thing fits anywhere
                for (int i = 0; i < minSpanX; i++) {
                    for (int j = 0; j < minSpanY; j++) {
                        if (occupied[x + i][y + j]) {
                            continue inner;
                        }
                    }
                }
                xSize = minSpanX;
                ySize = minSpanY;
                // We know that the item will fit at _some_ acceptable size, now let's see
                // how big we can make it. We'll alternate between incrementing x and y spans
                // until we hit a limit.
                boolean incX = true;
                boolean hitMaxX = xSize >= spanX;
                boolean hitMaxY = ySize >= spanY;
                while (!(hitMaxX && hitMaxY)) {
                    if (incX && !hitMaxX) {
                        for (int j = 0; j < ySize; j++) {
                            if (x + xSize > countX - 1 || occupied[x + xSize][y + j]) {
                                // We can't move out horizontally
                                hitMaxX = true;
                            }
                        }
                        if (!hitMaxX) {
                            xSize++;
                        }
                    } else if (!hitMaxY) {
                        for (int i = 0; i < xSize; i++) {
                            if (y + ySize > countY - 1 || occupied[x + i][y + ySize]) {
                                // We can't move out vertically
                                hitMaxY = true;
                            }
                        }
                        if (!hitMaxY) {
                            ySize++;
                        }
                    }
                    hitMaxX |= xSize >= spanX;
                    hitMaxY |= ySize >= spanY;
                    incX = !incX;
                }
                incX = true;
                hitMaxX = xSize >= spanX;
                hitMaxY = ySize >= spanY;
            }
            final int[] cellXY = mTmpXY;
            cellToCenterPoint(x, y, cellXY);
            // We verify that the current rect is not a sub-rect of any of our previous
            // candidates. In this case, the current rect is disqualified in favour of the
            // containing rect.
            Rect currentRect = mTempRectStack.pop();
            currentRect.set(x, y, x + xSize, y + ySize);
            boolean contained = false;
            for (Rect r : validRegions) {
                if (r.contains(currentRect)) {
                    contained = true;
                    break;
                }
            }
            validRegions.push(currentRect);
            double distance = Math.sqrt(Math.pow(cellXY[0] - pixelX, 2) + Math.pow(cellXY[1] - pixelY, 2));
            if ((distance <= bestDistance && !contained) || currentRect.contains(bestRect)) {
                bestDistance = distance;
                bestXY[0] = x;
                bestXY[1] = y;
                if (resultSpan != null) {
                    resultSpan[0] = xSize;
                    resultSpan[1] = ySize;
                }
                bestRect.set(currentRect);
            }
        }
    }
    // re-mark space taken by ignoreView as occupied
    markCellsAsOccupiedForView(ignoreView, occupied);
    // Return -1, -1 if no suitable location found
    if (bestDistance == Double.MAX_VALUE) {
        bestXY[0] = -1;
        bestXY[1] = -1;
    }
    recycleTempRects(validRegions);
    return bestXY;
}

Example 24 with Stack

use of java.util.Stack in project PneumaticCraft by MineMaarten.

the class HeatBehaviourLiquidTransition method transformSourceBlock.

protected void transformSourceBlock(Block turningBlockSource, Block turningBlockFlowing) {
    if (FluidUtils.isSourceBlock(getWorld(), getX(), getY(), getZ())) {
        getWorld().setBlock(getX(), getY(), getZ(), turningBlockSource);
        onLiquidTransition(getX(), getY(), getZ());
    } else {
        Set<ChunkPosition> traversed = new HashSet<ChunkPosition>();
        Stack<ChunkPosition> pending = new Stack<ChunkPosition>();
        pending.push(new ChunkPosition(getX(), getY(), getZ()));
        while (!pending.isEmpty()) {
            ChunkPosition pos = pending.pop();
            for (ForgeDirection d : ForgeDirection.VALID_DIRECTIONS) {
                ChunkPosition newPos = new ChunkPosition(pos.chunkPosX + d.offsetX, pos.chunkPosY + d.offsetY, pos.chunkPosZ + d.offsetZ);
                Block checkingBlock = getWorld().getBlock(newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ);
                if ((checkingBlock == getBlock() || getBlock() == Blocks.flowing_water && checkingBlock == Blocks.water || getBlock() == Blocks.flowing_lava && checkingBlock == Blocks.lava) && traversed.add(newPos)) {
                    if (FluidUtils.isSourceBlock(getWorld(), newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ)) {
                        getWorld().setBlock(newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ, turningBlockSource);
                        onLiquidTransition(newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ);
                        return;
                    } else {
                        getWorld().setBlock(newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ, turningBlockFlowing);
                        onLiquidTransition(newPos.chunkPosX, newPos.chunkPosY, newPos.chunkPosZ);
                        pending.push(newPos);
                    }
                }
            }
        }
    }
}

Example 25 with Stack

use of java.util.Stack in project PneumaticCraft by MineMaarten.

the class TileEntityElevatorBase method connectAsMultiblock.

private void connectAsMultiblock() {
    multiElevators = null;
    if (isCoreElevator()) {
        multiElevators = new ArrayList<TileEntityElevatorBase>();
        Stack<TileEntityElevatorBase> todo = new Stack<TileEntityElevatorBase>();
        todo.add(this);
        while (!todo.isEmpty()) {
            TileEntityElevatorBase curElevator = todo.pop();
            if (curElevator.isCoreElevator()) {
                multiElevators.add(curElevator);
                curElevator.multiElevators = multiElevators;
                for (int i = 2; i < 6; i++) {
                    TileEntity te = curElevator.getTileCache()[i].getTileEntity();
                    if (!multiElevators.contains(te) && te instanceof TileEntityElevatorBase) {
                        todo.push((TileEntityElevatorBase) te);
                    }
                }
            }
        }
    }
}