/** * @return the uncached node indices of the tower nodes in this path. */ public IntIndexedContainer calcNodes() { final IntArrayList nodes = new IntArrayList(edgeIds.size() + 1); if (edgeIds.isEmpty()) { if (isFound()) { nodes.add(endNode); } return nodes; } int tmpNode = getFromNode(); nodes.add(tmpNode); forEveryEdge(new EdgeVisitor() { @Override public void next(EdgeIteratorState eb, int index, int prevEdgeId) { nodes.add(eb.getAdjNode()); } @Override public void finish() { } }); return nodes; }
InMemLeafEntry leaf = ((InMemLeafEntry) entry); IntArrayList entries = leaf.getResults(); int len = entries.size(); if (len == 0) { return intIndex; if (len == 1) { dataAccess.setInt(refPointer, -entries.get(0) - 1); } else { for (int index = 0; index < len; index++, intIndex++) { dataAccess.setInt((long) intIndex * 4, entries.get(index));
void addTrip(ZoneId zoneId, int time, List<TripWithStopTimeAndArrivalNode> arrivalNodes, TripWithStopTimes trip, GtfsRealtime.TripDescriptor tripDescriptor, boolean frequencyBased) { IntArrayList boardEdges = new IntArrayList(); IntArrayList alightEdges = new IntArrayList(); StopTime prev = null; int arrivalNode = -1; boardEdge.setName(getRouteName(feed, trip.trip)); setEdgeTypeAndClearDistance(boardEdge, GtfsStorage.EdgeType.BOARD); while (boardEdges.size() < stopTime.stop_sequence) { boardEdges.add(-1); // Padding, so that index == stop_sequence boardEdges.add(boardEdge.getEdge()); gtfsStorage.getStopSequences().put(boardEdge.getEdge(), stopTime.stop_sequence); gtfsStorage.getTripDescriptors().put(boardEdge.getEdge(), tripDescriptor.toByteArray()); alightEdge.setName(getRouteName(feed, trip.trip)); setEdgeTypeAndClearDistance(alightEdge, GtfsStorage.EdgeType.ALIGHT); while (alightEdges.size() < stopTime.stop_sequence) { alightEdges.add(-1); alightEdges.add(alightEdge.getEdge()); gtfsStorage.getStopSequences().put(alightEdge.getEdge(), stopTime.stop_sequence); gtfsStorage.getTripDescriptors().put(alightEdge.getEdge(), tripDescriptor.toByteArray()); gtfsStorage.getBoardEdgesForTrip().put(GtfsStorage.tripKey(tripDescriptor, frequencyBased), boardEdges.toArray()); gtfsStorage.getAlightEdgesForTrip().put(GtfsStorage.tripKey(tripDescriptor, frequencyBased), alightEdges.toArray()); TripWithStopTimeAndArrivalNode tripWithStopTimeAndArrivalNode = new TripWithStopTimeAndArrivalNode(); tripWithStopTimeAndArrivalNode.tripWithStopTimes = trip;
private Graph buildInterferenceGraph(List<Map<Instruction, BitSet>> liveInInformation, Program program) { GraphBuilder builder = new GraphBuilder(program.variableCount()); for (Map<Instruction, BitSet> blockLiveIn : liveInInformation) { for (BitSet liveVarsSet : blockLiveIn.values()) { IntArrayList liveVars = new IntArrayList(); for (int i = liveVarsSet.nextSetBit(0); i >= 0; i = liveVarsSet.nextSetBit(i + 1)) { liveVars.add(i); } int[] liveVarArray = liveVars.toArray(); for (int i = 0; i < liveVarArray.length - 1; ++i) { for (int j = i + 1; j < liveVarArray.length; ++j) { builder.addEdge(liveVarArray[i], liveVarArray[j]); builder.addEdge(liveVarArray[j], liveVarArray[i]); } } } } return builder.build(); }
void fillVirtualEdges(IntObjectMap<VirtualEdgeIterator> node2Edge, int towerNode, EdgeExplorer mainExpl) { if (isVirtualNode(towerNode)) throw new IllegalStateException("Node should not be virtual:" + towerNode + ", " + node2Edge); VirtualEdgeIterator vIter = node2Edge.get(towerNode); IntArrayList ignoreEdges = new IntArrayList(vIter.count() * 2); while (vIter.next()) { EdgeIteratorState edge = queryResults.get(vIter.getAdjNode() - mainNodes).getClosestEdge(); ignoreEdges.add(edge.getEdge()); } vIter.reset(); EdgeIterator iter = mainExpl.setBaseNode(towerNode); while (iter.next()) { if (!ignoreEdges.contains(iter.getEdge())) vIter.add(iter.detach(false)); } }
public int[] ports() throws NumberFormatException { final IntArrayList ports = new IntArrayList(); iterate(new PortCallback() { @Override public boolean onPortNumber(int portNumber) { ports.add(portNumber); return false; } }); return ports.toArray(); }
IntArrayList component = new IntArrayList(); int node; while ((node = nodeStack.removeLast()) != start) { component.add(node); onStack.remove(node); component.add(start); component.trimToSize(); onStack.remove(start); components.add(component);
private void initIfNecessary() { if (mappings != null) { return; } mappings = new int[program.basicBlockCount()]; previousPtr = new IntArrayList(program.basicBlockCount() * 2); firstPtr = new IntArrayList(program.basicBlockCount() * 2); isLastInSequence = new ByteArrayList(program.basicBlockCount() * 2); for (int i = 0; i < mappings.length; ++i) { mappings[i] = i; previousPtr.add(i); firstPtr.add(i); isLastInSequence.add((byte) 1); } variableDefinedAt = ProgramUtils.getVariableDefinitionPlaces(program); }
depth = depthsByBlock.get(block.getIndex()); if (depth >= MAX_DEPTH) { continue;
/** * Returns all feature indices. * @return all feature indices. */ public int[] getIndices() { return i_indices.toArray(); }
continue; final IntArrayList intList = new IntArrayList(20); list.add(intList); new BreadthFirstSearch() { intList.trimToSize();
/** * Ensure this container can hold at least the given number of elements * without resizing its buffers. * * @param expectedElements * The total number of elements, inclusive. */ @Override public void ensureCapacity(int expectedElements) { final int bufferLen = (buffer == null ? 0 : buffer.length); if (expectedElements > bufferLen) { ensureBufferSpace(expectedElements - size()); } }
/** * Adds all elements from another container. */ public int addAll(IntContainer container) { final int size = container.size(); ensureBufferSpace(size); for (IntCursor cursor : container) { add(cursor.value); } return size; }
/** * {@inheritDoc} */ @Override public int removeLast(int e1) { final int index = lastIndexOf(e1); if (index >= 0) remove(index); return index; }