RDF2Manifest

Type Members

type RDFParser[a] = (RDFNode, RDFReader) ⇒ Try[a]

Definition Classes
RDFParser

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def action: RDFParser[ManifestAction]

Definition Classes
RDF2Manifest
val appender: ConsoleAppender

Definition Classes
Logging
val appenders: List[Any]

Definition Classes
Logging
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def debug(msg: String): Unit

Definition Classes
Logging
def entries: RDFParser[Seq[Entry]]

Definition Classes
RDF2Manifest
def entry: RDFParser[Entry]

Definition Classes
RDF2Manifest
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail[A](str: String): Try[A]

Definition Classes
RDFParser
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getEntryType(node: RDFNode): Try[EntryType]

Definition Classes
RDF2Manifest
def getIntegerLiteral(t: RDFTriple): Try[Integer]

Definition Classes
RDFParser
def group[A](parser: RDFParser[A], nodes: Seq[RDFNode]): RDFParser[Seq[A]]

Definition Classes
RDFParser
def hasNoRDFType(t: IRI): RDFParser[Boolean]

Definition Classes
RDFParser
def hasPredicateWithSubject(n: RDFNode, p: IRI, rdf: RDFReader): Boolean

Definition Classes
RDFParser
def hasRDFType(t: IRI): RDFParser[Boolean]

Definition Classes
RDFParser
def hasSomeRDFType(ts: Set[IRI]): RDFParser[Boolean]

Definition Classes
RDFParser
def hashCode(): Int

Definition Classes
AnyRef → Any
def includes(derefIncludes: Boolean): RDFParser[List[(IRI, Option[Manifest])]]

Definition Classes
RDF2Manifest
def info(msg: String): Unit

Definition Classes
Logging
def integerLiteralForPredicate(p: IRI): RDFParser[Integer]

Definition Classes
RDFParser
def iriDataFormat2str(iri: IRI): Try[String]

Definition Classes
RDF2Manifest
def iriFromPredicate(p: IRI): RDFParser[IRI]

Definition Classes
RDFParser
def iriSchemaFormat2str(iri: IRI): Try[String]

Definition Classes
RDF2Manifest
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val log: Logger

Definition Classes
Logging
def manifest(derefIncludes: Boolean): RDFParser[Manifest]

Definition Classes
RDF2Manifest
def mapOptional[A, B](optA: Option[A], fn: (A) ⇒ Try[B]): Try[Option[B]]

Definition Classes
RDF2Manifest
def maybeResult: (Option[RDFNode], RDFReader) ⇒ Try[Result]

Definition Classes
RDF2Manifest
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def objectFromPredicate(p: IRI): RDFParser[RDFNode]

Definition Classes
RDFParser
def objectFromPredicateOptional(p: IRI): RDFParser[Option[RDFNode]]

Definition Classes
RDFParser
def objectsFromPredicate(p: IRI): RDFParser[Set[RDFNode]]

Definition Classes
RDFParser
def objectsFromTriples(triples: Set[RDFTriple]): Set[RDFNode]

Definition Classes
RDFParser
def oneOf[A](parsers: Seq[RDFParser[A]]): RDFParser[A]

Definition Classes
RDFParser
def oneOfPredicates(predicates: Seq[IRI]): RDFParser[IRI]

Definition Classes
RDF2Manifest
def optional[A](parser: RDFParser[A]): RDFParser[Option[A]]

Definition Classes
RDFParser
def rdf2Manifest(rdf: RDFReader, derefIncludes: Boolean): Try[Seq[Manifest]]

Definition Classes
RDF2Manifest
def rdfList: RDFParser[List[RDFNode]]

Definition Classes
RDFParser
def rdfListForPredicate(p: IRI): RDFParser[List[RDFNode]]

Definition Classes
RDFParser
def rdfType: RDFParser[RDFNode]

Definition Classes
RDFParser
def rdfTypes: RDFParser[Set[RDFNode]]

Definition Classes
RDFParser
def read(fileName: String, base: String): Try[Manifest]
def result: RDFParser[Result]

Definition Classes
RDF2Manifest
def setDebug(): Unit

Definition Classes
Logging
def setError(): Unit

Definition Classes
Logging
def setInfo(): Unit

Definition Classes
Logging
def someOf[A](ps: Seq[RDFParser[A]]): RDFParser[A]

