--- a/src/main/scala/rdf/main.scala Mon Nov 21 15:31:17 2011 -0500
+++ b/src/main/scala/rdf/main.scala Mon Nov 21 17:37:09 2011 -0500
@@ -3,78 +3,11 @@
import java.io.File
import com.hp.hpl.jena.graph.Graph
-// afaik, the compiler doesn't not expose the unapply method
-// for a companion object
-trait Isomorphic[A, B] {
- def apply(x: A): B
- def unapply(x: B): Option[A]
-}
-
-// abstract module
-trait Module {
- // 3 types with some contraints
- type X
- type Y <: X
- type Z <: X
- // and their "companion" objects
- def X: Isomorphic[Int, X]
- def Y: Isomorphic[X, Y]
- def Z: Isomorphic[Y, Z]
-}
-
-// an implementation relying on case classes
-object ConcreteModule extends Module {
- sealed trait X { val i: Int = 42 }
- object X extends Isomorphic[Int, X] {
- def apply(_s: Int): X = new X { }
- def unapply(x: X): Option[Int] = Some(x.i)
- }
- case class Y(x: X) extends X
- // I guess the compiler could do that for me
- object Y extends Isomorphic[X, Y]
- case class Z(y: Y) extends X
- object Z extends Isomorphic[Y, Z]
-}
-
-object Main2 {
- def foo(t: Module)(x: t.X): Unit = {
- import t._
- // the output depends on the order of the first 3 lines
- // I'm not sure what's happening here...
- x match {
- // unchecked since it is eliminated by erasure
- case Y(_y) => println("y "+_y)
- // unchecked since it is eliminated by erasure
- case Z(_z) => println("z "+_z)
- // this one is fine
- case X(_x) => println("x "+_x)
- case xyz => println("xyz "+xyz)
- }
- }
- def bar(t: Module): Unit = {
- import t._
- val x: X = X(42)
- val y: Y = Y(x)
- val z: Z = Z(y)
- foo(t)(x)
- foo(t)(y)
- foo(t)(z)
- }
- def main(args: Array[String]) = {
- // call bar with the concrete module
- bar(ConcreteModule)
- }
-}
object Main {
def main(args: Array[String]) = {
-//
-// val turtle = new org.w3.rdf.turtle.TurtleParser(org.w3.rdf.jena.JenaModel)
-//
-// val g = turtle.toGraph(new File("/tmp/card.n3"))
-
//import org.w3.rdf.jena.JenaModel
//val rdf = ConcreteRDFModel
val rdf = org.w3.rdf.jena.JenaModel
@@ -88,13 +21,6 @@
println(s.asString(g, new java.net.URL("http://www.w3.org/People/Berners-Lee/card")))
-// import rdf._
-// val ol = ObjectLiteral(PlainLiteral("The Next Wave of the Web (Plenary Panel)",None))
-//
-// println(s.objectStr(ol))
-
-
-
}
--- a/src/main/scala/rdf/turtle.scala.egp Mon Nov 21 15:31:17 2011 -0500
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,145 +0,0 @@
-package org.w3.rdf.turtle
-
-import org.w3.rdf._
-import scala.util.parsing.combinator._
-import java.net.URI
-
-object MyParsers extends RegexParsers {
- val uri = """[a-zA-Z0-9:/#_\.\-\+]+""".r
- val integer = """[0-9]+""".r
- val float = """([0-9]+)?\.([0-9]+)?""".r
- val name = """[a-zA-Z][a-zA-Z0-9_-]*|[a-zA-Z_][a-zA-Z0-9_]+""".r
- var prefixes:Map[String, String] = Map()
- var nextBNode = 1
-}
-
-import MyParsers._
-
-class TurtleParser extends JavaTokenParsers {
-
- import rdf._
-
- def toGraph(t:String)(implicit rdf: RDFModel): rdf.Graph = parseAll(turtle, t).get
-
- def toGraph(file:java.io.File)(implicit rdf: RDFModel): rdf.Graph = {
- val t = scala.io.Source.fromFile(file).getLines.reduceLeft(_+_)
- parseAll(turtle, t).get
- }
-
- def turtle(implicit rdf: RDFModel): Parser[rdf.Graph] =
- opt(triplesblock) ^^ { case tbOPT => tbOPT.getOrElse(rdf.Graph.empty) }
-
- def prefixdecl(implicit rdf: RDFModel): Parser[Unit] =
- "@prefix" ~ name ~ ":" ~ qnameORuri ~ "." ^^ { case "@prefix"~pre~":"~u~"." => prefixes += (pre -> { val rdf.IRI(i: String) = u ; i }) }
-
- def triplesblock(implicit rdf: RDFModel): Parser[rdf.Graph] =
- rep(triplepatternOrPrefixOrBase) ^^ {
- case pats => rdf.Graph(pats.flatten(_.toTraversable))
- }
-
- def triplepatternOrPrefixOrBase(implicit rdf: RDFModel): Parser[Option[rdf.Triple]] = (
- triplepattern ^^ { case p => Some(p) }
- | prefixdecl ^^ { case _ => None }
- )
-
- def triplepattern(implicit rdf: RDFModel): Parser[rdf.Triple] =
- subject ~ predicate ~ objectt ~ "." ^^ { case s~p~o~"." => rdf.Triple(s, p, o) }
-
- def bnode(implicit rdf: RDFModel): Parser[rdf.BNode] =
- "_:"~name ^^ { case "_:"~name => rdf.BNode(name) }
-
- def literal(implicit rdf: RDFModel): Parser[rdf.Literal] = (
- stringLiteral~"^^"~qnameORuri ^^ {
- case lit~"^^"~dt => rdf.TypedLiteral(lit.substring(1,lit.size - 1), dt match {
- case rdf.IRI("http://www.w3.org/2001/XMLSchema#string") => rdf.StringDatatype
- case rdf.IRI("http://www.w3.org/2001/XMLSchema#integer") => rdf.IntegerDatatype
- case rdf.IRI("http://www.w3.org/2001/XMLSchema#float") => rdf.FloatDatatype
- case rdf.IRI("http://www.w3.org/2001/XMLSchema#date") => rdf.DateDatatype
- case rdf.IRI("http://www.w3.org/2001/XMLSchema#dateTime") => rdf.DateTimeDatatype
- case x => sys.error("only programed to deal with string and integer, not " + x)
- })
- } |
- stringLiteral ^^ {
- case lit => rdf.PlainLiteral(lit.substring(1,lit.size - 1), None)
- } |
- float ^^ { l => rdf.TypedLiteral(l, rdf.FloatDatatype) } |
- integer ^^ { l => rdf.TypedLiteral(l, rdf.IntegerDatatype) }
- )
-
- def subject(implicit rdf: RDFModel): Parser[rdf.Subject] = {
- qnameORuri ^^ { case x => rdf.SubjectNode(rdf.NodeIRI(x)) } |
- bnode ^^ { case x => rdf.SubjectNode(rdf.NodeBNode(x)) }
- }
-
- def predicate(implicit rdf: RDFModel): Parser[rdf.Predicate] = (
- qnameORuri ^^ { case x => rdf.PredicateIRI(x) }
- | "a" ^^ { x => rdf.PredicateIRI(rdf.IRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")) }
- )
-
- def objectt(implicit rdf: RDFModel): Parser[rdf.Object] = {
- qnameORuri ^^ { case x => rdf.ObjectNode(rdf.NodeIRI(x)) } |
- bnode ^^ { case x => rdf.ObjectNode(rdf.NodeBNode(x)) } |
- literal ^^ { case x => rdf.ObjectLiteral(x) }
- }
-
- def qnameORuri(implicit rdf: RDFModel): Parser[rdf.IRI] = (
- "<"~uri~">" ^^ { case "<"~x~">" => rdf.IRI(x) } |
- name~":"~name ^^ {
- case prefix~":"~localName => try {
- rdf.IRI(prefixes(prefix) + localName)
- } catch {
- case e:java.util.NoSuchElementException =>
- throw new Exception("unknown prefix " + prefix)
- }
- }
- )
-
-}
-
-// as the Module type does not escape from any method here, we can pass it at the constructor level
-class TurtleSerializer[M <: RDFModel] {
-
- type M = ConcreteRDFModel
-
- def showAsString(rdf: M)(g: rdf.Graph): String = {
- g map {
- t => {
- println(t)
- val rdf.Triple(rdf.SubjectNode(s), rdf.PredicateIRI(p), o) = t
- println(s)
- println(p)
- println(o)
- "%s %s %s" format (nodeStr(rdf)(s), iriStr(rdf)(p), objectStr(rdf)(o))
- }
- } mkString "\n"
- }
-
- private def objectStr(rdf: M)(n: rdf.Object): String = {
- n match {
- // case l:ObjectLiteral => {
- // val x:ObjectLiteral = l
- // "**ObjectLiteral(" + x + ")**"
- // }
- case rdf.ObjectNode(n) => nodeStr(rdf)(n)
- case rdf.ObjectLiteral(l) => literalStr(rdf)(l)
- // case x => x
- }
- }
-
- private def nodeStr(rdf: M)(n: rdf.Node): String = {
- n match {
- case rdf.NodeIRI(i) => iriStr(rdf)(i)
- case rdf.NodeBNode(b) => bnodeStr(rdf)(b)
- }
- }
-
- private def iriStr(rdf: M)(i: rdf.IRI): String =
- "<%s>" format { val rdf.IRI(s) = i; s }
-
- private def bnodeStr(rdf: M)(b: rdf.BNode): String =
- "_:" + { val rdf.BNode(l) = b; l }
-
- private def literalStr(rdf: M)(l: rdf.Literal): String = l.toString
-
-}
-