initial commit

Author: romangrebennikov

.gitignore

@@ -0,0 +1,16 @@
+.cache*
+.classpath
+.project
+.worksheet/
+.settings
+
+
+data/
+project/project/*
+project/target/*
+src/main/target
+target/
+project/eclipse.sbt
+
+.idea
+config.json

build.sbt

@@ -0,0 +1,38 @@
+// scala.meta macros are at the moment only supported in 2.11.
+scalaVersion in ThisBuild := "2.11.8"
+
+lazy val metaMacroSettings: Seq[Def.Setting[_]] = Seq(
+  // New-style macro annotations are under active development.  As a result, in
+  // this build we'll be referring to snapshot versions of both scala.meta and
+  // macro paradise.
+  resolvers += Resolver.url(
+    "scalameta",
+    url("http://dl.bintray.com/scalameta/maven"))(Resolver.ivyStylePatterns),
+  // A dependency on macro paradise 3.x is required to both write and expand
+  // new-style macros.  This is similar to how it works for old-style macro
+  // annotations and a dependency on macro paradise 2.x.
+  addCompilerPlugin(
+    "org.scalameta" % "paradise" % "3.0.0.132" cross CrossVersion.full),
+  scalacOptions += "-Xplugin-require:macroparadise",
+  // temporary workaround for https://github.com/scalameta/paradise/issues/10
+  scalacOptions in (Compile, console) := Seq(), // macroparadise plugin doesn't work in repl yet.
+  // temporary workaround for https://github.com/scalameta/paradise/issues/55
+  sources in (Compile, doc) := Nil // macroparadise doesn't work with scaladoc yet.
+)
+
+// Define macros in this project.
+lazy val macros = (project in file("macros")).settings(
+  name := "scala-packed-macro",
+  metaMacroSettings,
+  // A dependency on scala.meta is required to write new-style macros, but not
+  // to expand such macros.  This is similar to how it works for old-style
+  // macros and a dependency on scala.reflect.
+  libraryDependencies += "org.scalameta" %% "scalameta" % "1.4.0.544",
+  libraryDependencies += "org.scalatest" % "scalatest_2.11" % "3.0.1"
+)
+
+// Use macros in this project.
+lazy val core = (project in file("core")).settings(
+  name := "scala-packed-core",
+  metaMacroSettings
+).dependsOn(macros)

core/src/main/scala/io/findify/scalapacked/PackedProduct.scala

@@ -0,0 +1,20 @@
+package io.findify.scalapacked
+
+import java.nio.ByteBuffer
+
+import io.findify.scalapacked.types.PackedType
+
+/**
+  * Created by shutty on 11/19/16.
+  */
+trait PackedProduct {
+  var buffer: ByteBuffer
+  var offset: Int
+  def size: Int
+}
+
+object PackedMember {
+  def memberSize[T](value: T)(implicit packer: PackedType[T]): Int = packer.size(value)
+  def memberWrite[T](value: T, buffer: ByteBuffer, offset: Int)(implicit packer: PackedType[T]): Unit = packer.write(value, buffer, offset)
+  def memberRead[T](buffer: ByteBuffer, offset: Int)(implicit packer: PackedType[T]):T = packer.read(buffer, offset)
+}

core/src/main/scala/io/findify/scalapacked/PackedSeq.scala

@@ -0,0 +1,65 @@
+package io.findify.scalapacked
+
+import java.nio.ByteBuffer
+
+import scala.reflect.ClassTag
+
+/**
+  * Created by shutty on 11/20/16.
+  */
+class PackedSeq[T <: PackedProduct : ClassTag](buffer: ByteBuffer, size: Int) {
+  import scala.reflect._
+  def map[U <: PackedProduct : ClassTag]( f: T => U ) = {
+    var offset = 0
+    var count = 0
+    val instanceT = classTag[T].runtimeClass.newInstance().asInstanceOf[T]
+    var instanceU = classTag[U].runtimeClass.newInstance().asInstanceOf[U]
+    var output = ByteBuffer.allocate(1024)
+    while (count < size) {
+      instanceT.buffer = buffer
+      instanceT.offset = offset
+      offset += instanceT.size
+      instanceU = f(instanceT)
+      count += 1
+      if (output.remaining() > instanceU.size) {
+        output.put(instanceU.buffer)
+      } else {
+        val largerOutput = ByteBuffer.allocate(output.capacity() * 2)
+        largerOutput.put(output)
+        largerOutput.put(instanceU.buffer)
+        output = largerOutput
+      }
+    }
+    new PackedSeq[U](output, size)
+  }
+
+  def foreach(f: T => Unit) = {
+    var offset = 0
+    var count = 0
+    val instanceT = classTag[T].runtimeClass.newInstance().asInstanceOf[T]
+    while (count < size) {
+      instanceT.buffer = buffer
+      instanceT.offset = offset
+      offset += instanceT.size
+      f(instanceT)
+      count += 1
+    }
+  }
+}
+
+object PackedSeq {
+  def apply[T <: PackedProduct : ClassTag](items: Seq[T]) = {
+    val initial = ByteBuffer.allocate(1024)
+    val buffer = items.foldLeft(initial)( (buffer, item) => {
+      if (buffer.remaining() > item.size) {
+        buffer.put(item.buffer)
+        buffer
+      } else {
+        val largerBuffer = ByteBuffer.allocate(buffer.capacity() * 2)
+        largerBuffer.put(buffer)
+        largerBuffer.put(item.buffer)
+      }
+    })
+    new PackedSeq[T](buffer, items.length)
+  }
+}

