Makes TreeOrder and UastFormat types with implicits

This makes possible, as explained in package.scala file, to use a method
f(fmt: UastFormat) as f(0) or f(1) and a method g(fmt: Int) as
g(UastBinary) or g(UastYaml)

Signed-off-by: ncordon <[email protected]>

Author: ncordon

src/main/native/org_bblfsh_client_v2_Context.h

@@ -824,7 +824,7 @@ JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_Context_filter(
   return iter;
 }
 
-JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_Context_encode(
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_Context_nativeEncode(
     JNIEnv *env, jobject self, jobject jnode, jint fmt) {
   UastFormat format = (UastFormat) fmt;  // TODO(#107): make it argument
 
@@ -864,7 +864,7 @@ JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_ContextExt_filter(
   return filterUastIterExt(ctx, self, jquery, env);
 }
 
-JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_ContextExt_encode(
+JNIEXPORT jobject JNICALL Java_org_bblfsh_client_v2_ContextExt_nativeEncode(
     JNIEnv *env, jobject self, jobject node, jint fmt) {
   UastFormat format = (UastFormat) fmt;
 

src/main/native/org_bblfsh_client_v2_ContextExt.h

@@ -110,21 +110,25 @@ object BblfshClient {
   val DEFAULT_MAX_MSG_SIZE = 100 * 1024 * 1024 // bytes
 
   private val libuast = new Libuast
-  private val treeOrder = libuast.getTreeOrders
-  private val uastFormat = libuast.getUastFormats
+  private val orders = libuast.getTreeOrders
+  private val formats = libuast.getUastFormats
 
-  // Lift tree order as constants
-  val AnyOrder = treeOrder.AnyOrder
-  val PreOrder = treeOrder.PreOrder
-  val PostOrder = treeOrder.PostOrder
-  val LevelOrder = treeOrder.LevelOrder
-  val ChildrenOrder = treeOrder.ChildrenOrder
-  val PositionOrder = treeOrder.PositionOrder
-
-  // Lift UAST decoding / encoding formats as constants
-  val uastBinary = uastFormat.UastBinary
-  val uastYaml = uastFormat.UastYaml
+  abstract class UastFormat(val toInt: Int)
+  abstract class TreeOrder(val toInt: Int)
 
+  // Lift tree order as constants
+  case object UastBinary extends UastFormat(formats.uastBinary)
+  case object UastYaml extends UastFormat(formats.uastYaml)
+
+  // Lift orders from libuast as types
+  case object AnyOrder extends TreeOrder(orders.anyOrder)
+  case object PreOrder extends TreeOrder(orders.preOrder)
+  case object PostOrder extends TreeOrder(orders.postOrder)
+  case object LevelOrder extends TreeOrder(orders.levelOrder)
+  case object ChildrenOrder extends TreeOrder(orders.childrenOrder)
+  case object PositionOrder extends TreeOrder(orders.positionOrder)
+
+  /** Creates a BblfshClient with default parameters */
   def apply(
     host: String, port: Int,
     maxMsgSize: Int = DEFAULT_MAX_MSG_SIZE
@@ -137,7 +141,7 @@ object BblfshClient {
     *
     * Since v2.
     */
-  def decode(buf: ByteBuffer, fmt: Int): ContextExt = Libuast.synchronized {
+  def decode(buf: ByteBuffer, fmt: UastFormat): ContextExt = Libuast.synchronized {
     if (!buf.isDirect()) {
       throw new RuntimeException("Only directly-allocated buffer decoding is supported.")
     }
@@ -151,7 +155,7 @@ object BblfshClient {
     * Since v2.
     */
   def decode(buf: ByteBuffer): ContextExt = Libuast.synchronized {
-    decode(buf, uastBinary)
+    decode(buf, UastBinary)
   }
 
   /** Enables API: resp.uast.decode() */
@@ -162,7 +166,7 @@ object BblfshClient {
       * Always copies memory to a new buffer in Direct mode,
       * to be able to pass it to JNI.
       */
-    def decode(fmt: Int): ContextExt = {
+    def decode(fmt: UastFormat): ContextExt = {
       val bufDirectCopy = ByteBuffer.allocateDirect(buf.size)
       buf.copyTo(bufDirectCopy)
       val result = BblfshClient.decode(bufDirectCopy, fmt)
@@ -181,14 +185,14 @@ object BblfshClient {
       * Decodes in binary format
       */
     def decode(): ContextExt = {
-      decode(uastBinary)
+      decode(UastBinary)
     }
   }
 
   /** Enables API: resp.get() */
   implicit class ResponseMethods(val resp: ParseResponse) {
     /** Gets the root decoding the tree in binary format */
-    def get(fmt: Int): JNode = {
+    def get(fmt: UastFormat): JNode = {
       val ctx = resp.uast.decode(fmt)
       val node = ctx.root().load()
       ctx.dispose()
@@ -197,7 +201,7 @@ object BblfshClient {
 
     /** Gets the root node decoding the tree in binary format */
     def get(): JNode = {
-      get(uastBinary)
+      get(UastBinary)
     }
   }
 

src/main/native/org_bblfsh_client_v2_libuast_Libuast.cc

@@ -10,42 +10,49 @@ import org.bblfsh.client.v2.libuast.Libuast.{UastIter, UastIterExt}
   * This is equivalent of pyuast.ContextExt API
   */
 case class ContextExt(nativeContext: Long) {
-    import BblfshClient.uastBinary
+    import BblfshClient.{UastFormat, UastBinary}
+
     // @native def load(): JNode // TODO(bzz): clarify when it's needed VS just .root().load()
     @native def root(): NodeExt
     @native def filter(query: String): UastIterExt
+    @native def nativeEncode(n: NodeExt, fmt: Int): ByteBuffer
+    def encode(n: NodeExt, fmt: UastFormat): ByteBuffer = {
+      nativeEncode(n, fmt)
+    }
     // encode using binary format
-    @native def encode(n: NodeExt, fmt: Int): ByteBuffer
     def encode(n: NodeExt): ByteBuffer = {
-      encode(n, uastBinary)
+      encode(n, UastBinary)
     }
     @native def dispose()
     override def finalize(): Unit = {
         this.dispose()
     }
 }
 
-
 /**
   * Represents JVM-side constructed tree
   *
   * This is equivalent of pyuast.Context API
   */
 case class Context(nativeContext: Long) {
-    import BblfshClient.uastBinary
+    import BblfshClient.{UastFormat, UastBinary}
 
     @native def root(): JNode
     @native def filter(query: String, node: JNode): UastIter
-    @native def encode(n: JNode, fmt: Int): ByteBuffer
+    @native def nativeEncode(n: JNode, fmt: Int): ByteBuffer
+    def encode(n: JNode, fmt: UastFormat): ByteBuffer = {
+      nativeEncode(n, fmt)
+    }
     // encode using binary format
     def encode(n: JNode): ByteBuffer = {
-      encode(n, uastBinary)
+      encode(n, UastBinary)
     }
     @native def dispose()
     override def finalize(): Unit = {
       this.dispose()
     }
 }
+
 object Context {
     @native def create(): Long
     def apply(): Context = new Context(create())

src/main/scala/org/bblfsh/client/v2/BblfshClient.scala

@@ -28,9 +28,9 @@ case class NodeExt(ctx: ContextExt, handle: Long) {
   * This is equivalent of pyuast.Node API.
   */
 sealed abstract class JNode {
-  import BblfshClient.uastBinary
+  import BblfshClient.{UastFormat, UastBinary}
 
-  def toByteArray(fmt: Int): Array[Byte] = {
+  def toByteArray(fmt: UastFormat): Array[Byte] = {
     val buf = toByteBuffer(fmt)
     val arr = new Array[Byte](buf.capacity())
     buf.get(arr)
@@ -40,10 +40,10 @@ sealed abstract class JNode {
 
   /** Use binary UAST format */
   def toByteArray: Array[Byte] = {
-    toByteArray(uastBinary)
+    toByteArray(UastBinary)
   }
 
-  def toByteBuffer(fmt: Int): ByteBuffer = {
+  def toByteBuffer(fmt: UastFormat): ByteBuffer = {
     val ctx = Context()
     val bb = ctx.encode(this, fmt)
     ctx.dispose()
@@ -52,7 +52,7 @@ sealed abstract class JNode {
 
   /** Use binary UAST format */
   def toByteBuffer: ByteBuffer = {
-    toByteBuffer(uastBinary)
+    toByteBuffer(UastBinary)
   }
 
   /* Dynamic dispatch is a convenience to be called from JNI */
@@ -87,9 +87,9 @@ sealed abstract class JNode {
 }
 
 object JNode {
-  import BblfshClient.uastBinary
+  import BblfshClient.{UastFormat, UastBinary}
 
-  private def decodeFrom(bytes: ByteBuffer, fmt: Int): JNode = {
+  private def decodeFrom(bytes: ByteBuffer, fmt: UastFormat): JNode = {
     val ctx = BblfshClient.decode(bytes, fmt)
     val node = ctx.root().load()
     ctx.dispose()
@@ -105,7 +105,7 @@ object JNode {
     * @param original UAST encoded in wire format of protocol.v2
     * @return JNode of the UAST root
     */
-  def parseFrom(original: ByteBuffer, fmt: Int): JNode = {
+  def parseFrom(original: ByteBuffer, fmt: UastFormat): JNode = {
     val bufDirect = if (!original.isDirect) {
       val bufDirectCopy = ByteBuffer.allocateDirect(original.capacity())
       original.rewind()
@@ -121,7 +121,7 @@ object JNode {
 
   /** Parse from a buffer using binary UAST format */
   def parseFrom(original: ByteBuffer): JNode = {
-    parseFrom(original, uastBinary)
+    parseFrom(original, UastBinary)
   }
 
   /**
@@ -133,7 +133,7 @@ object JNode {
     * @param bytes UAST encoded in wire format of protocol.v2
     * @return JNode of the UAST root
     */
-  def parseFrom(bytes: Array[Byte], fmt: Int): JNode = {
+  def parseFrom(bytes: Array[Byte], fmt: UastFormat): JNode = {
     val bufDirect = ByteBuffer.allocateDirect(bytes.size)
     bufDirect.put(bytes)
     bufDirect.flip()
@@ -142,7 +142,7 @@ object JNode {
 
   /** Parse from an array using binary UAST format */
   def parseFrom(bytes: Array[Byte]): JNode = {
-    parseFrom(bytes, uastBinary)
+    parseFrom(bytes, UastBinary)
   }
 }
 

src/main/scala/org/bblfsh/client/v2/ContextExt.scala

@@ -1,6 +1,6 @@
 package org.bblfsh.client.v2.libuast
 
-import org.bblfsh.client.v2.{ContextExt, Context, JNode, NodeExt, TreeOrder}
+import org.bblfsh.client.v2.{ContextExt, Context, JNode, NodeExt}
 import org.bblfsh.client.v2.libuast.Libuast.UastIterExt
 
 import scala.collection.Iterator
@@ -19,17 +19,17 @@ object Libuast {
   }
 
   case class UastFormat(
-    UastBinary: Int,
-    UastYaml: Int
+    uastBinary: Int,
+    uastYaml: Int
   )
 
   case class TreeOrder(
-    AnyOrder: Int,
-    PreOrder: Int,
-    PostOrder: Int,
-    LevelOrder: Int,
-    ChildrenOrder: Int,
-    PositionOrder: Int
+    anyOrder: Int,
+    preOrder: Int,
+    postOrder: Int,
+    levelOrder: Int,
+    childrenOrder: Int,
+    positionOrder: Int
   )
 
   /**
@@ -156,7 +156,7 @@ class Libuast {
   @native def decode(buf: ByteBuffer, fmt: Int): ContextExt
 
   /** Lifts the tree order values from the libuast */
-  @native def getTreeOrders: TreeOrder
+  @native def getTreeOrders: Libuast.TreeOrder
 
   /** Lifts the uast decoding / encoding options from the libuast */
   @native def getUastFormats: Libuast.UastFormat

src/main/scala/org/bblfsh/client/v2/NodeExt.scala

@@ -8,12 +8,46 @@ package org.bblfsh.client
 package object v2 {
   /** Key, Value representation of [[org.bblfsh.client.v2.JObject]] */
   type JField = (String, JNode)
-  /** Aliases for constants coming from libuast
-    * This is just for convenience, to be able to do
-    * `import org.bblfsh.client.v2.TreeOrder`
-    * instead of
-    * `import org.bblfsh.client.v2.libuast.Libuast.TreeOrder`
+
+  import BblfshClient._
+
+  /** Allow to use methods
+    * f(fmt: UastFormat) as f(0) or f(1)
+    * g(fmt: Int) as g(UastBinary) or g(UastYaml)
+    */
+  implicit def formatToInt(fmt: UastFormat): Int = {
+    fmt.toInt
+  }
+
+  implicit def intToFormat(x: Int): UastFormat = {
+    x match {
+      case UastBinary.toInt => UastBinary
+      case UastYaml.toInt => UastYaml
+      case _ =>
+        println("warning: not valid numeric format, using UastBinary")
+        UastBinary
+    }
+  }
+
+  /** Allow to use methods
+    * f(order: UastOrder) as f(0), f(1), f(2), ...
+    * g(order: Int) as g(AnyOrder), g(PreOrder), g(PostOrder)
     */
-  type UastFormat = libuast.Libuast.UastFormat
-  type TreeOrder = libuast.Libuast.TreeOrder
+  implicit def orderToInt(order: TreeOrder): Int = {
+    order.toInt
+  }
+
+  implicit def intToOrder(x: Int): TreeOrder = {
+    x match {
+      case AnyOrder.toInt => AnyOrder
+      case PreOrder.toInt => PreOrder
+      case PostOrder.toInt => PostOrder
+      case LevelOrder.toInt => LevelOrder
+      case ChildrenOrder.toInt => ChildrenOrder
+      case PositionOrder.toInt => PositionOrder
+      case _ =>
+        println("warning: not valid numeric order, using AnyOrder")
+        AnyOrder
+    }
+  }
 }