Type Members

1.  trait GetAsyncArray[Tpl] extends AnyRef

   Asynchronous data getter methods on molecules returning Future[Array[Tpl]].

   Asynchronous data getter methods on molecules returning Future[Array[Tpl]].
   
   The fastest way of getting a large typed data set since data is applied to a super fast pre-allocated Array. The Array can then be traversed with a fast while loop.

   // Map over the Future
   Ns.int.getAsyncArray.map { result =>
     result === Array(1, 2, 3)
   
     // Fast while loop
     var i = 0
     val length = result.length
     while(i < length) {
       println(result(i)) // Do stuff with row...
       i += 1
     }
   }

   Each asynchronous getter in this package simply wraps the result of its equivalent synchronous getter (in the get package) in a Future. getAsyncArrayAsOf thus wraps the result of getArrayAsOf in a Future and so on.

2.  trait GetAsyncIterable[Tpl] extends AnyRef

   Asynchronous data getter methods on molecules returning Future[Iterable[Tpl]].

   Asynchronous data getter methods on molecules returning Future[Iterable[Tpl]].
   
   Suitable for data sets that are lazily consumed.

   val iterableFuture: Future[Iterable[(String, Int)]] = Person.name.age.getAsyncIterable
   for {
     iterable <- iterableFuture
   } yield {
     iterable.iterator.next === ("Ben" 42)
   }

   Each asynchronous getter in this package simply wraps the result of its equivalent synchronous getter (in the get package) in a Future. getAsyncIterableAsOf thus wraps the result of getIterableAsOf in a Future and so on.

3.  trait GetAsyncJson extends AnyRef

   Asynchronous data getter methods on molecules returning Future-wrapped Json String.

   Asynchronous data getter methods on molecules returning Future-wrapped Json String.
   
   Molecule builds a Json String directly from the untyped raw Datomic data.
   
   Attributes names are used as Json field names. In order to distinguish fields from each other, all attribute names are prepended with the namespace name (in lowercase). For a namespace Person with an attribute name we get:

   • "person.name"

   To distinguis fields of multiple relationships to the same namespace like friends and enemies pointing to other Person's require us to add a relationship name prefix too:

   • "friends.person.name"
   • "enemies.person.name"

   Furthermore, if the attribute is part of a transaction meta-data molecule, we prefix that with tx too:

   • "tx.person.name"
   • "tx.friends.person.name"

   Example:

   val jsonFuture: Future[String] = Person.name.age.getAsyncJson
   for {
     json <- jsonFuture
   } yield {
     json ===
      """[
        |{"person.name": "Ben", "person.age": 42},
        |{"person.name": "Liz", "person.age": 37}
        |]""".stripMargin
   }

   Each asynchronous getter in this package simply wraps the result of its equivalent synchronous getter (in the get package) in a Future. getAsyncIterableAsOf thus wraps the result of getIterableAsOf in a Future and so on.

   See also

   Json tests

4.  trait GetAsyncList[Tpl] extends AnyRef

   Default asynchronous data getter methods on molecules returning Future[List[Tpl]].

   Default asynchronous data getter methods on molecules returning Future[List[Tpl]].
   
   For expected smaller result sets it's convenient to return Lists of tuples of data. Considered as the default getter, no postfix has been added (getAsync instead of getAsyncList).

   val futureList: Future[List[(String, Int)]] = Person.name.age.getAsync
   for {
     list <- futureList
   } yield {
     list === List(
       ("Ben", 42),
       ("Liz", 37)
     )
   }

   Each asynchronous getter in this package simply wraps the result of its equivalent synchronous getter (in the get package) in a Future. getAsyncAsOf thus wraps the result of getAsOf in a Future and so on.

5.  trait GetAsyncRaw extends AnyRef

   Asynchronous data getter methods on molecules returning raw untyped Datomic data.

   Asynchronous data getter methods on molecules returning raw untyped Datomic data.
   
   Returns a Future with raw untyped java.util.Collection[java.util.List[Object]] directly from Datomic and is therefore the fastest (but untyped) way of retrieving data. Can be useful where typed data is not needed.

   val rawDataFuture: Future[java.util.Colleciton[java.util.List[Object]] = Person.name.age.getAsyncRaw
   for {
     rawData <- rawDataFuture
   } yield {
     rawData.toString === """[["Ben" 42]["Liz" 37]]"""
   }

   Each asynchronous getter in this package simply wraps the result of its equivalent synchronous getter (in the get package) in a Future. getAsyncRawAsOf thus wraps the result of getRawAsOf in a Future and so on.