Rule

Type Members

case class AlwaysPass[A] extends Rule[A] with Product with Serializable
case class Between[A] extends Rule[A] with Product with Serializable
case class ForEachInList[A](inner: Rule[A]) extends Rule[List[A]] with Product with Serializable
case class LengthBetween[A] extends Rule[A] with Product with Serializable
case class MatchesRegex extends Rule[String] with Product with Serializable
case class Max[A] extends Rule[A] with Product with Serializable
case class MaxLength[A] extends Rule[A] with Product with Serializable
case class Min[A] extends Rule[A] with Product with Serializable
case class MinLength[A] extends Rule[A] with Product with Serializable
case class NonEmpty[A] extends Rule[A] with Product with Serializable

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 alwaysPass[A]: Rule[A]

The simplest validation rule - accepts any value
final def asInstanceOf[T0]: T0

Definition Classes
Any
def between[A](minValue: A, maxValue: A)(implicit arg0: Order[A]): Rule[A]

Assert that the input value must come after, or in the same position as, minValue but before or in the same position as maxValue if the elements were put in order.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cond[A](predicate: (A) ⇒ Boolean, errorMsg: String, args: Any*): Rule[A]

A custom rule from a predicate and an error message
def condAtPath[A](pathHead: String, pathTail: String*)(predicate: (A) ⇒ Boolean, errorMsg: String, args: Any*): Rule[A]

A custom rule from a predicate and an error message to be applied to a supplied path
def condError[A](predicate: (A) ⇒ Boolean, errorTree: ErrorTree): Rule[A]

A custom rule from a predicate and an error tree
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def error(errorMsg: String, args: Any*): ErrorTree
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def lengthBetween[A](min: Int, max: Int)(implicit arg0: Quantifiable[A]): Rule[A]

Assert that there are at least len elements, but no more than max
def matchesRegex(regex: String, errorMsg: String = "format"): Rule[String]

Assert that the input string matches the given regular expression
def max[A](maxValue: A, errorMsg: String = "max")(implicit arg0: Order[A]): Rule[A]

Assert that the input value must come before, or in the same position as, maxValue if the elements were put in order
def maxLength[A](len: Int, errorMsg: String = "maxLength")(implicit arg0: Quantifiable[A]): Rule[A]

Assert that there are no more than len elements
def min[A](minValue: A, errorMsg: String = "min")(implicit arg0: Order[A]): Rule[A]

Assert that the input value must come after, or in the same position as, minValue if the elements were put in order
def minLength[A](len: Int, errorMsg: String = "minLength")(implicit arg0: Quantifiable[A]): Rule[A]

Assert that there are at least len elements
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nonEmpty[A](implicit arg0: Empty[A]): Rule[A]

Assert that the input is not empty (in the sense of a monoid being 'empty')
def nonEmpty[A](errorMsg: String)(implicit arg0: Empty[A]): Rule[A]

Assert that the input is not empty (in the sense of a monoid being 'empty')
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

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

Definition Classes
AnyRef
implicit def toQuantifiableOps[A](target: A)(implicit tc: Quantifiable[A]): Ops[A] { type TypeClassType = ltbs.uniform.validation.Quantifiable[A] }

Definition Classes
ToQuantifiableOps
Annotations
@SuppressWarnings()
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 Doc: package validation

object Rule extends ToQuantifiableOps

Type Members

case class AlwaysPass[A] extends Rule[A] with Product with Serializable

case class Between[A] extends Rule[A] with Product with Serializable

case class ForEachInList[A](inner: Rule[A]) extends Rule[List[A]] with Product with Serializable

case class LengthBetween[A] extends Rule[A] with Product with Serializable

case class MatchesRegex extends Rule[String] with Product with Serializable

case class Max[A] extends Rule[A] with Product with Serializable

case class MaxLength[A] extends Rule[A] with Product with Serializable

case class Min[A] extends Rule[A] with Product with Serializable

case class MinLength[A] extends Rule[A] with Product with Serializable

case class NonEmpty[A] extends Rule[A] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def alwaysPass[A]: Rule[A]

final def asInstanceOf[T0]: T0

def between[A](minValue: A, maxValue: A)(implicit arg0: Order[A]): Rule[A]

def clone(): AnyRef

def cond[A](predicate: (A) ⇒ Boolean, errorMsg: String, args: Any*): Rule[A]

def condAtPath[A](pathHead: String, pathTail: String*)(predicate: (A) ⇒ Boolean, errorMsg: String, args: Any*): Rule[A]

def condError[A](predicate: (A) ⇒ Boolean, errorTree: ErrorTree): Rule[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(errorMsg: String, args: Any*): ErrorTree

def finalize(): Unit

def forEachInList[A](inner: Rule[A]): Rule[List[A]]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def lengthBetween[A](min: Int, max: Int)(implicit arg0: Quantifiable[A]): Rule[A]

def matchesRegex(regex: String, errorMsg: String = "format"): Rule[String]

def max[A](maxValue: A, errorMsg: String = "max")(implicit arg0: Order[A]): Rule[A]

def maxLength[A](len: Int, errorMsg: String = "maxLength")(implicit arg0: Quantifiable[A]): Rule[A]

def min[A](minValue: A, errorMsg: String = "min")(implicit arg0: Order[A]): Rule[A]

def minLength[A](len: Int, errorMsg: String = "minLength")(implicit arg0: Quantifiable[A]): Rule[A]

final def ne(arg0: AnyRef): Boolean

def nonEmpty[A](implicit arg0: Empty[A]): Rule[A]

def nonEmpty[A](errorMsg: String)(implicit arg0: Empty[A]): Rule[A]

final def notify(): Unit

final def notifyAll(): Unit

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

implicit def toQuantifiableOps[A](target: A)(implicit tc: Quantifiable[A]): Ops[A] { type TypeClassType = ltbs.uniform.validation.Quantifiable[A] }

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from ToQuantifiableOps

Inherited from AnyRef

Inherited from Any

Ungrouped

def condAtPath[A](pathHead: String, pathTail: String)(predicate: (A) ⇒ Boolean, errorMsg: String, args: Any): Rule[A]