shex/es.weso.shex.validator/ShExChecker

ShExChecker

trait ShExChecker
class Object
trait Matchable
class Any
class Validator

Type members

Types

type Base[A] = IndexedReaderWriterStateT[[A] =>> IO[A], ConfigEnv, Log, State, State, A]
type Check[A] = EitherT[Base, Err, A]
type Env = Context
type Err = ShExError
type Evidence = (NodeShape, String)

Value members

Concrete methods

def addAction2Log(a: Action): Check[Unit]
def addEvidence(nodeShape: NodeShape, msg: String): Check[ShapeTyping]
def addLog(log: Log): Check[Unit]
def addNotEvidence(nodeShape: NodeShape, e: ShExError, msg: String): Check[ShapeTyping]
def attempt[A](c: Check[A]): Check[Either[Err, A]]
def bind[A, Other](c1: Check[Other], c2: Check[A]): Check[A]
def checkAll[A](xs: List[Check[A]]): Check[List[A]]

Checks all elements in a list If any of the elements fails, it fails

Checks all elements in a list If any of the elements fails, it fails

def checkAllFailFAtFirstFlag[A, B, F[_]](ls: => LazyList[A], check: A => F[(B, Boolean)], last: => B)(implicit evidence$5: Monoid[B], evidence$6: Monad[F]): F[(B, Boolean)]
def checkAllFlag[A, B, F[_]](ls: => LazyList[A], check: A => F[(B, Boolean)], last: => B)(implicit evidence$3: Monoid[B], evidence$4: Monad[F]): F[(B, Boolean)]
def checkCond(condition: Boolean, attempt: Attempt, error: ShExError, evidence: String): CheckTyping
def checkList[A, B](ls: List[A], check: A => Check[B]): Check[List[B]]
def checkLs[A](cs: List[Check[A]]): Check[List[A]]

Given a list of checks, return the list of values that pass It never fails (in case of failure, it ignores the value)

Given a list of checks, return the list of values that pass It never fails (in case of failure, it ignores the value)

def checkOneOf[A](cs: List[Check[A]], errNone: Err, errMoreThanOne: List[A] => Err): Check[A]
def checkPair1st[A, B](p: (Check[A], B)): Check[(A, B)]
def checkPair2nd[A, B](p: (A, Check[B])): Check[(A, B)]
def checkSequenceFlag[A, F[_]](ls: => List[F[(A, Boolean)]], last: A)(implicit evidence$7: Monoid[A], evidence$8: Monad[F]): F[(A, Boolean)]
def checkSome[A](cs: List[Check[A]], errorIfNone: Err): Check[A]
def checkSome[A](cs: LazyList[Check[A]])(implicit ev: Monoid[Err]): Check[A]
def checkSomeFlag[A, B, F[_]](ls: => LazyList[A], check: A => F[(B, Boolean)], last: F[(B, Boolean)])(implicit evidence$1: Monad[F]): F[(B, Boolean)]

Given a computation check that returns a pair of value and a flag, returns the first value whose flag is true If none is true, returns the value of the computation parameter last

Given a computation check that returns a pair of value and a flag, returns the first value whose flag is true If none is true, returns the value of the computation parameter last

def checkSomeFlagCount[A, B](ls: => LazyList[A], check: A => Check[(B, Boolean)], last: B)(implicit evidence$2: Monoid[B]): Check[(B, Int)]
def checkSomeFlagValue[A, B](ls: => LazyList[A], check: A => Check[B], last: Check[B]): Check[(B, Option[A])]
def checkSomeLazyList[A](cs: LazyList[Check[A]], errIfNone: => Err): Check[A]
def cond[A, B](check: Check[A], thenPart: A => Check[B], elsePart: Err => Check[B]): Check[B]

Attempts to execute a check If it fails, applies thenPart to the result, otherwise applies elsePart to the error

Attempts to execute a check If it fails, applies thenPart to the result, otherwise applies elsePart to the error

Type Params
A

type returned by the computation

B

type returned the the condition

Value Params
check

Computation to check

elsePart

part to be executed when the check fails

thenPart

part to be executed when it passes

