public static void main(String[] args) {
Deque<Integer> di = new Deque<Integer>();
fillTest(di);
print(di);
while (di.size() != 0) printnb(di.removeFirst() + " ");
print();
fillTest(di);
while (di.size() != 0) printnb(di.removeLast() + " ");
}
public void run() {
Deque<VisitingContext> stack = new ArrayDeque<>();
stack.add(new VisitingContext(rootNode));
boolean goOn = stack.peek().hasNext();
if (goOn) {
do {
Map.Entry<String, JsonValue> current = stack.peek().nextElement();
if (!(current.getValue() instanceof JsonStructure)) {
String key = stack.peek().getNSPrefix() + current.getKey();
String value = null;
JsonValue jsonValue = current.getValue();
switch (jsonValue.getValueType()) {
case NULL:
value = null;
break;
case FALSE:
value = Boolean.FALSE.toString();
break;
case TRUE:
Boolean.TRUE.toString();
break;
case NUMBER:
value = jsonValue.toString();
break;
case STRING:
value = ((JsonString) jsonValue).getString();
break;
default:
throw new ConfigException("Internal failure while processing JSON document.");
}
targetStore.put(key, value);
} else if (current.getValue() instanceof JsonObject) {
String key = stack.peek().getNSPrefix() + current.getKey();
JsonObject node = (JsonObject) current.getValue();
stack.push(new VisitingContext(node, key));
} else if (current.getValue() instanceof JsonArray) {
throw new ConfigException("Arrays are not supported at the moment.");
} else {
throw new ConfigException("Internal failure while processing JSON document.");
}
goOn = stack.peek().hasNext();
while (!goOn && stack.size() > 0) {
stack.remove();
goOn = (stack.size() > 0) && stack.peek().hasNext();
}
} while (goOn);
}
}
public static void main(String[] args) {
Deque<Integer> ints = new Deque<Integer>();
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(1);
assert ints.size() == 1;
assert !ints.isEmpty();
int val = ints.removeFirst();
assert val == 1;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(2);
assert ints.size() == 1;
assert !ints.isEmpty();
val = ints.removeLast();
assert val == 2;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(3);
ints.addFirst(2);
ints.addFirst(1);
ints.addLast(4);
ints.addLast(5);
ints.addLast(6);
assert ints.size() == 6;
assert !ints.isEmpty();
for (int value : ints) {
StdOut.print(value + " ");
}
StdOut.println();
while (!ints.isEmpty()) {
StdOut.println(ints.removeLast());
}
assert ints.size() == 0;
assert ints.isEmpty();
for (int i = 0; i < 10; ++i) {
ints.addFirst(i);
}
for (int i = 0; i < 10; ++i) {
assert ints.size() == 10 - i;
ints.removeLast();
}
assert ints.size() == 0;
}
@Test
public void testSize() {
assertEquals(0, deque.size());
deque.addFront(3);
assertEquals(1, deque.size());
deque.addFront(7);
assertEquals(2, deque.size());
deque.removeFront();
assertEquals(1, deque.size());
deque.removeFront();
assertEquals(0, deque.size());
}
@Test
public void testRemove() {
Deque<String> deque = new Deque<String>();
deque.addFirst(new String("test"));
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
deque.removeLast();
deque.removeFirst();
assertTrue(deque.size() == 1);
deque.removeLast();
assertTrue(deque.size() == 0);
}
@Test
public void Deque_addLast_removeLast_AddsRemovesTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
String returnedString = deque.removeLast();
assertEquals(returnedString, "secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 1);
returnedString = deque.removeLast();
assertEquals(returnedString, "firstString");
assertTrue(deque.isEmpty());
assertEquals(deque.size(), 0);
}
@Test
public void Deque_addLast_AddsTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
}
@Test
public void testAddition() {
Deque<String> deque = new Deque<String>();
deque.addFirst(new String("test"));
assertFalse(deque.isEmpty());
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
assertEquals(deque.size(), 3);
}
void playPrevious() {
if (playStack.size() < 2) return;
System.out.println("------------");
for (PlaylistAndTrack pnt : playStack) {
System.out.println(pnt.track.getTitle());
}
playStack.removeFirst();
PlaylistAndTrack prevPlaylistAndTrack = playStack.removeFirst();
playlistsView.getSelectionModel().select(prevPlaylistAndTrack.playlist);
tracksView.getSelectionModel().select(prevPlaylistAndTrack.track);
tracksView.scrollTo(tracksView.getSelectionModel().getSelectedIndex());
playTrack(prevPlaylistAndTrack.track);
}
private List<List<Integer>> help1(TreeNode root) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
if (root == null) {
return res;
}
Deque<TreeNode> current = new LinkedList<>();
Deque<TreeNode> next = new LinkedList<>();
boolean isOdd = true;
current.add(root);
while (!current.isEmpty()) {
int size = current.size();
List<Integer> level = new LinkedList<Integer>();
if (isOdd) {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeFirst();
level.add(top.val);
if (top.left != null) {
next.addLast(top.left);
}
if (top.right != null) {
next.addLast(top.right);
}
}
} else {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeLast();
level.add(top.val);
if (top.right != null) {
next.addFirst(top.right);
}
if (top.left != null) {
next.addFirst(top.left);
}
}
}
isOdd = !isOdd;
current = next;
res.add(level);
}
return res;
}
/**
* Emulates throwing an exception from method call. Should be inserted into all places where
* method or closure is called, because it can throw something unexpectedly
*/
private void visitCall(GroovyPsiElement call) {
// optimization: don't add call instruction if there is no catch or finally block in the context
if (myCaughtExceptionInfos.size() <= 0 && myFinallyCount <= 0) {
return;
}
final InstructionImpl instruction = new ThrowingInstruction(call);
addNodeAndCheckPending(instruction);
for (ExceptionInfo info : myCaughtExceptionInfos) {
info.myThrowers.add(instruction);
}
if (myFinallyCount > 0) {
addPendingEdge(null, instruction);
}
}
@NotNull
private Set<VirtualFile> pollFilesToResolve() {
Set<VirtualFile> set;
synchronized (filesToResolve) {
int queuedSize = filesToResolve.size();
set = new LinkedHashSet<VirtualFile>(queuedSize);
// someone might have cleared this bit to mark file as processed
for (VirtualFile file : filesToResolve) {
if (fileIsInQueue.clear(getAbsId(file))) {
set.add(file);
}
}
filesToResolve.clear();
}
return countAndMarkUnresolved(set, false);
}
@Test
public void test10() {
deque = new Deque<String>();
deque.addFirst("1");
deque.addFirst("2");
deque.addFirst("3");
deque.addFirst("4");
assertEquals(deque.removeLast(), "1");
assertEquals(deque.removeFirst(), "4");
deque.addLast("7");
assertEquals(deque.removeLast(), "7");
assertEquals(deque.removeLast(), "2");
assertEquals(deque.removeLast(), "3");
assertEquals(deque.size(), 0);
}
public static QuantileDigest deserialize(DataInput input) {
try {
double maxError = input.readDouble();
double alpha = input.readDouble();
QuantileDigest result = new QuantileDigest(maxError, alpha);
result.landmarkInSeconds = input.readLong();
result.min = input.readLong();
result.max = input.readLong();
result.totalNodeCount = input.readInt();
Deque<Node> stack = new ArrayDeque<>();
for (int i = 0; i < result.totalNodeCount; i++) {
int flags = input.readByte();
Node node = deserializeNode(input);
if ((flags & Flags.HAS_RIGHT) != 0) {
node.right = stack.pop();
}
if ((flags & Flags.HAS_LEFT) != 0) {
node.left = stack.pop();
}
stack.push(node);
result.weightedCount += node.weightedCount;
if (node.weightedCount >= ZERO_WEIGHT_THRESHOLD) {
result.nonZeroNodeCount++;
}
}
if (!stack.isEmpty()) {
Preconditions.checkArgument(
stack.size() == 1, "Tree is corrupted. Expected a single root node");
result.root = stack.pop();
}
return result;
} catch (IOException e) {
throw Throwables.propagate(e);
}
}
public static void main(String[] args) {
Deque<String> Ds = new LinkedDeque<String>();
Ds.pushLeft("Hello");
Ds.pushRight("KevinRight");
Ds.pushLeft("KevinLeft");
System.out.println("Three Pushes - " + Ds.toString());
Ds.popLeft();
System.out.println("Popped Left - " + Ds.toString());
Ds.pushRight("188");
System.out.println("Push Right - " + Ds.toString());
Ds.popRight();
System.out.println("Pop Right - " + Ds.toString());
System.out.println(Ds.toString());
Ds.pushRight("KevinRight2");
System.out.println(Ds.toString() + " Stack Size: " + Ds.size());
Ds.popLeft();
Ds.popLeft();
System.out.println("Popping until empty: " + Ds.toString());
// Ds.popRight(); // Uncomment for error messages.
}
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ret = new ArrayList<>();
if (root != null) {
Deque<TreeNode> queue = new ArrayDeque<>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> row = new ArrayList<>();
int levelcount = queue.size();
for (int i = 0; i < levelcount; i++) {
TreeNode tn = queue.poll();
if (tn.left != null) {
queue.offer(tn.left);
}
if (tn.right != null) {
queue.offer(tn.right);
}
row.add(tn.val);
}
ret.add(row);
}
}
return ret;
}
@Test
public void Deque_size_returns0() {
assertEquals(deque.size(), 0);
}
public int getSegmentCount() {
return segments.size();
}
// {{{ trimToLimit() method
private static void trimToLimit(Deque<Entry> list) {
int max = jEdit.getIntegerProperty("recentFiles", 50);
while (list.size() > max) list.removeLast();
} // }}}
@Test
public void Deque_addLast_AddsOne() {
deque.addLast("firstString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 1);
}
void pushToPlayStack(Playlist p, Track t) {
if (playStack.size() > 10000) {
playStack.removeLast();
}
playStack.push(new PlaylistAndTrack(p, t));
}
@Override
public int getQueueSize() {
synchronized (filesToResolve) {
return filesToResolve.size();
}
}
@Test
public void testEmpty() {
assertEquals(deque.size(), 0);
}
