simplify id types and related stuff

.gitignore

@@ -19,8 +19,16 @@ project/plugins/project/
 *.sublime-project
 *.sublime-workspace
 
+# scala-ide
+.project
+.classpath
+.settings
+.settings/*
+
+
 # data folders
 data/in/
 data/out/
 
 credentials.sbt
+/bin/

build.sbt

@@ -13,8 +13,9 @@ scalaVersion := "2.11.1"
 skip in update := true
 
 libraryDependencies ++= Seq(
-  "ohnosequences" %% "scarph" % "0.1.0",
+  "ohnosequences" %% "scarph" % "0.2.0-SNAPSHOT",
   "ohnosequences" %% "tabula" % "0.1.0-SNAPSHOT",
+  "ohnosequences" %% "type-sets" % "0.5.0-SNAPSHOT",
   //"com.typesafe.scala-logging" %% "scala-logging-slf4j" % "3.0.0", currentlu unavailable for 2.11
   "com.amazonaws" % "aws-java-sdk" % "1.8.0",
   "org.scala-lang.modules" %% "scala-xml" % "1.0.2",
@@ -23,7 +24,6 @@ libraryDependencies ++= Seq(
 )
 
 dependencyOverrides ++= Set(
-  "ohnosequences" %% "type-sets" % "0.5.0-SNAPSHOT",
   "org.apache.httpcomponents" % "httpclient" % "4.2",
   "commons-codec" % "commons-codec" % "1.7",
   "com.amazonaws" % "aws-java-sdk" % "1.8.0",

src/main/scala/com/bio4j/dynamograph/AnyDynamoEdge.scala

@@ -4,48 +4,123 @@ import com.amazonaws.services.dynamodbv2.model.AttributeValue
 import ohnosequences.scarph._
 import com.bio4j.dynamograph.dao.go.{AnyDynamoDbDao}
 import com.bio4j.dynamograph.model.GeneralSchema._
+import com.bio4j.dynamograph.model._
+import ohnosequences.typesets._
+import com.bio4j.dynamograph.writer.AnyVertexWriter
+import com.bio4j.dynamograph.reader.AnyVertexReader
+import ohnosequences.tabula._, impl.ImplicitConversions._, toSDKRep._, fromSDKRep._, impl._, impl.actions._
 
 
-trait AnyDynamoEdge extends AnyEdge { dynamoEdge =>
+trait AnyDynamoEdge extends AnySealedEdge { dynamoEdge =>
 
+  type Tpe <: Singleton with AnyEdgeTypeWithId
+
+  val dao: AnyDynamoDbDao = ServiceProvider.dao
 
-  final type Raw = Map[String, AttributeValue]
+  type EdgeTables <: Singleton with AnyEdgeTables
+  val edgeTables : EdgeTables
+
+  type SourceTable <: Singleton with AnyVertexTable.withVertexType[Tpe#SourceType]
+  val sourceTable : SourceTable
+  type SourceReader <: Singleton with AnyVertexReader.withVertexTableType[SourceTable]
+  val sourceReader : SourceReader
+
+  type TargetTable <: Singleton with AnyVertexTable.withVertexType[Tpe#TargetType]
+  val targetTable : TargetTable
+  type TargetReader <: Singleton with AnyVertexReader.withVertexTableType[TargetTable]
+  val targetReader : TargetReader
+
+  /*
+    you need the tables here!! same for DynamoVertex, but there is less obvious. If you would have them, what you need to do is:
 
-  val dao: AnyDynamoDbDao = ServiceProvider.dao
+    1. use sourceId, targetId from there to get the id from the in/out table
+    2. get the vertex from the corresponding vertex table
+
+  */
+
+  type Other = String
+
+  type Source <:  AnyDynamoVertex { type Tpe <: Singleton with AnyVertexTypeWithId with dynamoEdge.tpe.SourceType }
 
