/** Show the last element in the list of adapters */ private void showList() { if (mAdapters.isEmpty() || mAdapters.getLast().isEmpty()) { mList.setEmptyView(mEmptyLibrary); } else { LibraryAdapter adapter = mAdapters.getLast(); adapter.getFilter().filter(mLastFilter); mList.setAdapter(adapter); if (adapter.isEmpty() || adapter.getCount() == 0) { buildSubActionBar("", ""); } else { MyLibraryItem item = adapter.getItem(0); switch (item.getLevel()) { case MyLibrary.LVL_ARTIST: buildSubActionBar("", ""); break; case MyLibrary.LVL_ALBUM: buildSubActionBar(item.getArtist(), ""); break; default: buildSubActionBar(item.getArtist(), item.getAlbum()); break; } } } }
@Override public String toString() { String str = "=================================================\n"; str += "Freecells: "; for (LinkedList<Card> freecell : freecells) { if (freecell.isEmpty()) str += " "; else str += freecell.getLast().toString() + " "; } str += "\t\tFoundations: "; for (LinkedList<Card> foundation : foundations) { if (foundation.isEmpty()) str += " "; else str += foundation.getLast().toString() + "(" + foundation.size() + ") "; } str += "\n\n"; for (LinkedList<Card> cascade : cascades) { if (cascade.isEmpty()) str += "\n"; else { for (Card c : cascade) { str += c.toString() + " "; } str += "\n"; } } str += "\nF: " + f + "\tG: " + g + "\tH: " + h + "\n"; str += "=================================================\n"; return str; }
private void readGraph() throws IOException { InputStream is = ProgrammingSet4.class.getResourceAsStream("SCC.txt"); BufferedReader reader = new BufferedReader(new InputStreamReader(is)); graph = new HashMap<Integer, List<Integer>>(); rGraph = new HashMap<Integer, List<Integer>>(); String l = null; while ((l = reader.readLine()) != null) { LinkedList<Integer> line = readEdge(l); List<Integer> edges = graph.get(line.getFirst()); if (edges == null) { edges = new ArrayList<Integer>(); graph.put(line.getFirst(), edges); } edges.add(line.getLast()); List<Integer> rEdges = rGraph.get(line.getLast()); if (rEdges == null) { rEdges = new ArrayList<Integer>(); rGraph.put(line.getLast(), rEdges); } rEdges.add(line.getFirst()); } reader.close(); }
private void endCondition(String name) throws SAXException { Condition cond = conditionStack.removeLast(); if (cond.isEmpty()) throw new SAXException('<' + name + "> must not be empty"); if (!values.isEmpty()) { try { MemberOf memberOf = (MemberOf) cond; if (memberOf.vr.isIntType()) memberOf.setValues(parseInts(values)); else memberOf.setValues(values.toArray(new String[values.size()])); } catch (Exception e) { throw new SAXException("unexpected <Value> contained by <" + name + ">"); } values.clear(); } if (!codes.isEmpty()) { try { ((MemberOf) cond).setValues(codes.toArray(new Code[codes.size()])); } catch (Exception e) { throw new SAXException("unexpected <Code> contained by <" + name + ">"); } codes.clear(); } if (conditionStack.isEmpty()) { if (elementConditions) getLastDataElement().setCondition(cond.trim()); else iodStack.getLast().setCondition(cond.trim()); elementConditions = false; itemConditions = false; } else conditionStack.getLast().addChild(cond.trim()); }
@Override public Object handle() throws GAIInterpreterException { String condition = getFirstMatch(getCommand(), RH.VAL_OR_EXP); String action = getActionName(getCommand().replace(condition, "")); LinkedList<GAIObject> actionChain = getSession().getObjectOrAttribute(action); if (isPathValid(action)) { throw new GAIInterpreterException(wrongPath(actionChain)); } Object result; AbstractHandler handler; if (hasMatch(condition, RH.ANY_VAL)) { result = getValue(condition); } else if (hasMatch(condition, RH.NUMERIC_EXP)) { handler = new NumericExpHandler(condition, getInterpreter()); result = handler.handle(); } else if (hasMatch(condition, RH.ACT_EXE)) { handler = new ActionExecHandler(condition, getInterpreter()); result = handler.handle(); } else { throw new GAIInterpreterException(INVALID_FOR_CONDITION); } if (result == null) { throw new GAIInterpreterException(INVALID_FOR_CONDITION); } if (isArray(result)) { GAIObject arrayObject = (GAIObject) result; for (Object e : arrayObject.getElements()) { executeAction(actionChain.getLast(), e); } } else { executeAction(actionChain.getLast(), result); } return null; }
@Override public void handleMessage(Message msg) { switch (msg.what) { case MessageId.UPDATE_CLIENT_ID_FAIL: { BaseUtil.innerComm.webappclient.updateClientId( BaseUtil.getSelfUserInfo().getUserId(), clientId); break; } case MessageId.APK_DOWN_LOAD_DONE: { Intent intent = new Intent(Intent.ACTION_VIEW); intent.setDataAndType( Uri.fromFile( new File( FileUtil.APK_PATH + BaseUtil.getSystemInfo().getLatestClientName())), "application/vnd.android.package-archive"); InnerCommAdapter.ct.startActivity(intent); break; } default: { if (!innerCommQue.isEmpty()) { Log.i( "InnerCommAdapter", "baseutil send msg:" + msg.what + "to->" + innerCommQue.getLast()); innerCommQue.getLast().processMessage(msg); } else { Log.e("BaseUtil", "UI activity innerCommQue is empty,drop msgid:!!" + msg.what); } break; } } }
public MemorySet( int numberOfLevels, int[] assocs, int[] cacheszs, int[] blockszs, int[] latencies, int policy, int mainMemoryLatency, HashMap<Integer, int[]> initialMemory) { if (policy == 0) { writeThrough = true; } else { writeThrough = false; } cycles = 0; mainMemory = new MainMemory(initialMemory, mainMemoryLatency); caches = new LinkedList<Cache>(); // int x, y, z, cyc; for (int i = 0; i < numberOfLevels; i++) { caches.add(new Cache(assocs[i], cacheszs[i], blockszs[i], latencies[i])); if (i > 0) { caches.get(i - 1).setHigherLevel(caches.getLast()); } } caches.getLast().setMainMemory(mainMemory); firstCache = caches.getFirst(); }
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; // 第一次的时候缺少这一句,陷入死循环。 } } }
public void addState(World x) { double growthRate = calGrowthRate(x), deathRate = calDeathRate(x); int population = x.getPopulation(); listPopulationChange.add(generation == 0 ? population : population - listPopulation.getLast()); listPopulation.add(population); listGrowthRate.add(growthRate); listDeathRate.add(deathRate); if (generation == 1) { minPopulation = maxPopulation = population; maxGrowthRate = minGrowthRate = growthRate; maxDeathRate = deathRate; maxPopulationChange = minPopulationChange = listPopulationChange.getLast(); } if (generation > 1) { minPopulation = minPopulation > population ? population : minPopulation; maxPopulation = maxPopulation < population ? population : maxPopulation; maxGrowthRate = maxGrowthRate < growthRate ? growthRate : maxGrowthRate; maxDeathRate = maxDeathRate < deathRate ? deathRate : maxDeathRate; maxPopulationChange = Math.max(maxPopulationChange, listPopulationChange.getLast()); minPopulationChange = Math.min(minPopulationChange, listPopulationChange.getLast()); maxGrowthRate = Math.max(maxGrowthRate, listGrowthRate.getLast()); minGrowthRate = Math.min(minGrowthRate, listGrowthRate.getLast()); } generation++; listCells.add(x); }
/** * Removes the least recently used elements if the cache size is greater than or equal to the * maximum allowed size until the cache is at least 10% empty. */ protected synchronized void cullCache() { // Check if a max cache size is defined. if (maxCacheSize < 0) { return; } // See if the cache is too big. If so, clean out cache until it's 10% free. if (map.size() > maxCacheSize) { // First, delete any old entries to see how much memory that frees. deleteExpiredEntries(); // Next, delete the least recently used elements until 10% of the cache // has been freed. int desiredSize = (int) (maxCacheSize * .90); for (int i = map.size(); i > desiredSize; i--) { // Get the key and invoke the remove method on it. if (remove(lastAccessedList.getLast().object, true) == null) { LOGGER.warning( "Error attempting to cullCache with remove(" + lastAccessedList.getLast().object.toString() + ") - cacheObject not found in cache!"); lastAccessedList.getLast().remove(); } } } }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#linetoVerticalRel(float) */ public void linetoVerticalRel(float y) throws ParseException { if (verbose) System.out.println("linetoVerticalRel: " + y); Vertex vert = new Vertex(pathPoints.getLast().getX(), pathPoints.getLast().getY() + y, 0); pathPoints.add(vert); currentSubPath.add(vert); }
private void sendBatchNonTransacted() { try { if (qualityOfServiceMode == QualityOfServiceMode.ONCE_AND_ONLY_ONCE) { // We client ack before sending if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Client acking source session"); } messages.getLast().acknowledge(); if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Client acked source session"); } } sendMessages(); if (maxBatchSize > 1) { // The sending session is transacted - we need to commit it if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Committing target session"); } targetSession.commit(); if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Committed source session"); } } if (qualityOfServiceMode == QualityOfServiceMode.DUPLICATES_OK) { // We client ack after sending // Note we could actually use Session.DUPS_OK_ACKNOWLEDGE here // For a slightly less strong delivery guarantee if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Client acking source session"); } messages.getLast().acknowledge(); if (JMSBridgeImpl.trace) { HornetQJMSServerLogger.LOGGER.trace("Client acked source session"); } } // Clear the messages messages.clear(); } catch (Exception e) { HornetQJMSServerLogger.LOGGER.bridgeAckError(e); handleFailureOnSend(); } }
private ArrayList<String> helper(WifiMapData unknown) { Vd2_3MapData unknownStat = new Vd2_3MapData(unknown); // debug("here stat"); // debug(unknownStat, unknownStat.fullScan.size()); LinkedList<LocationEvaluation> possible = new LinkedList<LocationEvaluation>(); ArrayList<String> possibleLocations = new ArrayList<String>(); for (String locationID : cache.keySet()) { LocationEvaluation eval = new LocationEvaluation(locationID); possible.add(eval); } if (possible.isEmpty()) { System.out.println("+++++++++++++++++++++++++++++++++"); return possibleLocations; } { // Remove the ones that has too little low-var Aps for (LocationEvaluation eval : possible) { eval.score = nHavingLowVariance(cache.get(eval.name), unknownStat); } Collections.sort(possible); // debug(possible); double min = possible.getFirst().score - maxAbsenceAP; while (!possible.isEmpty() && possible.getLast().score < min) possible.removeLast(); } { // Remove the ones that miss too much Low-var APs for (LocationEvaluation eval : possible) { eval.score = nMissingLowVariance(cache.get(eval.name), unknownStat); } Collections.sort(possible); // debug(possible); double min = possible.getFirst().score - maxAbsenceAP; while (!possible.isEmpty() && possible.getLast().score < min) possible.removeLast(); } { // Sort the average this distance for (LocationEvaluation eval : possible) { eval.score = differenceAverage(cache.get(eval.name), unknownStat); } Collections.sort(possible); while (!possible.isEmpty() && possible.getLast().score < VERY_NEGATIVE) { possible.removeLast(); } } for (int i = 0; i < possible.size(); ++i) { possibleLocations.add(possible.get(i).name); } return possibleLocations; }
/** * flashback! Throws an unsupported operation exception * * @param location where to flash back to */ public void flashBackTo(GenomeLoc location) { if (!canFlashBackTo(location)) throw new UnsupportedOperationException("we can't flash back to " + location); if (pastQueue.size() == 0) return; // the iterator can do it alone while (pastQueue.size() > 0 && !pastQueue.getLast().getLocation().isBefore(location)) { aheadQueue.addFirst(pastQueue.getLast()); pastQueue.removeLast(); } }
public int theNthNum(int n) { Integer[] a = {1, 2, 3, 4, 5}; if (n <= 5) return a[n - 1]; LinkedList<Integer> arrayIntegers = new LinkedList<Integer>(); for (int aa : a) arrayIntegers.add(aa); for (int i = 6; i <= n; i++) { int x = getNext(arrayIntegers.getLast(), arrayIntegers); arrayIntegers.add(x); } return arrayIntegers.getLast(); }
private void updateEtaAndSpeed() { long now = dates.getFirst(); long past = dates.getLast(); long loadedKbNow = loaded.getFirst(); long loadedKbPast = loaded.getLast(); long kiloBytesRemaining = max - loadedKbNow; // speed kb/ speedKbPerSecond = (float) ((double) (loadedKbNow - loadedKbPast)) / ((now - past) / 1000); timeleft = (long) (kiloBytesRemaining / speedKbPerSecond); eta.setTime(now + timeleft * 1000); }
/** Starts adding points to the mouseEvents list every 2 milliseconds */ private void collect() { int same = 0; // The number of times that the mouse has been in same position. pause = false; // whether or not the mouse is currently idle while (record) { if (!pause) { // If the mouse is not currently idle, A new point is added to the "mouseEvents" List. point // has x and y coordinates mouseEvents.add( new SimpleMouseEvent( MouseInfo.getPointerInfo().getLocation().x, MouseInfo.getPointerInfo().getLocation().y, 0)); } // If the mouse is currently set as idle, but mouvement has been detected: that is, if the // current position is different than // where the mouse is when it was set as idle... if (pause && ((MouseInfo.getPointerInfo().getLocation().x) != mouseEvents.getLast().gx() || MouseInfo.getPointerInfo().getLocation().y != mouseEvents.getLast().gy())) { unpause(); } // Detects if the current position of the mouse is the same as the last time it was checked. if (mouseEvents.size() > 5 && (mouseEvents .getLast() .toString() .equals(mouseEvents.get(mouseEvents.size() - 2).toString()))) { // If position is the same, the "same" count is increased. same++; // Once the mouse has been in the same place for 10 cycles, it is said to be idle. if (same == 10) { pause = true; // The stopwatch will count how long the mouse has been idle for stopWatch.start(); System.out.println("Pause"); } } else { // If the mouse has moved since last cycle, then the number of times it has been in the same // position is set to 0. same = 0; } try { Thread.sleep(2); // Delay between cycles. } catch (InterruptedException ex) { Thread.currentThread().interrupt(); } if (!record) { gui.log("Recording Stopped."); gui.refreshActionList(); } } }
public Register getDestinationRegister() { /* for(int i = fields.size() - 1; i >= 0; i--) { if(fields.get(i) instanceof Register) { return (Register)fields.get(i); } } */ if (fields.size() > 0 && fields.getLast() instanceof Register) return (Register) fields.getLast(); return null; }
public void removeFromStacks(UndoableGroup group) { if (group.getAffectedDocuments().isEmpty()) return; if (group.isGlobal()) { assert myGlobalStack.getLast() == group; myGlobalStack.removeLast(); } for (DocumentReference each : group.getAffectedDocuments()) { LinkedList<UndoableGroup> stack = getStack(each); assert stack.getLast() == group; stack.removeLast(); } }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#curvetoQuadraticSmoothRel(float, float) */ public void curvetoQuadraticSmoothRel(float x, float y) throws ParseException { if (verbose) System.out.println("curvetoQuadraticSmoothRel: " + x + "," + y); Vertex lastPoint = pathPoints.getLast(); if (lastPoint instanceof BezierVertex && cubicBezVertTOQuadricControlPoint.get(lastPoint) != null) { Vertex lastEndPoint = new Vertex( pathPoints.getLast().getX(), pathPoints.getLast().getY(), pathPoints.getLast().getZ()); // Get control point of last QuadTo Vertex lastQuadControlPoint = cubicBezVertTOQuadricControlPoint.get(lastPoint); cubicBezVertTOQuadricControlPoint.remove(lastPoint); // Rotate that controlpoint around the end point of the last QuadTo lastQuadControlPoint.rotateZ(lastEndPoint, 180); // Put in startPoint = last QuadTo Endpoint of this smoothQuadTo, the calculated control // point, and the endpoint of smoothQuadTo BezierVertex b5 = Tools3D.getCubicFromQuadraticCurve( lastEndPoint, lastQuadControlPoint, new Vertex(lastPoint.getX() + x, lastPoint.getY() + y, 0)); // Save last quad control point cubicBezVertTOQuadricControlPoint.put(b5, lastQuadControlPoint); pathPoints.add(b5); currentSubPath.add(b5); } else { if (verbose) System.out.println( "couldnt get last control point at curvetoQuadraticSmoothRel - using last point as the control point"); Vertex lastEndPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0); Vertex quadControlPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0); BezierVertex b5 = Tools3D.getCubicFromQuadraticCurve( lastEndPoint, quadControlPoint, new Vertex(lastPoint.getX() + x, lastPoint.getY() + y, 0)); cubicBezVertTOQuadricControlPoint.put(b5, quadControlPoint); pathPoints.add(b5); currentSubPath.add(b5); } }
public synchronized boolean enqueue(ByteBuffer byteBuffer) { if (byteBuffer.remaining() == 0) { return false; } if (queue.size() > 0) { ByteBuffer tail = queue.getLast(); if (tail.hasRemaining()) { topUpBuffer(tail, byteBuffer); } } while (byteBuffer.hasRemaining()) { ByteBuffer newBuf = bufferFactory.newBuffer(); topUpBuffer(newBuf, byteBuffer); queue.addLast(newBuf); } facade.modifyInterestOps(SelectionKey.OP_WRITE, 0); return true; }
public void actionPerformed(ActionEvent event) { int i; JButton aux = (JButton) event.getSource(); if (aux == closeCompra) { try { String[] information = { JOptionPane.showInputDialog(null, "nombre"), JOptionPane.showInputDialog(null, "numero de targeta") }; ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream()); oos.writeObject(information); oos.flush(); oos.writeObject(products); oos.flush(); oos.writeObject(comprados); oos.flush(); cleanTable(); comprados.clear(); } catch (Exception e) { System.out.print("\nerror al cerrar la compra " + e.getMessage()); } return; } for (i = 0; aux != mostrador.addCar[i]; i++) {; } if (products.get(i).getPiesas() > 0) { products.get(i).popParts(); addCompra(products.get(i)); total.setText("total: " + comprados.getLast().getTotal()); } else { JOptionPane.showMessageDialog(null, "no seas menso ya no hay mas piesas! :@"); } }
/** * @param cacheCtx Cache context. * @param cand Cache lock candidate to add. * @return {@code True} if added as a result of this operation, {@code false} if was previously * added. */ public boolean addNext(GridCacheContext cacheCtx, GridCacheMvccCandidate cand) { assert cand != null; assert !cand.reentry() : "Lock reentries should not be linked: " + cand; // Don't order near candidates by thread as they will be ordered on // DHT node. Also, if candidate is implicit, no point to order him. if (cacheCtx.isNear() || cand.singleImplicit()) return true; LinkedList<GridCacheMvccCandidate> queue = pending.get(); GridCacheMvccCandidate prev = null; if (!queue.isEmpty()) prev = queue.getLast(); queue.add(cand); if (prev != null) { prev.next(cand); cand.previous(prev); } if (log.isDebugEnabled()) log.debug("Linked new candidate: " + cand); return true; }
public void handleEvents() { for (int i = 0; i < eventQueue.size(); i++) { Event e = eventQueue.getLast(); if (e.timestamp > ProcessingSketch.getGameTimeline().getIterations()) break; if (e.type == EventType.NEW_OBJECT) { ProcessingSketch.addGameObject(((NewObjectEvent) e).newObj); } else if (e.type == EventType.SHOT_COLLISION) { ProcessingSketch.removeObjByGUID(((ShotCollisionEvent) e).obj1GUID); ProcessingSketch.removeObjByGUID(((ShotCollisionEvent) e).obj2GUID); } else { for (GameObject obj : ProcessingSketch.getObjects()) { if (handlerMap.get(obj.getGUID()) == null) continue; if (handlerMap.get(obj.getGUID()).contains(e.type)) { if (e.type == EventType.COLLISION) { if (((CollisionEvent) e).obj1.getGUID() != obj.getGUID() && ((CollisionEvent) e).obj2.getGUID() != obj.getGUID()) { continue; // if obj is neither of the collided objects, don't send the collision // event to obj } } obj.onEvent(e); } } } eventQueue.removeLast(); System.out.println("Events handled: " + i); } }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#curvetoCubicSmoothAbs(float, float, float, float) */ public void curvetoCubicSmoothAbs(float x2, float y2, float x, float y) throws ParseException { if (verbose) System.out.println("curvetoCubicSmoothAbs x2:" + x2 + " y2:" + y2 + " x:" + x + " y:" + y); Vertex lastPoint = pathPoints.getLast(); if (lastPoint instanceof BezierVertex) { BezierVertex lastBez = (BezierVertex) lastPoint; Vertex lastConPointCopy = (Vertex) lastBez.getSecondCtrlPoint().getCopy(); // reflect the last controlpoint at the current point lastConPointCopy.rotateZ(lastPoint, 180); BezierVertex b = new BezierVertex(lastConPointCopy.getX(), lastConPointCopy.getY(), 0, x2, y2, 0, x, y, 0); pathPoints.add(b); currentSubPath.add(b); } else { if (verbose) System.out.println( "Couldnt get last controlpoint at: curvetoCubicSmoothAbs - using last point as first controlpoint"); Vertex lastEndPoint = new Vertex(lastPoint.getX(), lastPoint.getY(), 0); BezierVertex b = new BezierVertex(lastEndPoint.getX(), lastEndPoint.getY(), 0, x2, y2, 0, x, y, 0); pathPoints.add(b); currentSubPath.add(b); } }
public static String normalizePath(String path) { if (!path.contains("./")) { return path; } boolean absolute = path.startsWith("/"); String[] elements = path.split(Repository.SEPARATOR); LinkedList<String> list = new LinkedList<String>(); for (String e : elements) { if ("..".equals(e)) { if (list.isEmpty() || "..".equals(list.getLast())) { list.add(e); } else { list.removeLast(); } } else if (!".".equals(e) && e.length() > 0) { list.add(e); } } StringBuilder sb = new StringBuilder(path.length()); if (absolute) { sb.append("/"); } int count = 0, last = list.size() - 1; for (String e : list) { sb.append(e); if (count++ < last) sb.append("/"); } return sb.toString(); }
/** * Calculate largest prime factor. * * @return the largest prime factor */ public int getLargestPrimeFactor() { int divider = PrimeChecker.FIRST_PRIME; double divideIt = this.divideIt; this.factors.addLast(PrimeChecker.FIRST_PRIME); while (divideIt > 1) { if (String.valueOf(divideIt).endsWith(String.valueOf(PrimeChecker.END_PRIME))) { divider = PrimeChecker.END_PRIME; divideIt = divideIt / divider; } else { boolean hasNext = false; for (final int prime : this.factors) { if (divideIt % prime == 0) { divider = prime; hasNext = true; break; } } if (!hasNext) { while (divideIt % divider == 0) { this.factors.addLast(divider); divider = PrimeChecker.getNextPrime(this.factors); } hasNext = false; } } divideIt = divideIt / divider; if (!factors.contains(divider)) { factors.add(divider); } } System.out.println("processed primes : " + factors.toString()); return factors.getLast(); }
/** * Caches the path that was just found. * * @param smiod * @param endNode * @param startNode */ private void cachePath(StreetMobilityInfoOD smiod, SegmentNode startNode, SegmentNode endNode) { if (hm != null && smiod.path.size() > MIN_CACHED_PATH_LENGTH) { Location startPoint = startNode.point; LinkedList ll = (LinkedList) hm.get(startPoint); if (ll == null) { ll = new LinkedList(); } // make sure that path doesn't already exist... // must iterate through all of them... ListIterator li = ll.listIterator(); boolean found = false; while (li.hasNext()) { LinkedList existingPath = (LinkedList) li.next(); if (existingPath.getFirst().equals(startNode) && existingPath.getLast().equals(smiod.path.getLast())) { found = true; break; } } if (!found) { LinkedList newPath = (LinkedList) smiod.path.clone(); newPath.addFirst(startNode); ll.add(newPath); hm.put(startPoint, ll); } } }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#arcAbs(float, float, float, boolean, boolean, float, float) */ public void arcAbs( float rx, float ry, float phi, boolean large_arc, boolean sweep, float x, float y) throws ParseException { if (verbose) System.out.println( "arcAbs: " + rx + " " + ry + " " + phi + " " + large_arc + " " + sweep + " " + x + " " + y); Vertex lastPoint = pathPoints.getLast(); List<Vertex> arcVertices = Tools3D.arcTo(lastPoint.x, lastPoint.y, rx, ry, phi, large_arc, sweep, x, y, 40); // Prevent odd picking behavour, in which the normal is // not correctly computed, because the 2 points are the same if (!arcVertices.isEmpty() && lastPoint != null && arcVertices.get(0).equalsVector(lastPoint)) { arcVertices.remove(0); } pathPoints.addAll(arcVertices); currentSubPath.addAll(arcVertices); }
/* (non-Javadoc) * @see org.apache.batik.parser.PathHandler#linetoHorizontalAbs(float) */ public void linetoHorizontalAbs(float x) throws ParseException { if (verbose) System.out.println("linetoHorizontalAbs x:" + x); Vertex vert = new Vertex(x, pathPoints.getLast().getY(), 0); pathPoints.add(vert); currentSubPath.add(vert); }