svn commit: r1141667 - /incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala

[re...@apache.org]

Author: reto
Date: Thu Jun 30 18:58:49 2011
New Revision: 1141667

URL: http://svn.apache.org/viewvc?rev=1141667&view=rev
Log:
CLEREZZA-510: splitting things to different files as a first refactoring step

Added:
    incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala

Added: incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala
URL: http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala?rev=1141667&view=auto
==============================================================================
--- incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala (added)
+++ incubator/clerezza/issues/CLEREZZA-510-reto/rdf.scala.utils/src/main/scala/org/apache/clerezza/rdf/scala/utils/AltStyles.scala Thu Jun 30 18:58:49 2011
@@ -0,0 +1,226 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.clerezza.rdf.scala.utils
+
+import java.math.BigInteger
+import java.lang.Boolean
+import java.net.{URL, URI}
+import org.apache.clerezza.rdf.ontologies.{XSD, RDF}
+import java.util.Date
+import collection.mutable.{ListBuffer, HashMap}
+import org.apache.clerezza.rdf.utils.{GraphNode, UnionMGraph}
+import org.apache.clerezza.rdf.core._
+import org.apache.clerezza.rdf.core.impl._
+
+/**
+ * Alternative method names for some RichGraphNode methods allowing alternative
+ * DSL syntaxes
+ */
+class AltStyles {
+
+}
+
+/**
+ * import your preferred writing styles into your code
+ */
+object EzStyleChoice {
+	implicit val unicode = new EzStyle[EzGraphNodeU](){
+		override def preferred(ref: NonLiteral, tc: TripleCollection): EzGraphNodeU = new EzGraphNodeU(ref,tc)
+	}
+	implicit val arrow = new EzStyle[EzGraphNodeA](){
+		override def preferred(ref: NonLiteral, tc: TripleCollection): EzGraphNodeA = new EzGraphNodeA(ref,tc)
+	}
+   implicit val english = new EzStyle[EzGraphNodeEn](){
+		override def preferred(ref: NonLiteral, tc: TripleCollection): EzGraphNodeEn = new EzGraphNodeEn(ref,tc)
+	}
+
+
+}
+
+
+
+/**
+ * Unicode arrow notation for EzGraphNode. Very clean, short and efficient, but unicode values may not
+ * be available everywhere yet.
+ *
+ * Because of operator binding rules all the mathematical operators  bind the strongest. This means that
+ * anything outside of these operators should be put into brackets or use dot notation if you wish them to
+ * bind more tightly.
+ *
+ *
+ * @prefix graph: should this be an MGraph, since the EzGraphNode is really designed for editing
+ *
+ */
+class EzGraphNodeU(ref: NonLiteral, graph: TripleCollection) extends EzGraphNode(ref, graph) {
+	//
+	// symbolic notation
+	//
+	// (shorter and more predictable precedence rules, but unicode issues)
+
+	type T_Pred = PredicateU
+	type T_InvP = InversePredicateU
+	type T_EzGN = EzGraphNodeU
+
+	override def make(ref: NonLiteral, graph: TripleCollection) = new EzGraphNodeU(ref,graph)
+	override def predicate(rel: UriRef) = new PredicateU(rel)
+	override def inverse(rel: UriRef) = new InversePredicateU(rel)
+
+	/**
+	 * relate the subject via the given relation to....
+	 */
+	def ⟝(rel: UriRef) = predicate(rel)
+
+	/**
+	 * relate the subject via the given relation to....
+	 */
+	def ⟝(rel: String) = predicate(new UriRef(rel))
+
+	/**
+	 * relate the subject via the inverse of the given relation to....
+	 */
+	def ⟵(rel: UriRef) = inverse(rel)
+
+	/**
+	 * the subject is a member of the given class
+	 */
+	def ∈(rdfclass: UriRef) = a(rdfclass)
+
+
+	class InversePredicateU(rel: UriRef) extends InversePredicate(rel) {
+		/**
+		 * ...to the following non literal
+		 */
+		def ⟞(subj: NonLiteral) = add(subj)
+
+		/**
+		 * ...to the following resource (given as a string)
+		 */
+		def ⟞(uri: String) = add(new UriRef(uri))
+
+		/**
+		 * ...to the following EzGraphNode
+		 * (useful for opening a new parenthesis and specifying other things in more detail
+		 */
+		def ⟞(sub: EzGraphNodeU)  = addGN(sub)
+	}
+
+	class PredicateU(rel: UriRef) extends Predicate(rel) {
+
+		/**
+		 * ...to the following resource
+		 */
+		def ⟶(obj: Resource) = add(obj)
+
+		/**
+		 * ...to the following list as an RDF List
+		 */
+		def ⟶(list: List[Resource]) = addList(list)
+
+		/**
+		 * Add one relation for each member of the iterable collection
+		 */
+		def ⟶*[T <: Resource](objs: Iterable[T]) = addMany(objs)
+
+		/**
+		 * ...to the EzGraphNode, which is useful for opening a parenthesis.
+		 */
+		def ⟶(sub: EzGraphNode) = addEG(sub)
+
+	}
+
+
+}
+
+/**
+ * English language looking Notation for EzGraphNode. This feels gives somewhat awkward
+ * english, but the operator binding priorities for ascii named operators is the weakest, which
+ * means that one needs very few parenthesis when writing out the code as all other operators bind
+ * more tightly.
+ */
+class EzGraphNodeEn(ref: NonLiteral, graph: TripleCollection) extends EzGraphNode(ref, graph) {
+
+	type T_Pred = PredicateEn
+	type T_InvP = InversePredicateEn
+	type T_EzGN = EzGraphNodeEn
+
+	override protected def make(ref: NonLiteral, graph: TripleCollection) = new EzGraphNodeEn(ref,graph)
+	override protected def predicate(rel: UriRef) = new PredicateEn(rel)
+	override protected def inverse(rel: UriRef) = new InversePredicateEn(rel)
+
+	/**
+	 * the subject has the given relation to....
+	 */
+	def has(rel: UriRef) = predicate(rel)
+
+	/**
+	 * the subject has the given relation (specified as string) to....
+	 */
+	def has(rel: String) = predicate(new UriRef(rel))
+
+	/**
+	 * the subject is the inverse relation of ...
+	 */
+	def is(rel: UriRef) = inverse(rel)
+
+	class InversePredicateEn(rel: UriRef) extends InversePredicate(rel) {
+
+
+		/**
+		  * ...the following non literal
+		  */
+		def of(subj: NonLiteral) = add(subj)
+
+		/**
+		  * ...the following resource (as String)
+		  */
+		def of(subj: String) = add(new UriRef(subj))
+
+		/**
+		  * ...the following EzGraphNode - useful for opening a new bracket
+		  */
+		def of(subj: EzGraphNode) = addGN(subj)
+	}
+
+	class PredicateEn(rel: UriRef) extends Predicate(rel) {
+
+
+		/**
+		 * ...to the following resource
+		 */
+		def to(obj: Resource) = add(obj)
+
+		/**
+		 * ...to the following RDF list
+		 */
+		def to(list: List[Resource]) = addList(list)
+
+		/**
+		 * ... each of the members of the iterable collection
+		 */
+		def toEach[T <: Resource](objs: Iterable[T]) = addMany(objs)
+
+		/**
+		 * ...to the EzGraphNode, which is useful for opening a parenthesis.
+		 */
+		def to(sub: EzGraphNode) = addEG(sub)
+
+	}
+
+}
\ No newline at end of file