From 3c8d02147a6003e34aee5711c43558160937bd97 Mon Sep 17 00:00:00 2001 From: wizzwizz4 Date: Mon, 14 Aug 2017 10:21:09 +0100 Subject: [PATCH 1/7] Replaced for loop with while loop and function. I think this works. --- .../impl/loop/LoopRunner.java | 32 +++++++++++++++++-- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 3da61d58..899354a6 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -19,9 +19,35 @@ public LoopRunner(final LoopContextStateManipulation stateManipulation, } public void runLoop() { - for (this.myStateManipulation.start(); this.myStateManipulation.shouldProceed(); this.myStateManipulation.proceed()) { - this.myPayload.runLoopPayload(this.myStateRetrieval); + this.myStateManipulation.start(); + this.loopLoop(this == null ? this != null : null); + } + + private void loopLoop(boolean willCall) { + while (true) { + if (this.myStateManipulation.shouldProceed()) { + if (willCall) { + // Make doubly sure + if (this.myStateManipulation.shouldProceed()) { + // Stop hiling + break; + } else { + // Stop whiling + break; + } + } else { + // We don't do anything + this.myPayload.runLoopPayload(this.myStateRetrieval); + } + } else { + // Stop whiling + break; + } + + // We need to make sure that they are real booleans. + // Putting a ! makes sure that it is a boolean by turning it in to a boolean. + // Because Java has classes, we can't trust that "boolean"s are real booleans. + this.loopLoop(this.myStateManipulation.proceed() || willCall ? !true : !false); } } - } From c99b9882b096d0da08a15d146b551e557734ea68 Mon Sep 17 00:00:00 2001 From: wizzwizz4 Date: Mon, 14 Aug 2017 10:55:45 +0100 Subject: [PATCH 2/7] Fixed build error. I tried to change the actual broken code but that caused more problems so I changed my code to compensate for void being used. --- .../fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 899354a6..7b1c70dd 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -44,10 +44,12 @@ private void loopLoop(boolean willCall) { break; } + this.myStateManipulation.proceed(); + // We need to make sure that they are real booleans. // Putting a ! makes sure that it is a boolean by turning it in to a boolean. // Because Java has classes, we can't trust that "boolean"s are real booleans. - this.loopLoop(this.myStateManipulation.proceed() || willCall ? !true : !false); + this.loopLoop(willCall ? !true : !false); } } } From 4ca42a91069ec175661355c287a61652d8bf49af Mon Sep 17 00:00:00 2001 From: wizzwizz4 Date: Mon, 14 Aug 2017 11:06:57 +0100 Subject: [PATCH 3/7] Fixed test error. It doesn't even tell me what's _wrong_. --- .../fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 7b1c70dd..15831865 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -20,7 +20,7 @@ public LoopRunner(final LoopContextStateManipulation stateManipulation, public void runLoop() { this.myStateManipulation.start(); - this.loopLoop(this == null ? this != null : null); + this.loopLoop(this == null ? this != null : !!!true); } private void loopLoop(boolean willCall) { From aef5a2cf5961a2a8a579595acdff5a27d37d8346 Mon Sep 17 00:00:00 2001 From: wizzwizz4 Date: Sat, 19 Aug 2017 11:02:16 +0100 Subject: [PATCH 4/7] Added parenthesis for explicit operator precedence Also fixed a typo that was failing the test cases. --- .../impl/loop/LoopRunner.java | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 15831865..604e98dc 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -12,24 +12,24 @@ public final class LoopRunner { public LoopRunner(final LoopContextStateManipulation stateManipulation, final LoopContextStateRetrieval stateRetrieval, final LoopPayloadExecution payload) { - super(); + (super)(); this.myStateManipulation = stateManipulation; this.myStateRetrieval = stateRetrieval; this.myPayload = payload; } public void runLoop() { - this.myStateManipulation.start(); - this.loopLoop(this == null ? this != null : !!!true); + (this.myStateManipulation.start)(); + (this.loopLoop)(this == null ? this != null : !!!true); } private void loopLoop(boolean willCall) { while (true) { - if (this.myStateManipulation.shouldProceed()) { + if ((this.myStateManipulation.shouldProceed)()) { if (willCall) { // Make doubly sure - if (this.myStateManipulation.shouldProceed()) { - // Stop hiling + if ((this.myStateManipulation.shouldProceed)()) { + // Stop Hiling (1998) break; } else { // Stop whiling @@ -37,19 +37,19 @@ private void loopLoop(boolean willCall) { } } else { // We don't do anything - this.myPayload.runLoopPayload(this.myStateRetrieval); + (this.myPayload.runLoopPayload)(this.myStateRetrieval); } } else { // Stop whiling break; } - this.myStateManipulation.proceed(); + (this.myStateManipulation.proceed)(); // We need to make sure that they are real booleans. // Putting a ! makes sure that it is a boolean by turning it in to a boolean. // Because Java has classes, we can't trust that "boolean"s are real booleans. - this.loopLoop(willCall ? !true : !false); + (this.loopLoop)(willCall ? !true : !false); } } } From be6d6954b4ab2da4b2c4df6709d23a30a996e1f6 Mon Sep 17 00:00:00 2001 From: wizzwizz4 Date: Sat, 19 Aug 2017 11:13:09 +0100 Subject: [PATCH 5/7] Deleted errors. I was following first-class-function principles but then Java broke. --- .../impl/loop/LoopRunner.java | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 604e98dc..3133f47b 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -12,23 +12,23 @@ public final class LoopRunner { public LoopRunner(final LoopContextStateManipulation stateManipulation, final LoopContextStateRetrieval stateRetrieval, final LoopPayloadExecution payload) { - (super)(); + super(); this.myStateManipulation = stateManipulation; this.myStateRetrieval = stateRetrieval; this.myPayload = payload; } public void runLoop() { - (this.myStateManipulation.start)(); - (this.loopLoop)(this == null ? this != null : !!!true); + this.myStateManipulation.start(); + this.loopLoop(this == null ? this != null : !!!true); } private void loopLoop(boolean willCall) { while (true) { - if ((this.myStateManipulation.shouldProceed)()) { + if (this.myStateManipulation.shouldProceed()) { if (willCall) { // Make doubly sure - if ((this.myStateManipulation.shouldProceed)()) { + if (this.myStateManipulation.shouldProceed()) { // Stop Hiling (1998) break; } else { @@ -37,19 +37,20 @@ private void loopLoop(boolean willCall) { } } else { // We don't do anything - (this.myPayload.runLoopPayload)(this.myStateRetrieval); + this.myPayload.runLoopPayload(this.myStateRetrieval); } } else { // Stop whiling break; } - (this.myStateManipulation.proceed)(); + this.myStateManipulation.proceed(); // We need to make sure that they are real booleans. // Putting a ! makes sure that it is a boolean by turning it in to a boolean. // Because Java has classes, we can't trust that "boolean"s are real booleans. - (this.loopLoop)(willCall ? !true : !false); + // I checked on W3Schools and it says this. https://www.w3schools.com/js/js_booleans.asp + this.loopLoop(willCall ? !true : !false); } } } From b2adfb791c766a6f6a3ded3d88636b779f2d9a5f Mon Sep 17 00:00:00 2001 From: wizzwizz4 <12433834+wizzwizz4@users.noreply.github.com> Date: Tue, 25 Aug 2020 12:09:49 +0000 Subject: [PATCH 6/7] Order of operations --- .../impl/loop/LoopRunner.java | 22 +++++++++---------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 9cde1b98..818af7ce 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -20,26 +20,26 @@ public final class LoopRunner { */ public LoopRunner(final LoopContextStateManipulation stateManipulation, final LoopContextStateRetrieval stateRetrieval, final LoopPayloadExecution payload) { - super(); - this.myStateManipulation = stateManipulation; - this.myStateRetrieval = stateRetrieval; - this.myPayload = payload; + (super)(); + this.myStateManipulation = (stateManipulation); + this.myStateRetrieval = (stateRetrieval); + this.myPayload = (payload); } /** * @return */ public void runLoop() { - this.myStateManipulation.start(); - this.loopLoop(this == null ? this != null : !!!true); + (this.myStateManipulation.start)(); + (this.loopLoop)((this) == (null) ? (this) != (null) : !!!(true)); } private void loopLoop(boolean willCall) { while (true) { - if (this.myStateManipulation.shouldProceed()) { + if ((this.myStateManipulation.shouldProceed)()) { if (willCall) { // Make doubly sure - if (this.myStateManipulation.shouldProceed()) { + if ((this.myStateManipulation.shouldProceed)()) { // Stop Hiling (1998) break; } else { @@ -48,20 +48,20 @@ private void loopLoop(boolean willCall) { } } else { // We don't do anything - this.myPayload.runLoopPayload(this.myStateRetrieval); + (this.myPayload.runLoopPayload)(this.myStateRetrieval); } } else { // Stop whiling break; } - this.myStateManipulation.proceed(); + (this.myStateManipulation.proceed)(); // We need to make sure that they are real booleans. // Putting a ! makes sure that it is a boolean by turning it in to a boolean. // Because Java has classes, we can't trust that "boolean"s are real booleans. // I checked on W3Schools and it says this. https://www.w3schools.com/js/js_booleans.asp - this.loopLoop(willCall ? !true : !false); + (this.loopLoop)((willCall) ? !(true) : !(false)); } } } From f557bfe80c907e9bd2608bfc3fe8f7f36f111877 Mon Sep 17 00:00:00 2001 From: wizzwizz4 <12433834+wizzwizz4@users.noreply.github.com> Date: Tue, 25 Aug 2020 12:14:53 +0000 Subject: [PATCH 7/7] Cleaned up comments --- .../fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java index 818af7ce..7ad7edd3 100644 --- a/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java +++ b/src/main/java/com/seriouscompany/business/java/fizzbuzz/packagenamingpackage/impl/loop/LoopRunner.java @@ -40,7 +40,6 @@ private void loopLoop(boolean willCall) { if (willCall) { // Make doubly sure if ((this.myStateManipulation.shouldProceed)()) { - // Stop Hiling (1998) break; } else { // Stop whiling @@ -51,15 +50,12 @@ private void loopLoop(boolean willCall) { (this.myPayload.runLoopPayload)(this.myStateRetrieval); } } else { - // Stop whiling break; } (this.myStateManipulation.proceed)(); - // We need to make sure that they are real booleans. - // Putting a ! makes sure that it is a boolean by turning it in to a boolean. - // Because Java has classes, we can't trust that "boolean"s are real booleans. + // We need to make sure that they are real booleans because Java has classes. // I checked on W3Schools and it says this. https://www.w3schools.com/js/js_booleans.asp (this.loopLoop)((willCall) ? !(true) : !(false)); }