Samodzielna część

.gitignore

@@ -0,0 +1,9 @@
+# Ignorowanie folderów i plików generowanych przez narzędzia i IDE
+/bin/
+/target/
+/.idea/
+*.iml
+
+# Ignorowanie plików wygenerowanych przez systemy operacyjne
+Thumbs.db
+ehthumbs.db

pom.xml

@@ -29,5 +29,11 @@
       		<version>4.12</version>
       		<scope>test</scope>
     	</dependency>
-  	</dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>RELEASE</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
 </project>

src/main/java/edu/kis/vh/nursery/DefaultCountingOutRhymer.java

@@ -0,0 +1,41 @@
+package edu.kis.vh.nursery;
+
+public class DefaultCountingOutRhymer {
+
+    private static final int NUMBERS_ARRAY_SIZE = 12;
+    private static final int TOTAL_INIT_SIZE = -1;
+    private static final int RETURN_VALUE = -1;
+    private int[] numbers = new int[NUMBERS_ARRAY_SIZE];
+    // TODO: Move getTotal() method below the total variable declaration for better readability
+    public int getTotal() {
+        return total;
+    }
+
+    private int total = TOTAL_INIT_SIZE;
+
+    public void countIn(int in) {
+        if (!isFull())
+            numbers[++total] = in;
+    }
+
+    public boolean callCheck() {
+        return total == TOTAL_INIT_SIZE;
+    }
+
+    public boolean isFull() {
+        return total == NUMBERS_ARRAY_SIZE + TOTAL_INIT_SIZE;
+    }
+
+    protected int peekaboo() {
+        if (callCheck())
+            return RETURN_VALUE;
+        return numbers[total];
+    }
+
+    public int countOut() {
+        if (callCheck())
+            return RETURN_VALUE;
+        return numbers[total--];
+    }
+
+}

src/main/java/edu/kis/vh/nursery/FIFORhymer.java

@@ -1,21 +1,21 @@
 package edu.kis.vh.nursery;
 
-public class FIFORhymer extends defaultCountingOutRhymer {
+public class FIFORhymer extends DefaultCountingOutRhymer {
+
+    private DefaultCountingOutRhymer temp = new DefaultCountingOutRhymer();
 
-    public defaultCountingOutRhymer temp = new defaultCountingOutRhymer();
-
     @Override
     public int countOut() {
         while (!callCheck())
-            
-        temp.countIn(super.countOut());
-        
+
+            temp.countIn(super.countOut());
+
         int ret = temp.countOut();
-        
+
         while (!temp.callCheck())
-            
-        countIn(temp.countOut());
-        
+
+            countIn(temp.countOut());
+
         return ret;
     }
-}
+}

src/main/java/edu/kis/vh/nursery/HanoiRhymer.java

@@ -1,17 +1,18 @@
 package edu.kis.vh.nursery;
 