Definition Classes
RDFParser
def stringFromPredicate(p: IRI): RDFParser[String]

Definition Classes
RDFParser
def stringFromPredicateOptional(p: IRI): RDFParser[Option[String]]

Definition Classes
RDFParser
def subjectsFromTriples(triples: Set[RDFTriple]): Set[RDFNode]

Definition Classes
RDFParser
def subjectsWithProperty(pred: IRI, rdf: RDFReader): Set[RDFNode]

Definition Classes
RDFParser
def subjectsWithType(t: RDFNode, rdf: RDFReader): Set[RDFNode]

Definition Classes
RDFParser
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: trait RDF2Manifest | package manifest

object RDF2Manifest extends RDF2Manifest

Type Members

type RDFParser[a] = (RDFNode, RDFReader) ⇒ Try[a]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def action: RDFParser[ManifestAction]

val appender: ConsoleAppender

val appenders: List[Any]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def debug(msg: String): Unit

def entries: RDFParser[Seq[Entry]]

def entry: RDFParser[Entry]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[A](str: String): Try[A]

def finalize(): Unit

final def getClass(): Class[_]

def getEntryType(node: RDFNode): Try[EntryType]

def getIntegerLiteral(t: RDFTriple): Try[Integer]

def group[A](parser: RDFParser[A], nodes: Seq[RDFNode]): RDFParser[Seq[A]]

def hasNoRDFType(t: IRI): RDFParser[Boolean]

def hasPredicateWithSubject(n: RDFNode, p: IRI, rdf: RDFReader): Boolean

def hasRDFType(t: IRI): RDFParser[Boolean]

def hasSomeRDFType(ts: Set[IRI]): RDFParser[Boolean]

def hashCode(): Int

def includes(derefIncludes: Boolean): RDFParser[List[(IRI, Option[Manifest])]]

def info(msg: String): Unit

def integerLiteralForPredicate(p: IRI): RDFParser[Integer]

def iriDataFormat2str(iri: IRI): Try[String]

def iriFromPredicate(p: IRI): RDFParser[IRI]

def iriSchemaFormat2str(iri: IRI): Try[String]

final def isInstanceOf[T0]: Boolean

lazy val log: Logger

def manifest(derefIncludes: Boolean): RDFParser[Manifest]

def mapOptional[A, B](optA: Option[A], fn: (A) ⇒ Try[B]): Try[Option[B]]

def maybeResult: (Option[RDFNode], RDFReader) ⇒ Try[Result]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def objectFromPredicate(p: IRI): RDFParser[RDFNode]

def objectFromPredicateOptional(p: IRI): RDFParser[Option[RDFNode]]

def objectsFromPredicate(p: IRI): RDFParser[Set[RDFNode]]

def objectsFromTriples(triples: Set[RDFTriple]): Set[RDFNode]

def oneOf[A](parsers: Seq[RDFParser[A]]): RDFParser[A]

def oneOfPredicates(predicates: Seq[IRI]): RDFParser[IRI]

def optional[A](parser: RDFParser[A]): RDFParser[Option[A]]

def rdf2Manifest(rdf: RDFReader, derefIncludes: Boolean): Try[Seq[Manifest]]

def rdfList: RDFParser[List[RDFNode]]

def rdfListForPredicate(p: IRI): RDFParser[List[RDFNode]]

def rdfType: RDFParser[RDFNode]

def rdfTypes: RDFParser[Set[RDFNode]]

def read(fileName: String, base: String): Try[Manifest]

def result: RDFParser[Result]

def setDebug(): Unit

def setError(): Unit

def setInfo(): Unit

def someOf[A](ps: Seq[RDFParser[A]]): RDFParser[A]

def stringFromPredicate(p: IRI): RDFParser[String]

def stringFromPredicateOptional(p: IRI): RDFParser[Option[String]]

def subjectsFromTriples(triples: Set[RDFTriple]): Set[RDFNode]

def subjectsWithProperty(pred: IRI, rdf: RDFReader): Set[RDFNode]

def subjectsWithType(t: RDFNode, rdf: RDFReader): Set[RDFNode]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from RDF2Manifest

Inherited from rdf.parser.RDFParser

Inherited from Logging

Inherited from AnyRef

Inherited from Any

Ungrouped