UastAbstractIter: refactor to use Option

Signed-off-by: Alexander Bezzubov <[email protected]>

Author: bzz

src/main/scala/org/bblfsh/client/v2/libuast/Libuast.scala

@@ -18,39 +18,40 @@ object Libuast {
     * It brides the gap between the contracts of a Scala iterator (.hasNext()/.next()) and
     * a native Libuast iterator (.next() == null at the end).
     * */
-  abstract class UastAbstractIter[T](var node: T, var treeOrder: Int, var iter: Long, var ctx: Long)
+  abstract class UastAbstractIter[T >:Null](var node: T, var treeOrder: Int, var iter: Long, var ctx: Long)
     extends Iterator[T] {
     private var closed = false
-    private var lookedAhead = false
-    private var nextNode: T = _
+    private var nextNode: Option[T] = None
 
-    private def lookahead(): T = {
-      lookedAhead = true
+    private def lookahead(): Option[T] = {
       val node = nativeNext(iter)
       if (node == null) {
         close()
+        None
+      } else {
+        Some(node)
       }
-      node
     }
 
     /** True only if the next element is not null */
     override def hasNext(): Boolean = {
       if (closed) {
         return false
       }
-      if (lookedAhead) {
+      if (nextNode.isDefined) {
         return true
       }
       nextNode = lookahead()
-      nextNode != null
+      nextNode.isDefined
     }
 
     override def next(): T = {
       if (hasNext()) {
-        lookedAhead = false
-        return nextNode
+        val next = nextNode.get
+        nextNode = None
+        return next
       }
-      nextNode
+      null
     }
 
     def close() = {