QBSchema

Type Members

case class AnnotatedQBType(qbType: QBType, annotations: List[QBAnnotation]) extends QBType with Product with Serializable

DSL helper class
case class BuildDescription(descriptions: List[(QBClass, String)]) extends Product with Serializable

Definition Classes
QBBaseSchemaOps
implicit class QBFieldExtensionOps extends AnyRef

Definition Classes
QBBaseSchemaOps
implicit class QBSchemaOps extends AnyRef

Schema Ops Extensions ----------------------------------------------------------
type QBStringPath = List[String]

Definition Classes
QBBaseSchemaOps

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
object BuildDescription extends Serializable

Definition Classes
QBBaseSchemaOps
val ExclusiveMaximum: String

Definition Classes
JSONSchemaWrites
val ExclusiveMinimum: String

Definition Classes
JSONSchemaWrites
val MaximumId: String

Definition Classes
JSONSchemaWrites
val MinimumId: String

Definition Classes
JSONSchemaWrites
val MultipleOf: String

Definition Classes
JSONSchemaWrites
val PatternId: String

Definition Classes
JSONSchemaWrites
object UnReadable extends Reads[QBType]

Definition Classes
JSONSchemaReads
def adaptSchema[A](schema: QBType, path: JsPath, adapter: (JsPath, QBType) ⇒ JsResult[JsValue]): JsResult[JsValue]

Definition Classes
QBBaseSchemaOps
def add(schema: QBClass)(path: QBStringPath, attributes: Seq[QBAttribute]): QBClass

Adds the given fields to the object located at the path of the given object.
Adds the given fields to the object located at the path of the given object.
schema
the schema to which the attributes should be added
path
the path within the given schema at which the attributes should be added
attributes
the actual attributes to be added

Definition Classes
QBBaseSchemaOps
def allNonOptionalAttributes(fields: Seq[QBAttribute]): Seq[JsString]

Definition Classes
JSONSchemaAnnotationWrites
def areEqual(schema: QBClass, otherSchema: QBClass): Boolean

Compares the schema with each other
Compares the schema with each other
schema
the schema to be compared
otherSchema
the schema to be compared against the first one
returns
true, if the schemas are equal, false otherwise

Definition Classes
QBBaseSchemaOps
implicit def arrayReader: Reads[QBArray]

Definition Classes
JSONSchemaReads
implicit def arrayWriter: Writes[QBArray]

Definition Classes
JSONSchemaWrites
final def asInstanceOf[T0]: T0

Definition Classes
Any
def attribute(obj: QBClass, fieldName: String): QBAttribute

Definition Classes
QBBaseSchemaOps
implicit def booleanReader: Reads[QBBoolean]

Definition Classes
JSONSchemaReads
implicit def booleanWriter: Writes[QBBoolean]

Definition Classes
JSONSchemaWrites
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collapse[A <: QBType, B](obj: QBClass)(modifier: (QBAttribute) ⇒ B)(implicit arg0: ClassTag[A], arg1: Monoid[B]): B

Definition Classes
QBBaseSchemaOps
def collapseWithPath[B](matcher: (QBType) ⇒ Boolean)(obj: QBClass)(modifier: (QBAttribute, JsPath) ⇒ B)(implicit arg0: Monoid[B]): B

Definition Classes
QBBaseSchemaOps
def default(qbType: QBType, default: JsValue): AnnotatedQBType

Annotations
Annotations

Definition Classes
QBSchemaDSL
def defaultExtension(attr: QBAttribute): JsObject

Definition Classes
JSONSchemaAnnotationWrites
val emptyJsObject: JsObject

Definition Classes
JSONSchemaAnnotationWrites
def emptyPath: QBStringPath

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

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

Definition Classes
AnyRef → Any
def exclusiveMax(n: Double): MaxRule