def condFlag[A, B](check: Check[A], thenPart: A => Check[B], elsePart: Err => Check[B]): Check[(B, Boolean)]
def err[A](e: Err): Check[A]
def errStr[A](msg: String): Check[A]
def filterSuccess[A, B](ls: List[A], check: A => Check[B]): Check[List[(A, B)]]

Returns the list of values whose computation is successful

Returns the list of values whose computation is successful

Type Params
A

type of values

B

type returned by computation

Value Params
check

computation to check for each value

ls

list of values

Returns

a computation with a list of pairs for whom the computation was successful

def fromBase[A](b: Base[A]): Check[A]
def fromEither[A](e: Either[Err, A]): Check[A]
def fromEitherIO[A](e: EitherT[[A] =>> IO[A], Err, A]): Check[A]
def fromEitherIOS[A](e: EitherT[[A] =>> IO[A], String, A]): Check[A]
def fromEitherString[A](e: Either[String, A]): Check[A]
def fromIO[A](io: IO[A]): Check[A]
def fromIOUnsafe[A](io: IO[A]): Check[A]
def fromStream[A](s: Stream[[A] =>> IO[A], A]): Check[List[A]]
def getNeighPaths(node: RDFNode, paths: List[Path]): Check[Neighs]
def getNeighs(node: RDFNode): Check[Neighs]
def getNodesPrefixMap: Check[PrefixMap]
def getNotAllowedPredicates(node: RDFNode, paths: List[Path], neighs: Neighs): Check[Set[IRI]]
def getPaths(s: Shape, schema: ResolvedSchema): Check[List[Path]]
def getRDF: Check[RDFReader]
def getTargetNodeDeclarations(rdf: RDFReader): Check[List[(RDFNode, ShapeLabel)]]
def getValuesPath(node: RDFNode, path: Path): Check[Set[RDFNode]]
def getVerbose: Check[Boolean]
def info(msg: String): Check[Unit]
def infoTyping(t: ShapeTyping, msg: String, shapesPrefixMap: PrefixMap): Check[Unit]
def local[A](f: Env => Env)(comp: Check[A]): Check[A]
def mkErr[F[_]](e: Err)(implicit evidence$9: Applicative[F]): F[Err]
def mkLabel(label: ShapeMapLabel): ShapeLabel
def mkSeq[A, B](vs: List[A], f: A => IO[List[B]]): IO[List[B]]
def ok[A](x: A): Check[A]
def optCheck[A, B](c: Option[A], check: A => Check[B], default: => Check[B]): Check[B]

If c is some value, applies check, otherwise applies default

If c is some value, applies check, otherwise applies default

Value Params
c

Optional value

check

check function

default

value in case there is no option

def orElse[A](c1: Check[A], c2: => Check[A]): Check[A]
def run[A](c: Check[A])(config: Config)(env: Env): IO[(Log, Either[Err, A])]
def runCheck[A](c: Check[A], rdf: RDFReader, verbose: Boolean)(implicit evidence$10: Show[A]): IO[CheckResult[ShExError, A, Log]]
def runLocal[A](c: Check[A], f: Env => Env): Check[A]
def runLocalNeighs[A](c: Check[A], node: RDFNode, neighs: Neighs): Check[A]
def runLocalSafe[A](c: Check[A], f: Env => Env, safe: (Err, Env) => A): Check[A]

Run a computation in a local environment. If the computation fails, return the result of calling safe function over the current environment

Run a computation in a local environment. If the computation fails, return the result of calling safe function over the current environment

Value Params
c

computation to run

f

environment

safe

function to call if the computation fails

def runLocalSafeTyping[A](c: Check[A], f: ShapeTyping => ShapeTyping, safe: (Err, ShapeTyping) => A): Check[A]
def sequence[A](xs: List[Check[A]]): Check[List[A]]
def showCurrentTyping(msg: String, shapesPrefixMap: PrefixMap): Check[Unit]
def validateCheck(condition: Boolean, e: Err): Check[Unit]

Abstract fields

val builder: RDFBuilder

Concrete fields

lazy val ignoredPathsClosed: List[Path]