--- a/directmapping/src/test/scala/DirectMappingTest.scala	Mon Jan 10 12:26:03 2011 -0500
+++ b/directmapping/src/test/scala/DirectMappingTest.scala	Tue Jan 11 18:35:16 2011 -0500
@@ -50,6 +50,8 @@
 
 class DirectMappingTestWithConcreteModel extends DirectMappingTest with ConcreteModel
 
+class DirectMappingTestWithJenaModel extends DirectMappingTest with org.w3.rdf.jena.JenaModel
+
 trait DirectMappingTest extends FunSuite with RDFModel with RDFImplicits with DirectMappingModule with TurtleModule {
 
   val DirectMapping = new DirectMapping {  }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jena/src/main/scala/JenaModel.scala	Tue Jan 11 18:35:16 2011 -0500
@@ -0,0 +1,129 @@
+package org.w3.rdf.jena
+
+import org.w3.rdf._
+import com.hp.hpl.jena.graph.{Graph => JenaGraph, Triple => JenaTriple, Node => JenaNode, _}
+import com.hp.hpl.jena.rdf.model.{AnonId}
+import com.hp.hpl.jena.datatypes.{RDFDatatype, TypeMapper}
+
+import org.w3.isomorphic._
+
+object Util {
+  def tryopt[T](b: => T):Option[T] =
+    try {
+      Some(b)
+    } catch {
+      case e => None
+    }
+}
+
+import Util._
+
+trait JenaModel extends Model {
+
+  case class IRI(iri:String) { override def toString = '"' + iri + '"' }
+  object IRI extends Isomorphic1[String, IRI]
+
+  class Graph(val jenaGraph:JenaGraph) extends Iterable[Triple] {
+    def iterator:Iterator[Triple] = new Iterator[Triple] {
+      val iterator = jenaGraph.find(JenaNode.ANY, JenaNode.ANY, JenaNode.ANY)
+      def hasNext = iterator.hasNext
+      def next = iterator.next
+    }
+
+    override def equals(o:Any):Boolean = ( o.isInstanceOf[Graph] && jenaGraph.isIsomorphicWith(o.asInstanceOf[Graph].jenaGraph) )
+
+  }
+
+  object Graph extends GraphObject {
+    def empty:Graph = new Graph(Factory.createDefaultGraph)
+    def apply(elems:Triple*):Graph = apply(elems.toIterable)
+    def apply(it:Iterable[Triple]):Graph = {
+      val jenaGraph = Factory.createDefaultGraph
+      it foreach { t => jenaGraph add t }
+      new Graph(jenaGraph)
+    }
+  }
+
+  type Triple = JenaTriple
+  object Triple extends Isomorphic3[Subject, Predicate, Object, Triple] {
+    def apply(s:Subject, p:Predicate, o:Object):Triple = JenaTriple.create(s, p, o)
+    def unapply(t:Triple):Option[(Subject, Predicate, Object)] = Some((t.getSubject, t.getPredicate, t.getObject))
+  }
+
+  type BNode = Node_Blank
+  object BNode extends Isomorphic1[String, BNode] {
+    def apply(label:String):BNode = { val id = AnonId.create(label) ; JenaNode.createAnon(id).asInstanceOf[Node_Blank] }
+    def unapply(bn:BNode):Option[String] = tryopt(bn.getBlankNodeId.getLabelString)
+  }
+
+  type Node = JenaNode
+  type NodeIRI = Node_URI
+  object NodeIRI extends Isomorphic1[IRI, NodeIRI] {
+    def apply(iri:IRI):NodeIRI = { val IRI(s) = iri ; JenaNode.createURI(s).asInstanceOf[Node_URI] }
+    def unapply(node:NodeIRI):Option[IRI] = tryopt(IRI(node.getURI))
+  }
+  type NodeBNode = Node_Blank
+  object NodeBNode extends Isomorphic1[BNode, NodeBNode] {
+    def apply(node:BNode):NodeBNode = node
+    def unapply(node:NodeBNode):Option[BNode] =
+      if (node.isBlank) Some(node) else None
+  }
+
+  type Subject = JenaNode
+  type SubjectNode = JenaNode
+  object SubjectNode extends Isomorphic1[Node, SubjectNode] {
+    def apply(node:Node):SubjectNode = node
+    def unapply(node:SubjectNode):Option[Node] = Some(node)
+  }
+
+  type Predicate = JenaNode
+  type PredicateIRI = JenaNode
+  object PredicateIRI extends Isomorphic1[IRI, PredicateIRI] {
+    def apply(iri:IRI):PredicateIRI = { val IRI(s) = iri ; JenaNode.createURI(s) }
+    def unapply(node:PredicateIRI):Option[IRI] = tryopt(IRI(node.getURI))
+  }
+
+  type Object = JenaNode
+  type ObjectNode = JenaNode
+  object ObjectNode extends Isomorphic1[Node, ObjectNode] {
+    def apply(node:Node):ObjectNode = node
+    def unapply(node:ObjectNode):Option[Node] =
+      if (node.isURI || node.isBlank) Some(node) else None
+  }
+  type ObjectLiteral = JenaNode
+  object ObjectLiteral extends Isomorphic1[Literal, ObjectLiteral] {
+    def apply(literal:Literal):ObjectLiteral = literal
+    def unapply(node:ObjectLiteral):Option[Literal] =
+      if (node.isLiteral) Some(node.asInstanceOf[Node_Literal]) else None
+  }
+
+  type Literal = Node_Literal
+  type PlainLiteral = Node_Literal
+  object PlainLiteral extends Isomorphic2[String, Option[LangTag], PlainLiteral] {
+    def apply(lit:String, langtagOption:Option[LangTag]) =
+      langtagOption match {
+        case Some(LangTag(langtag)) => JenaNode.createLiteral(lit, langtag, false).asInstanceOf[Node_Literal]
+        case None => JenaNode.createLiteral(lit).asInstanceOf[Node_Literal]
+      }
+    def unapply(literal:PlainLiteral):Option[(String, Option[LangTag])] =
+      tryopt { ( literal.getLiteralValue.toString, Option(LangTag(literal.getLiteralLanguage)) ) }
+  }
+  type TypedLiteral = Node_Literal
+  lazy val mapper = TypeMapper.getInstance
+  object TypedLiteral extends Isomorphic2[String, IRI, TypedLiteral] {
+    def apply(lit:String, iri:IRI):TypedLiteral = {
+      val IRI(typ) = iri
+      JenaNode.createLiteral(lit, null, mapper.getTypeByName(typ)).asInstanceOf[Node_Literal]
+    }
+    def unapply(literal:TypedLiteral):Option[(String, IRI)] =
+      tryopt((literal.getLiteralValue.toString, IRI(literal.getLiteralDatatype.getURI)))
+  }
+
+  case class LangTag(s:String)
+  object LangTag extends Isomorphic1[String, LangTag]
+
+}
+
+object JenaModel extends JenaModel
+
+object JenaModelWithImplicits extends JenaModel with Implicits

--- a/project/build/RDB2RDF.scala	Mon Jan 10 12:26:03 2011 -0500
+++ b/project/build/RDB2RDF.scala	Tue Jan 11 18:35:16 2011 -0500
@@ -19,8 +19,9 @@
   lazy val rdfdsl = project("rdfdsl", "rdfdsl", new RDFDSL(_), rdf)
   lazy val turtle = project("turtle", "turtle", new Turtle(_), rdf)
   lazy val rdfxml = project("rdfxml", "rdfxml", new RDFXML(_), rdf)
+  lazy val jena = project("jena", "jena", new Jena(_), rdf)
   lazy val sharedtestdata = project("sharedtestdata", "sharedtestdata", new SharedTestData(_), rdb, rdf, sql, turtle)
-  lazy val directmapping = project("directmapping", "directmapping", new DirectMapping(_), rdb, rdf, sql, sharedtestdata)
+  lazy val directmapping = project("directmapping", "directmapping", new DirectMapping(_), rdb, rdf, sql, sharedtestdata, jena)
   lazy val sparql = project("sparql", "sparql", new SPARQL(_), rdf)
   lazy val sparql2sql = project("sparql2sql", "sparql2sql", new SPARQL2SQL(_), sparql, sql)
   lazy val sparql2sparql = project("sparql2sparql", "sparql2sparql", new SPARQL2SPARQL(_), sparql)
@@ -41,7 +42,12 @@
   class Turtle(info: ProjectInfo) extends DefaultProject(info) with Common
 
   class RDFXML(info: ProjectInfo) extends DefaultProject(info) with Common {
-    val jena = "com.hp.hpl.jena" % "jena" % "2.6.3"
+    val jena = "com.hp.hpl.jena" % "jena" % "2.6.4"
+    val jenaIri = "com.hp.hpl.jena" % "iri" % "0.8" from "http://openjena.org/repo/com/hp/hpl/jena/iri/0.8/iri-0.8.jar"
+  }
+
+  class Jena(info: ProjectInfo) extends DefaultProject(info) with Common {
+    val jena = "com.hp.hpl.jena" % "jena" % "2.6.4"
     val jenaIri = "com.hp.hpl.jena" % "iri" % "0.8" from "http://openjena.org/repo/com/hp/hpl/jena/iri/0.8/iri-0.8.jar"
   }
 

--- a/rdf/src/main/scala/RDF.scala	Mon Jan 10 12:26:03 2011 -0500
+++ b/rdf/src/main/scala/RDF.scala	Tue Jan 11 18:35:16 2011 -0500
@@ -5,7 +5,7 @@
 trait Model {
 
   type IRI
-  type Graph <: Traversable[Triple]
+  type Graph <: Iterable[Triple]
   type Triple
   type BNode
   type Node