Definition Classes
QBSchemaDSL
def exclusiveMax(n: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def exclusiveMin(n: Double): MinRule

Definition Classes
QBSchemaDSL
def exclusiveMin(n: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def extensions: List[(QBClass) ⇒ JsObject]

Extensions which act on a object and produce a result which contains information about multiple fields.
Extensions which act on a object and produce a result which contains information about multiple fields. For instance, required property.

Definition Classes
JSONSchemaAnnotationWrites → JSONSchemaWrites
def extract(obj1: QBClass, obj2: QBClass): QBClass

Removes all attributes from the first schema that are also part of the second given schema.
Removes all attributes from the first schema that are also part of the second given schema.

Definition Classes
QBBaseSchemaOps
def fail[A](msg: String): Nothing

Definition Classes
QBBaseSchemaOps
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 hashCode(): Int

Definition Classes
AnyRef → Any
implicit def integerReader: Reads[QBInteger]

Definition Classes
JSONSchemaReads
implicit def integerWriter: Writes[QBInteger]

Definition Classes
JSONSchemaWrites
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isSubSet(subSchema: QBClass, schema: QBClass): Boolean

Checks whether the schema is a subset of the given schema.
Checks whether the schema is a subset of the given schema.
subSchema
the schema that is supposed to be a subset
schema
the schema to check the sub schema against
returns
true, if the sub schema is a subset of the schema

Definition Classes
QBBaseSchemaOps
def length(lower: Int, upper: Int): ValidationRule[JsString]

Definition Classes
QBSchemaDSL
def makeOptional(root: QBClass, paths: List[QBStringPath]): QBClass

Makes all values referenced by the given list of paths optional.
Makes all values referenced by the given list of paths optional.

Definition Classes
QBBaseSchemaOps
def makeReadOnly(schema: QBClass, paths: List[QBStringPath]): QBClass

Marks all values referenced by the given list of paths as read-only.
Marks all values referenced by the given list of paths as read-only.
schema
the schema that is supposed to contain the attributes that are referenced by the given paths
returns
the updated schema with the referenced attributes being marked as read-only

Definition Classes
QBBaseSchemaOps
def max(n: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def max(n: Double): MaxRule

Definition Classes
QBSchemaDSL
def maxLength(n: Int): MaxLengthRule

Definition Classes
QBSchemaDSL
def maxProperties(max: Int): MaxPropertiesRule

Definition Classes
QBSchemaDSL
def merge(schema: QBClass, otherSchema: QBClass): QBClass

Merges the attributes of the second schema into the first one.
Merges the attributes of the second schema into the first one.
schema
the target schema
otherSchema
the schema to be merged into the target schema

Definition Classes
QBBaseSchemaOps
def min(n: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def min(n: Double): MinRule

Definition Classes
QBSchemaDSL
def minLength(n: Int): MinLengthRule

Definition Classes
QBSchemaDSL
def minProperties(min: Int): MinPropertiesRule

Definition Classes
QBSchemaDSL
def multipleOf(n: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def multipleOf(n: Double): MultipleOfRule

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
implicit def numberReader: Reads[QBNumber]

Definition Classes
JSONSchemaReads
implicit def numberWriter: Writes[QBNumber]

Definition Classes
JSONSchemaWrites
implicit def objectReader: Reads[QBClass]

Definition Classes
JSONSchemaReads
implicit def objectWriter: Writes[QBClass]

Definition Classes
JSONSchemaWrites
def oneOf(values: QBClass*): QBOneOfImpl

Object Rules
Object Rules

Definition Classes
QBSchemaDSL
def optional(qbType: QBType, defaultValue: JsValue): AnnotatedQBType

Mark the attribute as optional with a default value that is used in case the attribute is not present.
Mark the attribute as optional with a default value that is used in case the attribute is not present.

Definition Classes
QBSchemaDSL
def optional(qbType: QBType): AnnotatedQBType

Mark the attribute as optional.
Mark the attribute as optional.

Definition Classes
QBSchemaDSL
def optionalExtension(obj: QBClass): JsObject

Definition Classes
JSONSchemaAnnotationWrites
def pathOfSubSchema(schema: QBClass, subSchema: QBClass): Option[String]

Returns the path of the given subschema, if it is contained in the schema.
Returns the path of the given subschema, if it is contained in the schema.
schema
the schema that is supposed to contain the sub-schema
subSchema
the sub-schema that is supposed to be contained in the first schema
returns
the path of sub-schema in the schema, if it is contained, None otherwise

Definition Classes
QBBaseSchemaOps
def pattern(regex: String, errMessage: String = "qb.invalid.pattern"): RegexRule

Definition Classes
QBSchemaDSL
def propertyExtensions: List[(QBAttribute) ⇒ JsObject]

Extensions whose result gets merged into the written property like, for instance, the type:
Extensions whose result gets merged into the written property like, for instance, the type:

Definition Classes
JSONSchemaAnnotationWrites → JSONSchemaWrites
def qbBoolean: QBBoolean

Boolean Rules
Boolean Rules

Definition Classes
QBSchemaDSL
def qbClass(els: List[(String, QBType)], rules: ValidationRule[JsObject]*): QBClass

Definition Classes
QBSchemaDSL
def qbClass(els: (String, QBType)*): QBClass

Definition Classes
QBSchemaDSL
def qbClass(els: List[(String, QBType)])(): QBClass

Classes.
Classes.

Definition Classes
QBSchemaDSL
def qbDateTime: QBDateTimeImpl

Definition Classes
QBSchemaDSL
def qbEmail: QBString

Definition Classes
QBSchemaDSL
def qbEnum(values: String*): QBString

Definition Classes
QBSchemaDSL
def qbId: QBStringImpl

Definition Classes
QBSchemaDSL
def qbInteger(rules: DoubleRuleWrapper*): QBIntegerImpl

Definition Classes
QBSchemaDSL
def qbInteger: QBIntegerImpl

Definition Classes
QBSchemaDSL
def qbList(dataType: ⇒ QBType, rules: ValidationRule[JsArray]*): QBArray

Definition Classes
QBSchemaDSL
def qbList(dataType: ⇒ QBType): QBArray

Array Rules
Array Rules

Definition Classes
QBSchemaDSL
def qbNonEmptyText: QBString

Definition Classes
QBSchemaDSL
def qbNumber(rules: ValidationRule[JsNumber]*): QBNumber

Definition Classes
QBSchemaDSL
def qbNumber: QBNumberImpl

Number Rules
Number Rules

Definition Classes
QBSchemaDSL
def qbPosixTime: QBPosixTimeImpl

Definition Classes
QBSchemaDSL
def qbString: QBStringImpl

Definition Classes
QBSchemaDSL
def qbString(rules: ValidationRule[JsString]*): QBString

String Rules
String Rules

Definition Classes
QBSchemaDSL
def qbText: QBStringImpl

Definition Classes
QBSchemaDSL
implicit def qbTypeWriter: Writes[QBType]

Definition Classes
JSONSchemaWrites
def range(lower: Int, upper: Int): DoubleRuleWrapper

Definition Classes
QBSchemaDSL
def range(lower: Double, upper: Double): ValidationRule[JsNumber]

Definition Classes
QBSchemaDSL
def readOnly(qbType: QBType): AnnotatedQBType

Mark the attribute as read-only.
Mark the attribute as read-only.

Definition Classes
QBSchemaDSL
def readOnlyExtension(attr: QBAttribute): JsObject

Definition Classes
JSONSchemaAnnotationWrites
def remove(schema: QBClass, paths: Seq[QBStringPath]): QBClass

Removes all values that are referenced by the list of paths within the given object.
Removes all values that are referenced by the list of paths within the given object.
schema
the schema from which to remove attributes
paths
the paths to the attributes that are to be removed

Definition Classes
QBBaseSchemaOps
def renameAttribute(root: QBClass)(path: QBStringPath, newFieldName: String): QBClass

Renames the field located at the given path.
Renames the field located at the given path.
Example: Given an schema obj("a" -> obj("b" -> integer)) rename(List("a","b"), "c") will change the object to obj("a" -> obj("c" -> integer)).

Definition Classes
QBBaseSchemaOps
def resolve(path: QBStringPath, resolvable: QBClass): (BuildDescription, QBType)

Resolves the given path starting from the given resolvable.
Resolves the given path starting from the given resolvable.

Definition Classes
QBBaseSchemaOps
def resolvePath[A <: QBType](obj: QBClass)(path: QBStringPath): A

Resolves the given path.
Resolves the given path.

Definition Classes
QBBaseSchemaOps
def retain(root: QBClass)(path: QBStringPath, fields: Seq[String]): QBClass

Retains all fields of the object at the given path based on the name of the fields.
Retains all fields of the object at the given path based on the name of the fields.

Definition Classes
QBBaseSchemaOps
implicit def string2QBPath(str: String): QBStringPath

Definition Classes
QBBaseSchemaOps
implicit def stringReader: Reads[QBString]

Definition Classes
JSONSchemaReads
implicit def stringWriter: Writes[QBString]

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

Definition Classes
AnyRef
val toLowerCase: PartialFunction[JsValue, JsValue]

Definition Classes
JsValueUpdateOps
def toQBPaths(paths: List[String]): List[QBStringPath]

Definition Classes
QBBaseSchemaOps
def toString(): String

Definition Classes
AnyRef → Any
val toUpperCase: PartialFunction[JsValue, JsValue]

Definition Classes
JsValueUpdateOps
val trim: PartialFunction[JsValue, JsValue]

Definition Classes
JsValueUpdateOps
implicit def tuple2attribute(tuple: (String, QBType)): QBAttribute

Definition Classes
QBSchemaDSL
def unique: ValidationRule[JsArray]

Array Rules
Array Rules

Definition Classes
QBSchemaDSL
def update(qbType: QBType)(predicate: (QBType) ⇒ Boolean)(modifier: (QBType) ⇒ QBType): QBType

Definition Classes
QBBaseSchemaOps
def update[A <: QBType](resolvable: QBClass, path: QBStringPath, updateFn: (A) ⇒ QBType): QBClass

Resolves the given path on the given object, executes the modifier if the path has been resolved and returns the updated object.
Resolves the given path on the given object, executes the modifier if the path has been resolved and returns the updated object.
A
the expected tyupe when the path is resolved
resolvable
the object which is supposed to contain an attribute path
path
the path that is to be followed through the object
updateFn
the update function
returns
the updated object

Definition Classes
QBBaseSchemaOps
def updateAttributeByPath(root: QBClass)(path: QBStringPath, fn: (QBAttribute) ⇒ QBAttribute): QBClass

Definition Classes
QBBaseSchemaOps
def updateAttributeByPredicate(qbType: QBType)(predicate: (QBAttribute) ⇒ Boolean)(modifier: (QBAttribute) ⇒ QBAttribute): QBType

Definition Classes
QBBaseSchemaOps
implicit def valueReader: Reads[QBType]

Definition Classes
JSONSchemaReads
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( ... )
implicit def wrapper2doubleRule(rule: DoubleRuleWrapper): ValidationRule[JsNumber]

Definition Classes
QBSchemaDSL
def writeRule(rule: ValidationRule[_]): Seq[(String, JsValueWrapper)]

Definition Classes
JSONSchemaWrites

object QBSchema extends QBSchemaOps with QBSchemaDSL with JSONSchemaReads with JSONSchemaAnnotationWrites with JsValueUpdateOps

Type Members

case class AnnotatedQBType(qbType: QBType, annotations: List[QBAnnotation]) extends QBType with Product with Serializable

case class BuildDescription(descriptions: List[(QBClass, String)]) extends Product with Serializable

implicit class QBFieldExtensionOps extends AnyRef

implicit class QBSchemaOps extends AnyRef

type QBStringPath = List[String]

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object BuildDescription extends Serializable

val ExclusiveMaximum: String

val ExclusiveMinimum: String

val MaximumId: String

val MinimumId: String

val MultipleOf: String

val PatternId: String

object UnReadable extends Reads[QBType]

def adaptSchema[A](schema: QBType, path: JsPath, adapter: (JsPath, QBType) ⇒ JsResult[JsValue]): JsResult[JsValue]

def add(schema: QBClass)(path: QBStringPath, attributes: Seq[QBAttribute]): QBClass

def allNonOptionalAttributes(fields: Seq[QBAttribute]): Seq[JsString]

def areEqual(schema: QBClass, otherSchema: QBClass): Boolean

implicit def arrayReader: Reads[QBArray]

implicit def arrayWriter: Writes[QBArray]

final def asInstanceOf[T0]: T0

def attribute(obj: QBClass, fieldName: String): QBAttribute

implicit def booleanReader: Reads[QBBoolean]

implicit def booleanWriter: Writes[QBBoolean]

def clone(): AnyRef

def collapse[A <: QBType, B](obj: QBClass)(modifier: (QBAttribute) ⇒ B)(implicit arg0: ClassTag[A], arg1: Monoid[B]): B

def collapseWithPath[B](matcher: (QBType) ⇒ Boolean)(obj: QBClass)(modifier: (QBAttribute, JsPath) ⇒ B)(implicit arg0: Monoid[B]): B

def default(qbType: QBType, default: JsValue): AnnotatedQBType

def defaultExtension(attr: QBAttribute): JsObject

val emptyJsObject: JsObject

def emptyPath: QBStringPath

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exclusiveMax(n: Double): MaxRule

def exclusiveMax(n: Int): DoubleRuleWrapper

def exclusiveMin(n: Double): MinRule

def exclusiveMin(n: Int): DoubleRuleWrapper

def extensions: List[(QBClass) ⇒ JsObject]

def extract(obj1: QBClass, obj2: QBClass): QBClass

def fail[A](msg: String): Nothing

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

implicit def integerReader: Reads[QBInteger]

implicit def integerWriter: Writes[QBInteger]

final def isInstanceOf[T0]: Boolean

def isSubSet(subSchema: QBClass, schema: QBClass): Boolean

def length(lower: Int, upper: Int): ValidationRule[JsString]

def makeOptional(root: QBClass, paths: List[QBStringPath]): QBClass

def makeReadOnly(schema: QBClass, paths: List[QBStringPath]): QBClass

def max(n: Int): DoubleRuleWrapper

def max(n: Double): MaxRule

def maxLength(n: Int): MaxLengthRule

def maxProperties(max: Int): MaxPropertiesRule

def merge(schema: QBClass, otherSchema: QBClass): QBClass

def min(n: Int): DoubleRuleWrapper

def min(n: Double): MinRule

def minLength(n: Int): MinLengthRule

def minProperties(min: Int): MinPropertiesRule

def multipleOf(n: Int): DoubleRuleWrapper

def multipleOf(n: Double): MultipleOfRule

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def numberReader: Reads[QBNumber]

implicit def numberWriter: Writes[QBNumber]

implicit def objectReader: Reads[QBClass]

implicit def objectWriter: Writes[QBClass]

def oneOf(values: QBClass*): QBOneOfImpl

def optional(qbType: QBType, defaultValue: JsValue): AnnotatedQBType

def optional(qbType: QBType): AnnotatedQBType

def optionalExtension(obj: QBClass): JsObject