MyBeanSolver

Instance Constructors

new MyBeanSolver(excludeMatches: List[(String) ⇒ Boolean] = Nil)

excludeMatches
- custom exclusion rules: nodes and attributes with these names won't be browsed

Type Members

abstract class BeanWrapper extends LazyB
type CONT = (String, String) ⇒ List[BeanWrapper]
case class FieldWrapper(j: Any, f: Field, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable
trait LazyB extends AnyRef
case class MethodWrapper(j: Any, m: Method, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable
case class RootWrapper(j: Any, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable
type T = Any
type U = (String, String) ⇒ List[BeanWrapper]

type U stands for the continuation that following methods pass to themselves.
type U stands for the continuation that following methods pass to themselves.
Ideally it's just a closure that can implement getNext(curr: (T, U), tag: String, assoc: String): Iterable[(T, U)]
So options include
type U = List[MyWrapper] and type U = PartialFunction[(String, String), List[MyWrapper]] // basically getNext (tag, assoc)
The continuation is very good when getting the kids is expensive, like a DB query, eh?

Definition Classes
MyBeanSolver → XpSolver

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 WrapF(j: Any, f: Field, label: String): FieldWrapper
def WrapM(j: Any, m: Method, label: String): MethodWrapper
def WrapO(j: Any, label: String = "root"): RootWrapper
final def asInstanceOf[T0]: T0

Definition Classes
Any
def children(root: T, xe: Option[XpElement]): (T, U)

prepare to start from a node, figure out the continuations.
prepare to start from a node, figure out the continuations.
This is only used to start, from the root - then getNext is used
You can return an actual list of nodes or a callback that you then call from getNext to get the actuals
root
the node we'll start resolving from
xe
- optional the current path element - you can use cond to filter result set directly when querying

Definition Classes
MyBeanSolver → XpSolver
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
val excludeMatches: List[(String) ⇒ Boolean]

- custom exclusion rules: nodes and attributes with these names won't be browsed
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def getAttr(o: T, attr: String): String

get the value of an attribute from the given node
get the value of an attribute from the given node
returns
the value, toString, of the attribute

Definition Classes
MyBeanSolver → XpSolver
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getNext(o: (T, U), tag: String, assoc: String, xe: Option[XpElement]): List[(T, U)]

get the next list of nodes at the current position in the path.
get the next list of nodes at the current position in the path. For each, return a tuple with the respective value and the REST to continue solving
You can return an actual list of nodes or a callback that you then call from getNext to get the actuals
xe
- optional the current path element - you can use cond to filter result set directly when querying

Definition Classes
MyBeanSolver → XpSolver
def hashCode(): Int

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

Definition Classes
Any
lazy val meth: Map[String, String]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val nogo: List[Any]
val nomatch: List[(String) ⇒ Boolean]
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def reduce(curr: Iterable[(T, U)], xe: XpElement): Iterable[(T, U)]

reduce the current set of possible nodes based on the given condition.
reduce the current set of possible nodes based on the given condition. Note that the condition may be null - this is still called to give you a chance to cleanup?
This default implementation may be ok for most resolvers
NOTE - if you choose to filter in getNext, then you don't have to filter here...
curr
the list of (currelement, continuation) to reduce

Definition Classes
MyBeanSolver → XpSolver
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unwrap(root: List[T]): List[T]

finally unwrap whatever and serve plain objects
finally unwrap whatever and serve plain objects
root
the node we'll start resolving from

Definition Classes
MyBeanSolver → XpSolver
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 xp

class MyBeanSolver extends XpSolver[Any]

Instance Constructors

new MyBeanSolver(excludeMatches: List[(String) ⇒ Boolean] = Nil)

Type Members

abstract class BeanWrapper extends LazyB

type CONT = (String, String) ⇒ List[BeanWrapper]

case class FieldWrapper(j: Any, f: Field, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable

trait LazyB extends AnyRef

case class MethodWrapper(j: Any, m: Method, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable

case class RootWrapper(j: Any, label: String = "root") extends BeanWrapper with LazyB with Product with Serializable

type T = Any

type U = (String, String) ⇒ List[BeanWrapper]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def WrapF(j: Any, f: Field, label: String): FieldWrapper

def WrapM(j: Any, m: Method, label: String): MethodWrapper

def WrapO(j: Any, label: String = "root"): RootWrapper

final def asInstanceOf[T0]: T0

def children(root: T, xe: Option[XpElement]): (T, U)

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val excludeMatches: List[(String) ⇒ Boolean]

def finalize(): Unit

def getAttr(o: T, attr: String): String

final def getClass(): Class[_]

def getNext(o: (T, U), tag: String, assoc: String, xe: Option[XpElement]): List[(T, U)]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

lazy val meth: Map[String, String]

final def ne(arg0: AnyRef): Boolean

val nogo: List[Any]

val nomatch: List[(String) ⇒ Boolean]

final def notify(): Unit

final def notifyAll(): Unit

def reduce(curr: Iterable[(T, U)], xe: XpElement): Iterable[(T, U)]

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

def toString(): String

def unwrap(root: List[T]): List[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from XpSolver[Any]

Inherited from AnyRef

Inherited from Any

Ungrouped