Merge pull request #42 from CloudCoders/iterator

Iterator

Author: Cotel

src/main/kotlin/oop/Iterator/BackwardsIterator.kt

@@ -0,0 +1,20 @@
+package oop.Iterator
+
+class BackwardsIterator<T>(list: MutableList<T>): NormalIterator<T>(list) {
+  override fun first(): T? {
+    index = list.size - 1
+    return get()
+  }
+
+  override fun hasNext(): Boolean = index - 1 > -1
+
+  override fun hasPrev(): Boolean = this.list.size > index + 1
+
+  override fun nextIndex(): Int = if(index > -1) index - 1 else -1
+
+  override fun prevIndex(): Int = if(index > this.list.size) index +1 else -1
+
+  override fun next(): T? = if (hasNext()) list[index--] else throw NoSuchElementException()
+
+  override fun prev(): T? = if (hasPrev()) list[index++] else throw NoSuchElementException()
+}

src/main/kotlin/oop/Iterator/Iterable.kt

@@ -0,0 +1,7 @@
+package oop.Iterator
+
+interface Iterable<T> {
+  fun getNormalIterator(): Iterator<T>
+  fun getBackwardsIterator(): Iterator<T>
+}
+

src/main/kotlin/oop/Iterator/Iterator.kt

@@ -0,0 +1,16 @@
+package oop.Iterator
+
+interface Iterator<T> {
+  fun first(): T?
+  fun next(): T?
+  fun prev(): T?
+  fun hasNext():Boolean
+  fun hasPrev(): Boolean
+  fun nextIndex(): Int
+  fun prevIndex(): Int
+  fun set(element: T)
+  fun get() : T
+  fun <B> map(res: (T) -> B): MutableList<B>
+  fun forEach(res: (T) -> Unit)
+  fun filter(res: (T) -> Boolean): MutableList<T>
+}

src/main/kotlin/oop/Iterator/NormalIterator.kt

@@ -0,0 +1,60 @@
+package oop.Iterator
+
+open class NormalIterator<T>(val list: MutableList<T>) : Iterator<T> {
+  protected var index = 0
+
+  override fun first(): T? {
+    index = 0
+    return get()
+  }
+
+  override fun hasNext(): Boolean = this.list.size > index + 1
+
+  override fun hasPrev(): Boolean = index - 1 > -1
+
+  override fun nextIndex(): Int = if (index > this.list.size) index + 1 else -1
+
+  override fun prevIndex(): Int = if (index > -1) index - 1 else -1
+
+  override fun next(): T? = if (hasNext()) list[index++] else throw NoSuchElementException()
+
+  override fun prev(): T? = if (hasPrev()) list[index--] else throw NoSuchElementException()
+
+  override fun set(element: T) {
+    list[index] = element
+  }
+
+  override fun get() = list[index]
+
+  override fun <B> map(res: (T) -> B): MutableList<B> {
+    val res = ArrayList<B>(list.size)
+    first()
+    while (hasNext()) res.add(res(next()!!))
+    res.add(res(get()))
+    first()
+    return res
+  }
+
+  override fun forEach(res: (T) -> Unit) {
+    first()
+    while (hasNext()) {
+      res(next()!!)
+    }
+    res(get()!!)
+
+  }
+
+  override fun filter(res: (T) -> Boolean): MutableList<T> {
+    val res = ArrayList<T>()
+    first()
+
+    while (hasNext()) {
+
+      if (res((get()!!))) res.add(next()!!)
+      else next()
+    }
+    return res
+  }
+
+
+}

src/main/kotlin/oop/Iterator/TypeIterator.kt

@@ -0,0 +1,5 @@
+package oop.Iterator
+
+enum class TypeIterator {
+  NORMAL, BACKWARDS, RANDOM
+}

src/test/kotlin/oop/Iterator/BackwardsIteratorShould.kt

@@ -0,0 +1,26 @@
+package oop.Iterator
+
+
+import org.hamcrest.CoreMatchers.`is`
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.Test
+
+class BackwardsIteratorShould {
+  private val list = mutableListOf("10", "12", "15", "29", "30", "36")
+  private val iterator: Iterator<String> = BackwardsIterator(list)
+
+  @Test
+  fun `Return last item of collection when call`(){
+    assertThat(iterator.first(),`is`("36"))
+  }
+
+  @Test
+  fun `Iterate list from back to start`(){
+    var res = ""
+    iterator.first()
+    iterator.forEach {
+      res += "$it,"
+    }
+    assertThat(res, `is`("36,30,29,15,12,10,"))
+  }
+}

src/test/kotlin/oop/Iterator/IteratorShould.kt

@@ -0,0 +1,56 @@
+package oop.Iterator
+
+import org.hamcrest.CoreMatchers.`is`
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.Test
+
+class IteratorShould {
+  private val list = mutableListOf("10", "12", "15", "29", "30", "36")
+  private val iterator: Iterator<String> = NormalIterator(list)
+
+  @Test
+  fun `Return first element with first`() {
+    assertThat(iterator.first(), `is`("10"))
+  }
+
+  @Test
+  fun `Return fourth element doing first-next-next-next`() {
+    iterator.first()
+    iterator.next()
+    iterator.next()
+    iterator.next()
+    assertThat(iterator.get(), `is`("29"))
+  }
+
+  @Test(expected = NoSuchElementException::class)
+  fun `Throw NoSuchElementException if element don't have next `() {
+    iterator.first()
+    (1..7).forEach { iterator.next() }
+  }
+
+  @Test
+  fun `Return -1 when ask to prev index in first element`() {
+    iterator.first()
+    assertThat(iterator.prevIndex(), `is`(-1))
+  }
+
+
+  @Test
+  fun `Transform all elements of a list when using map`() {
+    val transformList = iterator.map { it.toInt() }
+    assertThat(transformList, `is`(listOf(10, 12, 15, 29, 30, 36)))
+  }
+
+  @Test
+  fun `Filter list with criterion using filter`() {
+    val filterList = iterator.filter { it.contains("1") }
+    assertThat(filterList, `is`(listOf("10", "12", "15")))
+  }
+
+  @Test
+  fun `Apply function to all elements`() {
+    var res = 0
+    iterator.forEach { res += it.toInt() }
+    assertThat(res, `is`(132))
+  }
+}