-  type Source <: AnyVertex.ofType[Tpe#SourceType] with AnyDynamoVertex
   val source: Source
 
-  type Target <: AnyVertex.ofType[Tpe#TargetType] with AnyDynamoVertex
+  type Target <:  AnyDynamoVertex { type Tpe <: Singleton with AnyVertexTypeWithId with dynamoEdge.tpe.TargetType }
+
   val target: Target
 
+  implicit object sourceGetter extends GetSource {
 
-  implicit def unsafeGetProperty[P <: AnyProperty: Property.Of[this.Tpe]#is](p: P) =
-    new PropertyGetter[P](p) {
-      def apply(rep: dynamoEdge.Rep) : p.Raw = getValue(rep, p.label).asInstanceOf[p.Raw]
-    }
+    import tpe._
 
-  implicit object sourceGetter extends GetSource {
-    def apply(rep: dynamoEdge.Rep): Out =
-      source ->> dao.get(getValue(rep,sourceId.label), source)
+    def apply(rep: dynamoEdge.Rep): Out = source ->> {
+
+      val srcId: sourceId.Rep = rep get sourceId
+
+      // try to get it
+      import ServiceProvider.executors._
+
+      val getResult = ServiceProvider.service please (
+
+        FromHashKeyTable (
+
+          source.vertexTable.table, 
+          Active (
+            source.vertexTable.table,
+            ServiceProvider.service.account,
+            ThroughputStatus(1, 1)
+          )
+        ) getItem source.vertexTable.vertexItem withKey (srcId)
+      )
+
+      val recordEntry = getResult.right.get
+
+      source.raw ( recordEntry, "" )
+    }
   }
 
   implicit object targetGetter extends GetTarget {
-    def apply(rep: dynamoEdge.Rep): target.Rep =
-      target ->> dao.get(getValue(rep,targetId.label), target)
-  }
 
-  // NOTE: why was it private?
-  def getValue(rep: Rep, attributeName : String) : String = rep.get(attributeName).getOrElse(new AttributeValue().withS("")).getS
+    import tpe._
 
+    def apply(rep: dynamoEdge.Rep): target.Rep = target ->> {
+
+      val tgtId = rep get targetId
+      val couldBeRecordEntry = targetReader.read(tgtId)
+      val recordEntry = couldBeRecordEntry.right.get
+      target.raw ( recordEntry, "" )
+    }
+  }
 }
 
 class DynamoEdge[
-ET <: AnyEdgeType,
-S <: Singleton with AnyVertex.ofType[ET#SourceType] with AnyDynamoVertex,
-T <: Singleton with AnyVertex.ofType[ET#TargetType] with AnyDynamoVertex
-](val source: S, val tpe: ET, val target: T) extends AnyDynamoEdge {
+  ET <: Singleton with AnyEdgeTypeWithId,
+  ETab <: Singleton with AnyEdgeTables.withEdgeType[ET],
+  S <: Singleton with AnyDynamoVertex.ofType[ET#SourceType] with AnyDynamoVertex,
+  STab <: Singleton with AnyVertexTable.withVertexType[ET#SourceType],
+  SR <: Singleton with AnyVertexReader.withVertexTableType[STab],
+  T <: Singleton with AnyDynamoVertex.ofType[ET#TargetType] with AnyDynamoVertex,
+  TTab <: Singleton with AnyVertexTable.withVertexType[ET#TargetType],
+  TR <: Singleton with AnyVertexReader.withVertexTableType[TTab]
+](
+  val source: S,
+  val sourceTable: STab,
+  val sourceReader: SR,
+  val tpe: ET, 
+  val edgeTables: ETab, 
+  val target: T, 
+  val targetTable : TTab,
+  val targetReader : TR
+) extends AnyDynamoEdge {
   type Source = S
   type Tpe = ET
   type Target = T
+  type EdgeTables = ETab
+  type SourceTable = STab
+  type TargetTable = TTab
+  type SourceReader = SR
+  type TargetReader = TR
+}
+
+object AnyDynamoEdge{
+  type ofType[ET <: Singleton with AnyEdgeTypeWithId] = AnyDynamoEdge { type Tpe = ET }
 }

src/main/scala/com/bio4j/dynamograph/AnyDynamoVertex.scala

@@ -3,69 +3,89 @@ package com.bio4j.dynamograph
 import ohnosequences.scarph._
 import com.bio4j.dynamograph.dao.go.AnyDynamoDbDao
 import com.bio4j.dynamograph.model.GeneralSchema.id
-import com.amazonaws.services.dynamodbv2.model.AttributeValue
+import com.bio4j.dynamograph.model._
 import scala.collection.JavaConverters._
+import ohnosequences.tabula.AnyItem
+import ohnosequences.tabula.AnyItem._
+import ohnosequences.typesets._
+import com.bio4j.dynamograph.reader.EdgeReader
 
 
-trait AnyDynamoVertex extends AnyVertex { dynamoVertex =>
+trait AnyDynamoVertex extends AnySealedVertex { dynamoVertex =>
 
-  final type Raw = Map[String, AttributeValue]
+  type Tpe <: AnySealedVertexType with AnyVertexTypeWithId
+  type VertexTable <: Singleton with AnyVertexTable
+  val vertexTable: VertexTable
 
   val dao: AnyDynamoDbDao = ServiceProvider.dao
 
-  implicit def unsafeGetProperty[P <: AnyProperty: Property.Of[this.Tpe]#is](p: P) =
-    new PropertyGetter[P](p) {
-      def apply(rep: Rep): p.Raw = getValue(rep, p.label)
-    }
+  type Other = String
 
+  implicit def unsafeGetOneOutEdge [
+    E <: AnyDynamoEdge { type Tpe <: From[dynamoVertex.Tpe] with OneOut }
+  ]
+  (e: E)(implicit 
+    isThere: tpe.Id ∈ tpe.record.Properties, 
+    lookup: Lookup[tpe.record.Values, tpe.id.Rep]
+  )
+  : GetOutEdge[E] = new GetOutEdge[E](e) {
 
-  implicit def unsafeGetOneOutEdge[E <: Singleton with AnyDynamoEdge {
-    type Tpe <: From[dynamoVertex.Tpe] with OneOut }](e: E): GetOutEdge[E] = new GetOutEdge[E](e) {
+    def apply(rep: dynamoVertex.Rep): e.tpe.Out[E#Rep] = {
 
-    def apply(rep: dynamoVertex.Rep): e.tpe.Out[e.Rep] = {
-      val it = dao.getOutRelationships(getId(rep), e).asInstanceOf[List[e.Rep]]
-      it.headOption: Option[e.Rep]
+
+      val idV = rep get tpe.id
+      val it = dao.getOutRelationships( idV, e ).asInstanceOf[List[E#Rep]]
+      it.headOption: Option[E#Rep]
     }
   }
 
-  implicit def unsafeGetManyOutEdge[E <: Singleton with AnyDynamoEdge {
-    type Tpe <: From[dynamoVertex.Tpe] with ManyOut }](e: E): GetOutEdge[E] = new GetOutEdge[E](e) {
+  implicit def unsafeGetManyOutEdge [
+    E <: AnyDynamoEdge {type Tpe <: From[dynamoVertex.Tpe] with ManyOut }
+  ]
+  (e: E)(implicit 
+    isThere: tpe.Id ∈ tpe.record.Properties, 
+    lookup: Lookup[tpe.record.Values, tpe.id.Rep]
+  )
+  : GetOutEdge[E] = new GetOutEdge[E](e) {
+
+    def apply(rep: dynamoVertex.Rep): e.tpe.Out[E#Rep] = {
+
+      val it = dao.getOutRelationships( rep get tpe.id, e).asInstanceOf[List[E#Rep]]
 
-    def apply(rep: dynamoVertex.Rep): e.tpe.Out[e.Rep] = {
-      val it = dao.getOutRelationships(getId(rep),e).asInstanceOf[List[e.Rep]]
-      it: List[e.Rep]
+      it: List[E#Rep]
     }
   }
 
   implicit def unsafeGetOneInEdge[E <: Singleton with AnyDynamoEdge {
     type Tpe <: To[dynamoVertex.Tpe] with OneIn }](e: E): GetInEdge[E] = new GetInEdge[E](e) {
 
-    def apply(rep: dynamoVertex.Rep): e.tpe.In[e.Rep] = {
-      val it = dao.getOutRelationships(getId(rep),e).asInstanceOf[List[e.Rep]]
+    def apply(rep: dynamoVertex.Rep)(implicit isThere: id.type ∈ dynamoVertex.tpe.record.Properties, lookup: Lookup[dynamoVertex.tpe.record.Values, id.Entry]): e.tpe.In[e.Rep] = {
+      val it = dao.getOutRelationships(rep.get(id),e).asInstanceOf[List[e.Rep]]
       it.headOption: Option[e.Rep]
     }
   }
 
   implicit def unsafeGetManyInEdge[E <: Singleton with AnyDynamoEdge {
     type Tpe <: To[dynamoVertex.Tpe] with ManyIn }](e: E): GetInEdge[E] = new GetInEdge[E](e) {
 
-    def apply(rep: dynamoVertex.Rep): e.tpe.In[e.Rep] = {
-      val it = dao.getOutRelationships(getId(rep), e).asInstanceOf[List[e.Rep]]
+    def apply(rep: dynamoVertex.Rep)(implicit isThere: id.type ∈ dynamoVertex.tpe.record.Properties, lookup: Lookup[dynamoVertex.tpe.record.Values, id.Entry]): e.tpe.In[e.Rep] = {
+      val it = dao.getOutRelationships(rep.get(id), e).asInstanceOf[List[e.Rep]]
       it.toList: List[e.Rep]
     }
   }
-
-  private def getValue[T](rep: Rep, attributeName : String) : T = rep.get(attributeName).getOrElse(new AttributeValue().withS("")).getS.asInstanceOf[T]
-
-  private def getId(rep: Rep) : String = getValue(rep, id.label)
-
 }
 
-class DynamoVertex[VT <: Singleton with AnyVertexType](val tpe: VT) extends AnyDynamoVertex {
+class DynamoVertex[VT <: Singleton with AnySealedVertexType, VTab <: Singleton with AnyVertexTable]
+(
+  val tpe: VT,
+  val vertexTable: VTab
+) extends AnyDynamoVertex {
   type Tpe = VT
+  type VertexTable = VTab
 }
 
 object AnyDynamoVertex{
-  type ofType[VT <: AnyVertexType] = AnyDynamoVertex { type Tpe = VT }
+  type ofType[VT <: Singleton with AnySealedVertexType] = AnyDynamoVertex { type Tpe = VT }
 }
 
+

src/main/scala/com/bio4j/dynamograph/AnyEdgeTypeWithId.scala

@@ -0,0 +1,59 @@
+package com.bio4j.dynamograph
+
+import ohnosequences.scarph.AnySealedEdgeType
+import ohnosequences.typesets._
+import com.bio4j.dynamograph.model.GeneralSchema._
+import ohnosequences.scarph.From
+import ohnosequences.scarph.To
+
+
+trait AnyEdgeTypeWithId extends AnySealedEdgeType {
+
+  type Id <: Singleton with AnyProperty with AnyProperty.ofValue[String]
+  val id : Id
+
+  implicit val containsId: (Id ∈ record.Properties)
+  implicit val idLookup: Lookup[Record#Raw, id.Rep]
+
+  type SourceType <: AnyVertexTypeWithId
+
+  // the id of the source
+  type SourceId <: Singleton with AnyProperty with AnyProperty.ofValue[sourceType.id.Value]
+  val sourceId: SourceId
+
+  type TargetType <: AnyVertexTypeWithId
+
+  type TargetId <: Singleton with AnyProperty with AnyProperty.ofValue[targetType.id.Value]
+  val targetId: TargetId
+
+  implicit val containsSourceId: (SourceId ∈ record.Properties)
+  implicit val sourceLookup: Lookup[record.Values, sourceId.Rep]
+  implicit val containsTargetId: (TargetId ∈ record.Properties)
+  implicit val targetLookup: Lookup[record.Values, targetId.Rep]
+}
+
+abstract class EdgeTypeWithId[
+  S <: Singleton with AnyVertexTypeWithId,
+  PS <: Singleton with AnyProperty with AnyProperty.ofValue[S#Id#Value],
+  P <: Singleton with AnyProperty with AnyProperty.ofValue[String],
+  R <: Singleton with AnyRecord,
+  T <: Singleton with AnyVertexTypeWithId,
+  PT <: Singleton with AnyProperty with AnyProperty.ofValue[T#Id#Value]
+](
+  val sourceType: S,
+  val sourceId: PS,
+  val id: P,
+  val label: String,
+  val record: R,
+  val targetType: T,
+  val targetId: PT
+)
+extends AnyEdgeTypeWithId with From[S] with To[T] {
+
+  type Id = P
+  type Record = R
+  type SourceType = S
+  type SourceId = PS
+  type TargetType = T
+  type TargetId = PT
+}

src/main/scala/com/bio4j/dynamograph/AnyVertexTypeWithId.scala

@@ -0,0 +1,29 @@
+package com.bio4j.dynamograph
+
+import ohnosequences.typesets._
+import ohnosequences.scarph.AnySealedVertexType
+
+
+trait AnyVertexTypeWithId extends AnySealedVertexType {
+
+  type Id <: Singleton with AnyProperty with AnyProperty.ofValue[String]
+  val id: Id
+
+  implicit val containsId: Id ∈ record.Properties
+}
+
+abstract class VertexTypeWithId [
+  P <: Singleton with AnyProperty with AnyProperty.ofValue[String],
+  R <: Singleton with AnyRecord
+](
+  val id: P,
+  val label: String,
+  val record: R
+)
+extends AnyVertexTypeWithId {
+
+  type Record = R
+  type Id = P
+
+  implicit val containsId: Id ∈ record.Properties
+}