-public class HanoiRhymer extends defaultCountingOutRhymer {
+public class HanoiRhymer extends DefaultCountingOutRhymer {
 
-int totalRejected = 0;
+    private int totalRejected = 0;
 
-    public int reportRejected() {
+    int reportRejected() {
         return totalRejected;
     }
 
+    @Override
     public void countIn(int in) {
-    if (!callCheck() && in > peekaboo())
+        if (!callCheck() && in > peekaboo())
             totalRejected++;
-            else
-                super.countIn(in);
+        else
+            super.countIn(in);
     }
 }

src/main/java/edu/kis/vh/nursery/factory/DefaultRhymersFactory.java

@@ -1,29 +1,28 @@
 package edu.kis.vh.nursery.factory;
 
-import edu.kis.vh.nursery.defaultCountingOutRhymer;
+import edu.kis.vh.nursery.DefaultCountingOutRhymer;
 import edu.kis.vh.nursery.FIFORhymer;
 import edu.kis.vh.nursery.HanoiRhymer;
-import edu.kis.vh.nursery.factory.Rhymersfactory;
 
 public class DefaultRhymersFactory implements Rhymersfactory {
 
     @Override
-    public defaultCountingOutRhymer GetStandardRhymer() {
-        return new defaultCountingOutRhymer();
+    public DefaultCountingOutRhymer getStandardRhymer() {
+        return new DefaultCountingOutRhymer();
     }
 
     @Override
-    public defaultCountingOutRhymer GetFalseRhymer() {
-        return new defaultCountingOutRhymer();
+    public DefaultCountingOutRhymer getFalseRhymer() {
+        return new DefaultCountingOutRhymer();
     }
 
     @Override
-    public defaultCountingOutRhymer GetFIFORhymer() {
+    public DefaultCountingOutRhymer getFIFORhymer() {
         return new FIFORhymer();
     }
 
     @Override
-    public defaultCountingOutRhymer GetHanoiRhymer() {
+    public DefaultCountingOutRhymer getHanoiRhymer() {
         return new HanoiRhymer();
     }
 

src/main/java/edu/kis/vh/nursery/factory/Rhymersfactory.java

@@ -1,15 +1,15 @@
 package edu.kis.vh.nursery.factory;
 
-import edu.kis.vh.nursery.defaultCountingOutRhymer;
-
-    public interface Rhymersfactory {
-    
-        public defaultCountingOutRhymer GetStandardRhymer();
-        
-        public defaultCountingOutRhymer GetFalseRhymer();
-        
-        public defaultCountingOutRhymer GetFIFORhymer();
-        
-        public defaultCountingOutRhymer GetHanoiRhymer();
-        
-    }
+import edu.kis.vh.nursery.DefaultCountingOutRhymer;
+
+public interface Rhymersfactory {
+
+    public DefaultCountingOutRhymer getStandardRhymer();
+
+    public DefaultCountingOutRhymer getFalseRhymer();
+
+    public DefaultCountingOutRhymer getFIFORhymer();
+
+    public DefaultCountingOutRhymer getHanoiRhymer();
+
+}

src/main/java/edu/kis/vh/nursery/list/IntLinkedList.java

@@ -1,10 +1,35 @@
 package edu.kis.vh.nursery.list;
 
+/**
+ * The IntLinkedList class represents a doubly linked list of integers.
+ * It supports basic operations such as push, pop, and checking if the list is empty or full.
+ */
 public class IntLinkedList {
 
-    Node last;
-    int i;
+    /**
+     * The constant value returned when an operation fails.
+     */
+    public static final int returnValue = -1;
 
+    /**
+     * The last node in the linked list.
+     */
+    private Node last;
+
+    /**
+     * An integer used for various purposes (currently unused).
+     */
+
+    // TODO: Remove unused variable 'i' if it's not needed in the future
+    private int i;
+
+    /**
+     * Pushes a new integer onto the top of the linked list.
+     * If the list is empty, creates a new node as the last element.
+     * Otherwise, adds the new node to the end of the list.
+     *
+     * @param i the integer to be added to the list
+     */
     public void push(int i) {
         if (last == null)
             last = new Node(i);
@@ -15,26 +40,78 @@ public void push(int i) {
         }
     }
 
+    /**
+     * Checks if the linked list is empty.
+     *
+     * @return true if the list is empty, false otherwise
+     */
     public boolean isEmpty() {
         return last == null;
     }
 
+    /**
+     * Checks if the linked list is full.
+     * This implementation always returns false since the list is dynamically sized.
+     *
+     * @return false always, as the list cannot be full
+     */
     public boolean isFull() {
         return false;
     }
 
+    /**
+     * Returns the value of the last element in the list without removing it.
+     * If the list is empty, returns returnValue.
+     *
+     * @return the value of the last element, or returnValue if the list is empty
+     */
     public int top() {
         if (isEmpty())
-            return -1;
+            return returnValue;
         return last.value;
     }
 
+    /**
+     * Removes and returns the value of the last element in the list.
+     * If the list is empty, returns returnValue.
+     *
+     * @return the value of the last element, or returnValue if the list is empty
+     */
     public int pop() {
         if (isEmpty())
-            return -1;
+            return returnValue;
         int ret = last.value;
         last = last.prev;
         return ret;
     }
 
+    /**
+     * The Node class represents a node in a doubly linked list.
+     */
+    private class Node {
+        /**
+         * The value stored in the node.
+         */
+        private int value;
+
+        /**
+         * A reference to the previous node in the list.
+         */
+        private Node prev;
+
+        /**
+         * A reference to the next node in the list.
+         */
+        private Node next;
+
+        /**
+         * Creates a new node with the specified value.
+         *
+         * @param i the value to be stored in the node
+         */
+        private Node(int i) {
+            value = i;
+        }
+    }
+
 }