core/src/main/scala/io/findify/scalapacked/types/DefaultTypes.scala

@@ -0,0 +1,22 @@
+package io.findify.scalapacked.types
+
+import java.nio.ByteBuffer
+
+/**
+  * Created by shutty on 11/20/16.
+  */
+object DefaultTypes {
+
+  implicit object IntPacked extends PackedType[Int] {
+    override def size(value:Int): Int = 4
+    override def write(value:Int, buffer: ByteBuffer, offset: Int): Unit = buffer.putInt(offset, value)
+    override def read(buffer: ByteBuffer, offset: Int): Int = buffer.getInt(offset)
+  }
+
+  implicit object LongPacked extends PackedType[Long] {
+    override def size(value:Long): Int = 8
+    override def write(value:Long, buffer: ByteBuffer, offset: Int): Unit = buffer.putLong(offset, value)
+    override def read(buffer: ByteBuffer, offset: Int): Long = buffer.getLong(offset)
+  }
+
+}

core/src/main/scala/io/findify/scalapacked/types/PackedType.scala

@@ -0,0 +1,13 @@
+package io.findify.scalapacked.types
+
+import java.nio.ByteBuffer
+
+/**
+  * Created by shutty on 11/19/16.
+  */
+trait PackedType[@specialized(Int, Long, Float, Double) T] {
+  def size(value: T): Int
+  def write(value: T, buffer: ByteBuffer, offset: Int): Unit
+  def read(buffer: ByteBuffer, offset: Int): T
+}
+

core/src/test/scala/io/findify/scalapacked/MacroTest.scala

@@ -0,0 +1,16 @@
+package io.findify.scalapacked
+
+import org.scalatest.{FlatSpec, Matchers}
+
+/**
+  * Created by shutty on 11/21/16.
+  */
+
+@Packed class Bar(a:Int)
+
+class MacroTest extends FlatSpec with Matchers {
+  "packed class" should "have size method" in {
+    val bar = new Bar(1)
+    bar.size shouldBe 4
+  }
+}

core/src/test/scala/io/findify/scalapacked/SimpleTest.scala

@@ -0,0 +1,69 @@
+package io.findify.scalapacked
+
+import java.nio.ByteBuffer
+
+import org.scalatest.{FlatSpec, Matchers}
+
+/**
+  * Created by shutty on 11/19/16.
+  */
+
+
+class Foo(var buffer: ByteBuffer, var offset: Int) extends PackedProduct {
+  def this() = this(ByteBuffer.allocate(0), 0)
+  import io.findify.scalapacked.types.DefaultTypes._
+  def i1: Int = PackedMember.memberRead[Int](buffer, offset + 0)
+  def i2: Long = PackedMember.memberRead[Long](buffer, offset + PackedMember.memberSize(i1))
+  def size = PackedMember.memberSize(i1) + PackedMember.memberSize(i2)
+}
+
+object Foo {
+  def apply(i1: Int, i2: Long) = {
+    import io.findify.scalapacked.types.DefaultTypes._
+    val i1size = PackedMember.memberSize(i1)
+    val i2size = PackedMember.memberSize(i2)
+    val buffer = ByteBuffer.allocate(i1size + i2size)
+    val i1offset = 0
+    PackedMember.memberWrite(i1, buffer, i1offset)
+    val i2offset = i1offset + i1size
+    PackedMember.memberWrite(i2, buffer, i2offset)
+    new Foo(buffer, 0)
+  }
+}
+
+class SimpleTest extends FlatSpec with Matchers {
+  "case class with int" should "be written to bytebuffer" in {
+    val in = Foo(17, 24)
+    val buff = ByteBuffer.allocate(in.size)
+    buff.put(in.buffer)
+    val result1 = buff.getInt(0)
+    result1 shouldBe 17
+    val result2 = buff.getLong(4)
+    result2 shouldBe 24
+  }
+
+  it should "not fail on empty instance" in {
+    val empty = new Foo()
+    empty.offset shouldBe 0
+  }
+
+  it should "be insertable to PackedSeq" in {
+    val seq = PackedSeq(Seq(Foo(1, 2), Foo(3, 4)))
+    var count = 0
+    seq.foreach { item => {
+      count += item.i1
+      count += item.i2.toInt
+    }}
+    count shouldBe 10
+  }
+
+  it should "map thru elements" in {
+    val seq = PackedSeq(Seq(Foo(1, 2), Foo(3, 4))).map(item => Foo(item.i1 * 2, item.i2 * 2))
+    var count = 0
+    seq.foreach { item => {
+      count += item.i1
+      count += item.i2.toInt
+    }}
+    count shouldBe 20
+  }
+}

macros/src/main/scala/io/findify/scalapacked/Packed.scala

@@ -0,0 +1,16 @@
+package io.findify.scalapacked
+
+/**
+  * Created by shutty on 11/21/16.
+  */
+
+import scala.meta._
+
+class Packed extends scala.annotation.StaticAnnotation {
+  inline def apply(defn: Any): Any = meta {
+    defn match {
+      case q"class $tpname (...$paramss) { ..$stats }" => q"class $tpname (...$paramss) {..$stats; def size: Int = 1}; object $tpname { def hello: Int = 1 }"
+      case _ => abort("cannot match class")
+    }
+  }
+}

project/build.properties

@@ -0,0 +1 @@
+sbt.version = 0.13.8

project/plugins.sbt

@@ -0,0 +1 @@
+logLevel := Level.Warn