private void play() {
if (isReload) reloadGame();
if (isEnd || isPause) return;
addFeed();
doesEatFeed();
addRegime();
doesEatRegime();
crossBorder();
head = blocks.peekFirst();
Block newHead = new Block(head.getX() + dx[inputDirection], head.getY() + dy[inputDirection]);
Rectangle headRect = new Rectangle(head.getX(), head.getY(), 10, 10);
if (isEnd(newHead)) {
isEnd = true;
// Image image = new Image(this.getClass().getResourceAsStream("/gameOver.png"));
// ImageView imageView = new ImageView(image);
// group.getChildren().add(imageView);
// scene.setOnKeyPressed(null);
saveRecord();
showRecord();
return;
} else {
blocks.push(newHead);
rectangles.push(headRect);
blocks.pollLast();
updateGui();
}
}
private void doesEatRegime() {
if (isEnd) return;
if (Math.abs(blocks.peekFirst().getX() - regimeRectangle.getX()) < 10
&& Math.abs(blocks.peekFirst().getY() - regimeRectangle.getY()) < 10
&& System.currentTimeMillis() - currentTime <= 10000) {
regimeRectangle.setX(1200);
isRegime = false;
++score;
scoreLabel.setText(String.valueOf(score));
blocks.pollLast();
blocks.pollLast();
blocks.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
group.getChildren().remove(rectangles.peekLast());
rectangles.pollLast();
}
if (System.currentTimeMillis() - currentTime > 10000) {
regimeRectangle.setX(1200);
isRegime = false;
}
}
@Override
public void meet(Count node) throws RuntimeException {
builder.append("COUNT(");
if (node.isDistinct()) {
builder.append("DISTINCT ");
}
if (node.getArg() == null) {
// this is a weird special case where we need to expand to all variables selected in the query
// wrapped
// by the group; we cannot simply use "*" because the concept of variables is a different one
// in SQL,
// so instead we construct an ARRAY of the bindings of all variables
List<String> countVariables = new ArrayList<>();
for (SQLVariable v : parent.getVariables().values()) {
if (v.getProjectionType() == ValueType.NONE) {
Preconditions.checkState(
v.getExpressions().size() > 0, "no expressions available for variable");
countVariables.add(v.getExpressions().get(0));
}
}
builder.append("ARRAY[");
Joiner.on(',').appendTo(builder, countVariables);
builder.append("]");
} else {
optypes.push(ValueType.NODE);
node.getArg().visit(this);
optypes.pop();
}
builder.append(")");
}
// Method 2: BFS Solution
public boolean validTreeII(int n, int[][] edges) {
int[] visited = new int[n];
List<List<Integer>> adjList = new ArrayList<>();
for (int i = 0; i < n; ++i) {
adjList.add(new ArrayList<Integer>());
}
for (int[] edge : edges) {
adjList.get(edge[0]).add(edge[1]);
adjList.get(edge[1]).add(edge[0]);
}
Deque<Integer> q = new LinkedList<Integer>();
q.addLast(0);
visited[0] = 1; // vertex 0 is in the queue, being visited
while (!q.isEmpty()) {
Integer cur = q.removeFirst();
for (Integer succ : adjList.get(cur)) {
if (visited[succ] == 1) {
return false;
} // loop detected
if (visited[succ] == 0) {
q.addLast(succ);
visited[succ] = 1;
}
}
visited[cur] = 2; // visit completed
}
for (int v : visited) {
if (v == 0) {
return false;
}
} // # of connected components is not 1
return true;
}
@Test
public void Deque_addLast_AddsTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
}
@Override
public void meet(MathExpr expr) throws RuntimeException {
ValueType ot = new OPTypeFinder(expr).coerce();
if (ot == ValueType.STRING) {
if (expr.getOperator() == MathExpr.MathOp.PLUS) {
builder.append(
functionRegistry
.get(FN.CONCAT.stringValue())
.getNative(
parent.getDialect(),
new ValueExpressionEvaluator(expr.getLeftArg(), parent, ot).build(),
new ValueExpressionEvaluator(expr.getRightArg(), parent, ot).build()));
} else {
throw new IllegalArgumentException(
"operation " + expr.getOperator() + " is not supported on strings");
}
} else {
if (ot == ValueType.NODE || ot == ValueType.TERM) {
ot = ValueType.DOUBLE;
}
optypes.push(ot);
expr.getLeftArg().visit(this);
builder.append(getSQLOperator(expr.getOperator()));
expr.getRightArg().visit(this);
optypes.pop();
}
}
@Override
public void meet(ValueConstant node) throws RuntimeException {
String val = node.getValue().stringValue();
switch (optypes.peek()) {
case STRING:
case URI:
builder.append("'").append(val).append("'");
break;
case INT:
builder.append(Integer.parseInt(val));
break;
case DECIMAL:
case DOUBLE:
builder.append(Double.parseDouble(val));
break;
case BOOL:
builder.append(Boolean.parseBoolean(val));
break;
case DATE:
builder.append("'").append(sqlDateFormat.format(DateUtils.parseDate(val))).append("'");
break;
// in this case we should return a node ID and also need to make sure it actually exists
case TERM:
case NODE:
KiWiNode n = parent.getConverter().convert(node.getValue());
builder.append(n.getId());
break;
default:
throw new IllegalArgumentException("unsupported value type: " + optypes.peek());
}
}
@Test(expected = NoSuchElementException.class)
public void Deque_addLast_removeFirst_throwsIfEmpty() {
deque.addFirst("firstString");
deque.addFirst("secondString");
deque.removeLast();
deque.removeLast();
deque.removeFirst();
}
@Test
public void testAddThenRemove() {
deque.addBack(3);
assertEquals(new Integer(3), deque.removeBack());
deque.addFront(7);
assertEquals(new Integer(7), deque.removeBack());
assertTrue(deque.isEmpty());
}
@Test
public void testAddFront() {
assertEquals("<>", deque.toString());
deque.addFront(3);
deque.addFront(7);
deque.addFront(4);
assertEquals("<4, 7, 3>", deque.toString());
}
@Test
public void testAddBack() {
assertEquals("<>", deque.toString());
deque.addBack(3);
deque.addBack(7);
deque.addBack(4);
assertEquals("<3, 7, 4>", deque.toString());
}
@Test
public void testIsEmpty() {
assertTrue(deque.isEmpty());
deque.addFront(3);
assertFalse(deque.isEmpty());
deque.removeFront();
assertTrue(deque.isEmpty());
}
@Test
public void testGenericity() {
Deque<String> d = new Deque<String>();
d.addBack("a");
d.addBack("b");
d.addBack("c");
assertEquals("<a, b, c>", d.toString());
}
public void performIncludes(ModuleChain inclusionPoint, Deque<DynamicObject> moduleAncestors) {
while (!moduleAncestors.isEmpty()) {
DynamicObject mod = moduleAncestors.pop();
assert RubyGuards.isRubyModule(mod);
inclusionPoint.insertAfter(mod);
Layouts.MODULE.getFields(mod).addDependent(rubyModuleObject);
}
}
/*
* stack contains all ancestors of the node, stack.peek() is its parent.
*/
private void mutateUp(@NotNull final Deque<ChildReferenceTransient> stack, MutableNode node) {
while (!stack.isEmpty()) {
final ChildReferenceTransient parent = stack.pop();
final MutableNode mutableParent = parent.mutate(this);
mutableParent.setChild(parent.firstByte, node);
node = mutableParent;
}
}
private void prune() {
// Remove all values that are too old
TimeInterval periodAllowed = cachedPeriod.before(buffer.getLast().getTimestamp());
while (!buffer.isEmpty() && !periodAllowed.contains(buffer.getFirst().getTimestamp())) {
// Discard value
buffer.removeFirst();
}
}
@Test
public void testOneEmptyOne() {
deque.addFirst("1");
assertEquals(deque.removeFirst(), "1");
deque.addLast("2");
}
@Override
public void meet(Sum node) throws RuntimeException {
builder.append("SUM(");
optypes.push(ValueType.DOUBLE);
node.getArg().visit(this);
optypes.pop();
builder.append(")");
}
@Override
public void meet(Compare cmp) throws RuntimeException {
optypes.push(new OPTypeFinder(cmp).coerce());
cmp.getLeftArg().visit(this);
builder.append(getSQLOperator(cmp.getOperator()));
cmp.getRightArg().visit(this);
optypes.pop();
}
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() + " ");
}
@Test
public void Deque_iterator_hasNextIsFalse() {
deque.addFirst("firstString");
deque.addFirst("secondString");
Iterator<String> dequeIterator = deque.iterator();
dequeIterator.next();
dequeIterator.next();
assertFalse(dequeIterator.hasNext());
}
@Override
public void meet(SameTerm cmp) throws RuntimeException {
// covered by value binding in variables
optypes.push(ValueType.TERM);
cmp.getLeftArg().visit(this);
builder.append(" = ");
cmp.getRightArg().visit(this);
optypes.pop();
}
@Test(expected = NoSuchElementException.class)
public void Deque_iterator_throwsNoSuchElement() {
deque.addFirst("firstString");
deque.addFirst("secondString");
Iterator<String> dequeIterator = deque.iterator();
dequeIterator.next();
dequeIterator.next();
dequeIterator.next();
}
@Nullable
@Override
public DataNode<ProjectData> resolveProjectInfo(
@NotNull final ExternalSystemTaskId id,
@NotNull final String projectPath,
final boolean isPreviewMode,
@Nullable final GradleExecutionSettings settings,
@NotNull final ExternalSystemTaskNotificationListener listener)
throws ExternalSystemException, IllegalArgumentException, IllegalStateException {
final GradleProjectResolverExtension projectResolverChain;
if (settings != null) {
myHelper.ensureInstalledWrapper(id, projectPath, settings, listener);
List<ClassHolder<? extends GradleProjectResolverExtension>> extensionClasses =
settings.getResolverExtensions();
Deque<GradleProjectResolverExtension> extensions =
new ArrayDeque<GradleProjectResolverExtension>();
for (ClassHolder<? extends GradleProjectResolverExtension> holder : extensionClasses) {
final GradleProjectResolverExtension extension;
try {
extension = holder.getTargetClass().newInstance();
} catch (Throwable e) {
throw new IllegalArgumentException(
String.format(
"Can't instantiate project resolve extension for class '%s'",
holder.getTargetClassName()),
e);
}
final GradleProjectResolverExtension previous = extensions.peekLast();
if (previous != null) {
previous.setNext(extension);
}
extensions.add(extension);
}
projectResolverChain = extensions.peekFirst();
} else {
projectResolverChain = new BaseGradleProjectResolverExtension();
}
return myHelper.execute(
projectPath,
settings,
new Function<ProjectConnection, DataNode<ProjectData>>() {
@Override
public DataNode<ProjectData> fun(ProjectConnection connection) {
try {
return doResolveProjectInfo(
new ProjectResolverContext(
id, projectPath, settings, connection, listener, isPreviewMode),
projectResolverChain);
} catch (RuntimeException e) {
LOG.info("Gradle project resolve error", e);
throw projectResolverChain.getUserFriendlyError(e, projectPath, null);
}
}
});
}
final synchronized void method2835(Class348_Sub42_Sub4 class348_sub42_sub4, int i) {
for (
/**/ ; (anInt8888 ^ 0xffffffff) <= -101; anInt8888--) aClass262_8861.removeFirst(8);
if (i == 30700) {
anInt8881++;
aClass262_8861.addToFront(class348_sub42_sub4, -20180);
anInt8888++;
}
}
/**
* @param path path to first element
* @param pathTo path to second element
* @return environment in which the generic parameters in the path to the first element are bound
* to those in the path to the second element, or null type on error
*/
public static ResolvedName mapGenericParameters(
final Deque<? extends INamedElement> path, final Deque<? extends INamedElement> pathTo) {
// Construct an environment in which the current function's generic parameters
// are bound to those of the eventual override.
final Deque<List<? extends ResolvedName>> tableau =
new LinkedList<>(ResolvedName.fromNamedElement(path.getLast()).tableau());
final Iterator<? extends INamedElement> pathIt = path.descendingIterator();
while (pathIt.hasNext()) {
pathIt.next();
tableau.removeLast();
}
CachedIterator<? extends INamedElement> itPathTo = null;
CachedIterator<? extends IGenericParameter> itGPTo = null;
boolean end = false;
{
// Initialise iterators into direct override's generic parameters.
boolean foundValid = false;
itPathTo = Iterators.cached(pathTo.iterator());
while (!foundValid && itPathTo.hasItem()) {
itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator());
while (!foundValid && itGPTo.hasItem()) {
foundValid = true;
if (!foundValid) itGPTo.next();
}
if (!foundValid) itPathTo.next();
}
if (!foundValid) end = true;
}
for (final INamedElement elt : path) {
final List<ResolvedName> row = new ArrayList<>();
for (@SuppressWarnings("unused")
final IGenericParameter genericParameter : elt.genericParameters()) {
if (end) return null;
row.add(ResolvedName.fromNamedElement(itGPTo.item()));
{
// Increment iterators into direct override's generic parameters.
boolean init = true;
boolean foundValid = false;
if (!init) itPathTo = Iterators.cached(pathTo.iterator());
while (!foundValid && itPathTo.hasItem()) {
if (!init) itGPTo = Iterators.cached(itPathTo.item().genericParameters().iterator());
while (!foundValid && itGPTo.hasItem()) {
if (!init) foundValid = true;
init = false;
if (!foundValid) itGPTo.next();
}
if (!foundValid) itPathTo.next();
}
if (!foundValid) end = true;
}
}
tableau.add(row);
}
if (!end) return null;
return ResolvedName.newNameReference(path.getLast(), tableau);
}
@Test
public void testAdditionReverseOrdered() {
Deque<Integer> deque = new Deque<Integer>();
for (int i = 0; i < 10; i++) {
deque.addLast(i);
}
for (int i = 0; i < 10; i++) {
assertEquals(deque.removeFirst(), new Integer(i));
}
}
@Test(expected = NoSuchElementException.class)
public void testNextFromEmptyIterator() {
Deque<String> deque = new Deque<String>();
deque.addLast("last");
deque.addFirst("first");
Iterator<String> i = deque.iterator();
i.next();
i.next();
i.next(); // should throw exception
}
@Test(expected = UnsupportedOperationException.class)
public void testRemoveFromIterator() {
Deque<String> deque = new Deque<String>();
deque.addFirst("middle");
deque.addLast("last");
deque.addFirst("first");
Iterator<String> i = deque.iterator();
i.next();
i.remove(); // should throw exception
}
/**
* @param namedElement named element
* @return ancestors of the named element, beginning with the root namespace and ending with the
* named element itself, skipping local scopes
*/
public static Iterable<? extends INamedElement> ancestors(final INamedElement namedElement) {
final Deque<INamedElement> ancestors = new LinkedList<>();
INamedElement ancestor = namedElement;
while (membership(ancestor) != ScopeMembership.Root) {
ancestors.addFirst(ancestor);
ancestor = parentNamedElementOfScope(ancestor.parent());
}
ancestors.addFirst(ancestor);
return ancestors;
}
