void startIdleState() { lock.lock(); try { final Thread currentThread = Thread.currentThread(); final Thread currentIdleThread = threadsRequestingIdle.peekFirst(); if (currentIdleThread == currentThread) { assert idleStateCount > 0; ++idleStateCount; assert idleStateCount > 0; return; } threadsRequestingIdle.add(currentThread); while ((activitiyCount > 0) || (threadsRequestingIdle.getFirst() != currentThread)) condition.awaitUninterruptibly(); assert idleStateCount == 0; assert activitiyCount == 0; assert threadsRequestingIdle.getFirst() == currentThread; idleStateCount = 1; } finally { lock.unlock(); } }
public void testGetMinTransaction() throws Exception { LinkedList list = new LinkedList(); for (int i = 0; i < 100; i++) { TestClientTransaction tx = new TestClientTransaction(); tx.sequenceID = new SequenceID(i); tx.txID = new TransactionID(i); tx.txnType = TxnType.NORMAL; list.add(tx); writer.addTransaction(tx); } writer.wait4AllTxns2Serialize(); assertSame( ((ClientTransaction) list.getFirst()).getSequenceID(), writer.getMinTransactionSequence()); // remove some from the middle and make sure the min is constant for (int i = 50; i < 55; i++) { ClientTransaction tx = (ClientTransaction) list.remove(i); writer.removeTransaction(tx.getTransactionID()); assertSame( ((ClientTransaction) list.getFirst()).getSequenceID(), writer.getMinTransactionSequence()); } // now remove the leastmost transaction and make sure the min increases. for (Iterator i = list.iterator(); i.hasNext(); ) { ClientTransaction tx = (ClientTransaction) i.next(); assertSame( ((ClientTransaction) list.getFirst()).getSequenceID(), writer.getMinTransactionSequence()); i.remove(); writer.removeTransaction(tx.getTransactionID()); } }
private void initiateQuery(long bssid) { LinkedList<QuerySet> queryEntries = mBssQueues.get(bssid); if (queryEntries == null) { return; } else if (queryEntries.isEmpty()) { mBssQueues.remove(bssid); return; } QuerySet querySet = queryEntries.getFirst(); QueryEntry queryEntry = querySet.peek(); if (queryEntry.bumpRetry() >= RetryCount) { QueryEntry newEntry = querySet.pop(); if (newEntry == null) { // No more entries in this QuerySet, advance to the next set. querySet.getOsuInfo().setIconStatus(OSUInfo.IconStatus.NotAvailable); queryEntries.removeFirst(); if (queryEntries.isEmpty()) { // No further QuerySet on this BSSID, drop the bucket and bail. mBssQueues.remove(bssid); return; } else { querySet = queryEntries.getFirst(); queryEntry = querySet.peek(); queryEntry.bumpRetry(); } } } mOSUManager.doIconQuery(bssid, queryEntry.getKey().getFileName()); }
/** Sorts the static LinkedList mainlineLinks in the order they appear on the freeway */ private LinkedList<Link> recursiveLinkSort(LinkedList<Link> links2) { if (links2.size() == 1) { return links2; } else { boolean swapMade = false; ListIterator<Link> itr1 = links2.listIterator(); while (itr1.hasNext()) { Link temp = itr1.next(); int tempindex = itr1.nextIndex(); // if this loop makes any switches, set the flag to true if (links2.getFirst().getUpNode().getNodeID() == temp.getDownNode().getNodeID()) { swapMade = true; links2.addFirst(temp); links2.remove(tempindex); return this.recursiveLinkSort(links2); } } if (!swapMade) { // assign last n-1 links to links3 LinkedList<Link> links3 = new LinkedList<Link>(); Link temp = links2.getFirst(); links2.removeFirst(); links3 = this.recursiveLinkSort(links2); links3.addFirst(temp); return links3; } else { return links2; } } }
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(); }
public void testWaitPolicyWithShutdownExecutor() throws Exception { assertEquals(0, SleepyTask.activeTasks.get()); // wants to wait forever, but will fail immediately executor.setRejectedExecutionHandler(new LastRejectedWaitPolicy()); executor.shutdown(); // create a task List tasks = new ArrayList(); tasks.add(new SleepyTask("rejected", 1000)); // should fail and return immediately LinkedList submitters = this.execute(tasks); assertFalse(submitters.isEmpty()); // let submitted tasks run Thread.sleep(1000); LinkedList exceptions = threadGroup.collectedExceptions(); assertEquals(1, exceptions.size()); Map.Entry threadFailure = (Map.Entry) ((Map) (exceptions.getFirst())).entrySet().iterator().next(); assertEquals(submitters.getFirst(), threadFailure.getKey()); assertEquals(RejectedExecutionException.class, threadFailure.getValue().getClass()); assertEquals(0, SleepyTask.activeTasks.get()); }
static boolean maybe(LinkedList<Item>[] buf, int d, int checkedRow, int checkedColumn) { LinkedList<Item> e; for (int row = 0; row < 9; row++) { if (checkedRow == row) continue; e = buf[row * 9 + checkedColumn]; if (e.getFirst().value == d) { return false; } for (Item item : e) { if (item.value == d && item.canbe()) { return false; } } } for (int column = 0; column < 9; column++) { if (checkedColumn == column) continue; e = buf[checkedRow * 9 + column]; if (e.getFirst().value == d) { return false; } for (Item item : e) { if (item.value == d && item.canbe()) { return false; } } } int subGridStartRow = checkedRow - checkedRow % 3; int subGridStartColumn = checkedColumn - checkedColumn % 3; for (int row = subGridStartRow; row < subGridStartRow + 3; row++) { for (int column = subGridStartColumn; column < subGridStartColumn + 3; column++) { e = buf[row * 9 + column]; if (checkedColumn == column) continue; if (e.getFirst().value == d) { return false; } for (Item item : e) { if (item.value == d && item.canbe()) { return false; } } } } return true; }
protected Object getFirst() { Object object = null; if (data.size() > 0) { object = data.getFirst(); } else if (stored.size() > 0) { object = readValue((String) stored.getFirst()); } return object; }
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; }
@Override public int readData( int track, long positionUs, MediaFormatHolder formatHolder, SampleHolder sampleHolder) { Assertions.checkState(state == STATE_ENABLED); downstreamPositionUs = positionUs; if (pendingDiscontinuity || isPendingReset()) { return NOTHING_READ; } boolean haveSamples = !sampleQueue.isEmpty(); BaseMediaChunk currentChunk = mediaChunks.getFirst(); while (haveSamples && mediaChunks.size() > 1 && mediaChunks.get(1).getFirstSampleIndex() <= sampleQueue.getReadIndex()) { mediaChunks.removeFirst(); currentChunk = mediaChunks.getFirst(); } Format format = currentChunk.format; if (!format.equals(downstreamFormat)) { notifyDownstreamFormatChanged(format, currentChunk.trigger, currentChunk.startTimeUs); } downstreamFormat = format; if (haveSamples || currentChunk.isMediaFormatFinal) { MediaFormat mediaFormat = currentChunk.getMediaFormat(); if (!mediaFormat.equals(downstreamMediaFormat)) { formatHolder.format = mediaFormat; formatHolder.drmInitData = currentChunk.getDrmInitData(); downstreamMediaFormat = mediaFormat; return FORMAT_READ; } // If mediaFormat and downstreamMediaFormat are equal but different objects then the equality // check above will have been expensive, comparing the fields in each format. We update // downstreamMediaFormat here so that referential equality can be cheaply established during // subsequent calls. downstreamMediaFormat = mediaFormat; } if (!haveSamples) { if (loadingFinished) { return END_OF_STREAM; } return NOTHING_READ; } if (sampleQueue.getSample(sampleHolder)) { boolean decodeOnly = sampleHolder.timeUs < lastSeekPositionUs; sampleHolder.flags |= decodeOnly ? C.SAMPLE_FLAG_DECODE_ONLY : 0; onSampleRead(currentChunk, sampleHolder); return SAMPLE_READ; } return NOTHING_READ; }
public boolean removeAnd(SeqCond and) { for (Iterator<LinkedList<SeqCond>> it = sequenceCondition.iterator(); it.hasNext(); ) { LinkedList<SeqCond> list = it.next(); if (list.size() == 1 && list.getFirst().id == and.id && list.getFirst().state == and.state) { sequenceCondition.remove(list); return true; } } return false; }
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; }
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); }
public final void testGetBlockListForFile() { HeaderBlock hBlock = tracker.getLatestHeaderBlockForFile(FILENAME); assertNotNull(hBlock); assertEquals(hBlock1.getBlockId(), hBlock.getBlockId()); LinkedList<Long> blocksIds = hBlock.getAssociatedDataBlockId(); assertEquals(2, blocksIds.size()); assertEquals(dBlock1.getBlockId(), blocksIds.getLast().longValue()); assertEquals(dBlock2.getBlockId(), blocksIds.getFirst().longValue()); MetaDataBlock metaBlock = hBlock.getMetaDataForDataBlock(blocksIds.getFirst()); }
// Point : Forest to Tree // // While T has more than one component // For each component C of T : // Begin with an empty set of edges S // For each vertex v in C : // Find the cheapest edge from v to a vertex outside of C, and add it to S // Add the cheapest edge in S to T public WeightUnDirectedGraph MSTBySollin() { LinkedList<WeightUnDirectedGraph> graphLinkedList = new LinkedList<>(); for (int i = 0; i < vertices.size(); i++) { graphLinkedList.add(new WeightUnDirectedGraph()); } // 각각의 vertex에 대해서 graph라고 만듦 for (int i = 0; i < vertices.size(); i++) { graphLinkedList.get(i).insertVertex(new Data(vertices.get(i).getData().id)); } int index = 0; WeightUnDirectedGraph currentGraph; // While T has more than one component: while (graphLinkedList.size() > 1) { if (index >= graphLinkedList.size()) index = 0; // For each component C of T: currentGraph = graphLinkedList.get(index); // Begin with an empty set of edges S LinkedList<Edge> edgeList = new LinkedList<>(); // For each vertex v in C: for (Vertex currentVertex : currentGraph.vertices) { // Find the cheapest edge from v to a vertex outside of C, and add it to S // 현재 큰 그래프에서 찾음 Vertex vertex = retrieveVertex(currentVertex.getData().id); for (Edge edge : vertex.getEdges()) { if (currentGraph.retrieveVertex(edge.getToVertex().getData().id) == null) insertEdgeToList(edgeList, edge); } } int graphIndex = findGraphIndex(graphLinkedList, edgeList.getFirst().getToVertex()); // Add the cheapest edge in S to T if (mergeGraph(currentGraph, graphLinkedList.get(graphIndex), edgeList.removeFirst())) graphLinkedList.remove(graphIndex); index++; } return graphLinkedList.getFirst(); }
public boolean addAnd(SeqCond and) { for (Iterator<LinkedList<SeqCond>> it = sequenceCondition.iterator(); it.hasNext(); ) { LinkedList<SeqCond> list = it.next(); if (list.size() == 1 && list.getFirst().id == and.id && list.getFirst().state == and.state) { return false; } } LinkedList<SeqCond> s = new LinkedList<SeqCond>(); s.add(and); sequenceCondition.add(s); return true; }
public static int[] maxInWindow(int[] array, int k) { if (k <= 0 || array == null || array.length == 0) { System.out.println("invalid input"); return new int[0]; } int len = array.length; int[] max = new int[len]; if (k == 1) { System.arraycopy(array, 0, max, 0, len); // 复制一份,不影响原数组 } else { LinkedList<Item> queue = new LinkedList<Item>(); for (int i = 0; i < len; i++) { Item curItem = new Item(array[i], i); if (queue.isEmpty()) { queue.addLast(curItem); } else { Item head = queue.getFirst(); int headIndex = head.getIndex(); // 如果队首元素已不在窗口内,则删除 if (headIndex < (i - k + 1)) { queue.removeFirst(); } // 插入元素 while (!queue.isEmpty()) { Item tail = queue.getLast(); int tailValue = tail.getValue(); if (tailValue < array[i]) { queue.removeLast(); if (queue.isEmpty()) { queue.addLast(curItem); break; } } else if (tailValue > array[i]) { queue.addLast(curItem); } else { break; } } } // 每次操作后,队首元素为当前窗口的最大值 if (!queue.isEmpty()) { max[i] = queue.getFirst().getValue(); } } } return max; }
@Override protected void onPostExecute(LinkedList<String> response) { if (dialog.isShowing()) dialog.dismiss(); if (response.isEmpty()) { showMessage("Could not connect to server. Please try again later."); } else if (response.getFirst().equals("failure")) { Log.e(TAG, "failure querying open challenges from server"); } else if (response.getFirst().equals("empty")) { showMessage("There are no challenges available at this time."); } else { String[] respStr = response.toArray(new String[0]); createChallengesCursor(respStr); populateChallengesList(); } }
static void printGraph(String msg, LinkedList<Item>[] buf) { System.out.print("\n================================================\n" + msg); for (int row = 0; row < 9; row++) { System.out.println("\n"); InnerFor: for (int column = 0; column < 9; column++) { System.out.print("\t"); LinkedList<Item> e = buf[row * 9 + column]; if (e.size() == 1) System.out.print("[" + e.getFirst().value + "]"); else { for (Item t : e) { if (t.status == ItemStatus.ForceOK) { System.out.print("<" + t.value + ">"); continue InnerFor; } } for (Item t : e) { if (t.status == ItemStatus.OK) { System.out.print("(" + t.value + ")"); continue InnerFor; } } for (Item t : e) { if (t.status == ItemStatus.MaybeOK) System.out.print("" + t.value + ""); } for (Item t : e) { if (t.status == ItemStatus.MaybeNot) System.out.print("-" + t.value + ""); } } } } }
/** * maintains a list of last <i>committedLog</i> or so committed requests. This is used for fast * follower synchronization. * * @param request committed request */ public void addCommittedProposal(Request request) { WriteLock wl = logLock.writeLock(); try { wl.lock(); if (committedLog.size() > commitLogCount) { committedLog.removeFirst(); minCommittedLog = committedLog.getFirst().packet.getZxid(); } if (committedLog.isEmpty()) { minCommittedLog = request.zxid; maxCommittedLog = request.zxid; } ByteArrayOutputStream baos = new ByteArrayOutputStream(); BinaryOutputArchive boa = BinaryOutputArchive.getArchive(baos); try { request.getHdr().serialize(boa, "hdr"); if (request.getTxn() != null) { request.getTxn().serialize(boa, "txn"); } baos.close(); } catch (IOException e) { LOG.error("This really should be impossible", e); } QuorumPacket pp = new QuorumPacket(Leader.PROPOSAL, request.zxid, baos.toByteArray(), null); Proposal p = new Proposal(); p.packet = pp; p.request = request; committedLog.add(p); maxCommittedLog = p.packet.getZxid(); } finally { wl.unlock(); } }
static void testObjectSensitivity1() { LinkedList<String> list1 = new LinkedList<String>(); LinkedList<String> list2 = new LinkedList<String>(); list1.add(taintedString("abcd")); // source list2.add("123"); assert (getTaint(list2.getFirst()) == 0); }
/** The sensor manager determines what all of the sensors are able to confirm. */ @Override public Environment apply(Environment t) { /* * If we have any omniscient sensors, they will be the first sensor on * the list. */ Sensor firstSensor = sensors.peek(); if (firstSensor instanceof OmniscientSensor) { return firstSensor.apply(t); } /* * Otherwise, extract the different types of sensor */ LinkedList<ProximitySensor> proximitySensors = new LinkedList<>(); for (Sensor sensor : sensors) { if (sensor instanceof ProximitySensor) { proximitySensors.add((ProximitySensor) sensor); } } /* * If we have no other sensors, throw a problem */ if (proximitySensors.size() == 0) { throw new RuntimeException("Sensor was not omniscient!"); } return proximitySensors.getFirst().apply(t); }
/** * Find the maximum weight matching of a path using dynamic programming. * * @param path a list of edges. The code assumes that the list of edges is a valid simple path, * and that is not a cycle. * @return a maximum weight matching of the path */ public Pair<Double, Set<E>> getMaximumWeightMatching(Graph<V, E> g, LinkedList<E> path) { int pathLength = path.size(); // special cases switch (pathLength) { case 0: // special case, empty path return Pair.of(Double.valueOf(0d), Collections.emptySet()); case 1: // special case, one edge E e = path.getFirst(); double eWeight = g.getEdgeWeight(e); if (comparator.compare(eWeight, 0d) > 0) { return Pair.of(eWeight, Collections.singleton(e)); } else { return Pair.of(Double.valueOf(0d), Collections.emptySet()); } } // make sure work array has enough space if (a.length < pathLength + 1) { a = new double[pathLength + 1]; } // first pass to find solution Iterator<E> it = path.iterator(); E e = it.next(); double eWeight = g.getEdgeWeight(e); a[0] = 0d; a[1] = (comparator.compare(eWeight, 0d) > 0) ? eWeight : 0d; for (int i = 2; i <= pathLength; i++) { e = it.next(); eWeight = g.getEdgeWeight(e); if (comparator.compare(a[i - 1], a[i - 2] + eWeight) > 0) { a[i] = a[i - 1]; } else { a[i] = a[i - 2] + eWeight; } } // reverse second pass to build solution Set<E> matching = new HashSet<>(); it = path.descendingIterator(); int i = pathLength; while (i >= 1) { e = it.next(); if (comparator.compare(a[i], a[i - 1]) > 0) { matching.add(e); // skip next edge if (i > 1) { e = it.next(); } i--; } i--; } // return solution return Pair.of(a[pathLength], matching); }
private boolean bfs_cirle(boolean[] visited, Map<Integer, ArrayList<Integer>> graph, int i) { LinkedList<Integer> queue = new LinkedList<>(); if (visited[i]) { return true; } visited[i] = true; queue.addLast(i); int top; List<Integer> edges; while (!queue.isEmpty()) { top = queue.getFirst(); queue.removeFirst(); edges = graph.get(top); if (edges != null) { for (int j = 0; j < edges.size(); j++) { if (visited[edges.get(j)]) { return true; } else { visited[edges.get(j)] = true; queue.add(edges.get(j)); } } } } return false; }
/** * 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); } } }
/** Specified in Node */ protected Node removeNeighbour(Node neighbour) { Iterator it = edges.iterator(); Edge next; while (it.hasNext()) { next = (Edge) it.next(); if (next.to == neighbour) { it.remove(); break; } } // collapse this node if it has degree 2 after removal of neighbour if (edges.size() == 2) { Edge e1 = (Edge) edges.getFirst(); Edge e2 = (Edge) edges.getLast(); Edge ne1, ne2; ne1 = e1.to.addNeighbour(e2.to); ne2 = e2.to.addNeighbour(e1.to); ne1.backedge = ne2; ne2.backedge = ne1; e1.to.removeNeighbour(this); return e2.to.removeNeighbour(this); } return this; }
public String getLastPath() { if (mostRecentlyUsedHistory.isEmpty()) { return System.getProperty("user.home"); } return mostRecentlyUsedHistory.getFirst(); }
@Test public void appenderStoresMessages() { MemoryAppender appender = new MemoryAppender(); BasicConfigurator.configure(appender); Logger logger = Logger.getLogger(TEST_CATEGORY); logger.setLevel(Level.ERROR); logger.error(TEST_MESSAGE); LinkedList<LoggingEvent> events = appender.getEvents(); assertEquals(1, events.size()); LoggingEvent event = events.getFirst(); assertEquals(Level.ERROR, event.getLevel()); assertEquals(TEST_CATEGORY, event.getLoggerName()); assertEquals(TEST_MESSAGE, event.getMessage()); assertEquals(TEST_LOCATION, event.getLocationInformation().getClassName()); appender.clear(); assertEquals(0, events.size()); logger.error(TEST_MESSAGE); assertEquals(1, appender.getEvents().size()); }
/** * Eat an identifier, possibly qualified (meaning that it is dotted). TODO AndyC Could create * complete identifiers (a.b.c) here rather than a sequence of them? (a, b, c) */ private SpelNodeImpl eatPossiblyQualifiedId() { LinkedList<SpelNodeImpl> qualifiedIdPieces = new LinkedList<SpelNodeImpl>(); Token node = peekToken(); while (isValidQualifiedId(node)) { nextToken(); if (node.kind != TokenKind.DOT) { qualifiedIdPieces.add(new Identifier(node.stringValue(), toPos(node))); } node = peekToken(); } if (qualifiedIdPieces.isEmpty()) { if (node == null) { raiseInternalException(expressionString.length(), SpelMessage.OOD); } raiseInternalException( node.startpos, SpelMessage.NOT_EXPECTED_TOKEN, "qualified ID", node.getKind().toString().toLowerCase()); } int pos = toPos( qualifiedIdPieces.getFirst().getStartPosition(), qualifiedIdPieces.getLast().getEndPosition()); return new QualifiedIdentifier( pos, qualifiedIdPieces.toArray(new SpelNodeImpl[qualifiedIdPieces.size()])); }
private static int getInitialY(EsbConnector connector, LinkedList<EsbNode> nodeList) { int y = 10; EObject eContainer = connector.eContainer(); if (eContainer != null) { // FIXME : Remove hard-coded values if (eContainer instanceof ProxyService || eContainer instanceof APIResource) { y = 95; // Initial y of proxy, api resource output connector } else if (eContainer instanceof Sequences) { y = 146; // Initial y of sequence output connector } else { return y; } if (nodeList.size() > 0) { EditPart editpart = getEditpart(nodeList.getFirst()); if (editpart != null) { if (!(editpart instanceof complexFiguredAbstractMediator)) { GraphicalEditPart gEditpart = (GraphicalEditPart) editpart; y = y - (gEditpart.getFigure().getPreferredSize().height / 2); } } } } return y; }