ModelNode

abstract def at(address: Address): ModelNode

Sets the address for this model node.

abstract def op(operation: Operation): ModelNode

Sets the operation for this model node.

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: (String, ModelNode), That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def ++:[B >: (String, ModelNode), That](that: Traversable[B])(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def ++:[B >: (String, ModelNode), That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def +=(kvs: (String, Any)*): ModelNode

Adds multiple key / value pairs to this model node:

node += (
"flag" -> true,
"hello" -> "world",
"answer" -> 42,
"child" -> ModelNode(
  "inner-a" -> 123,
  "inner-b" -> "test",
  "deep-inside" -> ModelNode("foo" -> "bar"),
  "deep-list" -> List(
    ModelNode("one" -> 1),
    ModelNode("two" -> 2),
    ModelNode("three" -> 3)
  )
)
)

def /:[B](z: B)(op: (B, (String, ModelNode)) ⇒ B): B

def :\[B](z: B)(op: ((String, ModelNode), B) ⇒ B): B

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: B)(seqop: (B, (String, ModelNode)) ⇒ B, combop: (B, B) ⇒ B): B

def apply(path: Path): ModelNode

Returns the model node associated with a path, or throws a NoSuchElementException if the path is not contained in the model node.

def asBigInt: Option[BigInt]

Returns the value of this model node as Some(BigInt) or None if the underlying node does not support conversion to BigInt

def asBoolean: Option[Boolean]

Returns the value of this model node as Some(Boolean) or None if the underlying node does not support conversion to Boolean

def asDouble: Option[Double]

Returns the value of this model node as Some(Double) or None if the underlying node does not support conversion to Double

final def asInstanceOf[T0]: T0

def asInt: Option[Int]

Returns the value of this model node as Some(Int) or None if the underlying node does not support conversion to Int

def asList: Option[List[ModelNode]]

Returns the value of this model node as Some(List[ModelNode]) or None if the underlying node does not support conversion to List[ModelNode]

def asLong: Option[Long]

Returns the value of this model node as Some(Long) or None if the underlying node does not support conversion to Long

def asString: Option[String]

Returns the value of this model node as Some(String) or None if the underlying node does not support conversion to String

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[(String, ModelNode), B])(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def collectFirst[B](pf: PartialFunction[(String, ModelNode), B]): Option[B]

def companion: GenericCompanion[Traversable]

def contains(path: Path): Boolean

Tests whether this model node contains a binding for a path.

def copyToArray[B >: (String, ModelNode)](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: (String, ModelNode)](xs: Array[B]): Unit

def copyToArray[B >: (String, ModelNode)](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: (String, ModelNode)](dest: Buffer[B]): Unit

def count(p: ((String, ModelNode)) ⇒ Boolean): Int

def drop(n: Int): ModelNode

def dropWhile(p: ((String, ModelNode)) ⇒ Boolean): ModelNode

final def eq(arg0: AnyRef): Boolean

def equals(obj: Any): Boolean

Delegates to underlying.equals() if obj is also a model node, returns false otherwise

def exists(p: ((String, ModelNode)) ⇒ Boolean): Boolean

def filter(p: ((String, ModelNode)) ⇒ Boolean): ModelNode

def filterNot(p: ((String, ModelNode)) ⇒ Boolean): ModelNode

def finalize(): Unit

def find(p: ((String, ModelNode)) ⇒ Boolean): Option[(String, ModelNode)]

def flatMap[B, That](f: ((String, ModelNode)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def flatten[B](implicit asTraversable: ((String, ModelNode)) ⇒ GenTraversableOnce[B]): Traversable[B]

def fold[A1 >: (String, ModelNode)](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, (String, ModelNode)) ⇒ B): B

def foldRight[B](z: B)(op: ((String, ModelNode), B) ⇒ B): B

def forall(p: ((String, ModelNode)) ⇒ Boolean): Boolean

def foreach[U](f: ((String, ModelNode)) ⇒ U): Unit

def genericBuilder[B]: Builder[B, Traversable[B]]

def get(path: Path): Option[ModelNode]

Optionally returns the value associated with a path.

final def getClass(): Class[_]

def getOrElse(path: Path, default: ⇒ ModelNode): ModelNode

Returns the model node associated with a path, or a default value if the path is not contained in the model node.

def groupBy[K](f: ((String, ModelNode)) ⇒ K): Map[K, ModelNode]

def hasDefiniteSize: Boolean

def hashCode(): Int

Delegates to underlying.hashCode()

def head: (String, ModelNode)

def headOption: Option[(String, ModelNode)]

def inOrder: List[(String, ModelNode)]

Traversals the model node tree using inorder

def init: ModelNode

def inits: Iterator[ModelNode]

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraversableAgain: Boolean

def keys: Iterable[String]

Returns the keys for this model node

def last: (String, ModelNode)

def lastOption: Option[(String, ModelNode)]

def map[B, That](f: ((String, ModelNode)) ⇒ B)(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def max[B >: (String, ModelNode)](implicit cmp: Ordering[B]): (String, ModelNode)

def maxBy[B](f: ((String, ModelNode)) ⇒ B)(implicit cmp: Ordering[B]): (String, ModelNode)

def min[B >: (String, ModelNode)](implicit cmp: Ordering[B]): (String, ModelNode)

def minBy[B](f: ((String, ModelNode)) ⇒ B)(implicit cmp: Ordering[B]): (String, ModelNode)

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

def newBuilder: Builder[(String, ModelNode), ModelNode]

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

def par: ParIterable[(String, ModelNode)]

def parCombiner: Combiner[(String, ModelNode), ParIterable[(String, ModelNode)]]

def partition(p: ((String, ModelNode)) ⇒ Boolean): (ModelNode, ModelNode)

def product[B >: (String, ModelNode)](implicit num: Numeric[B]): B

def reduce[A1 >: (String, ModelNode)](op: (A1, A1) ⇒ A1): A1

def reduceLeft[B >: (String, ModelNode)](op: (B, (String, ModelNode)) ⇒ B): B

def reduceLeftOption[B >: (String, ModelNode)](op: (B, (String, ModelNode)) ⇒ B): Option[B]

def reduceOption[A1 >: (String, ModelNode)](op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight[B >: (String, ModelNode)](op: ((String, ModelNode), B) ⇒ B): B

def reduceRightOption[B >: (String, ModelNode)](op: ((String, ModelNode), B) ⇒ B): Option[B]

def repr: ModelNode

def reversed: List[(String, ModelNode)]

def scan[B >: (String, ModelNode), That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[ModelNode, B, That]): That

def scanLeft[B, That](z: B)(op: (B, (String, ModelNode)) ⇒ B)(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def scanRight[B, That](z: B)(op: ((String, ModelNode), B) ⇒ B)(implicit bf: CanBuildFrom[ModelNode, B, That]): That

def seq: Traversable[(String, ModelNode)]

def size: Int

def slice(from: Int, until: Int): ModelNode

def span(p: ((String, ModelNode)) ⇒ Boolean): (ModelNode, ModelNode)

def splitAt(n: Int): (ModelNode, ModelNode)

def stringPrefix: String

def sum[B >: (String, ModelNode)](implicit num: Numeric[B]): B

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

def tail: ModelNode

def tails: Iterator[ModelNode]

def take(n: Int): ModelNode

def takeWhile(p: ((String, ModelNode)) ⇒ Boolean): ModelNode

def thisCollection: Traversable[(String, ModelNode)]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, (String, ModelNode), Col[(String, ModelNode)]]): Col[(String, ModelNode)]

def toArray[B >: (String, ModelNode)](implicit arg0: ClassTag[B]): Array[B]

def toBuffer[B >: (String, ModelNode)]: Buffer[B]

def toCollection(repr: ModelNode): Traversable[(String, ModelNode)]

def toIndexedSeq: IndexedSeq[(String, ModelNode)]

def toIterable: Iterable[(String, ModelNode)]

def toIterator: Iterator[(String, ModelNode)]

def toList: List[(String, ModelNode)]

def toMap[T, U](implicit ev: <:<[(String, ModelNode), (T, U)]): Map[T, U]

def toSeq: Seq[(String, ModelNode)]

def toSet[B >: (String, ModelNode)]: Set[B]

def toStream: Stream[(String, ModelNode)]

def toString(): String

Delegates to underlying.toString

def toTraversable: Traversable[(String, ModelNode)]

def toVector: Vector[(String, ModelNode)]

def transpose[B](implicit asTraversable: ((String, ModelNode)) ⇒ GenTraversableOnce[B]): Traversable[Traversable[B]]

def underlying: dmr.ModelNode

Returns the underlying Java mode node

def unzip[A1, A2](implicit asPair: ((String, ModelNode)) ⇒ (A1, A2)): (Traversable[A1], Traversable[A2])

def unzip3[A1, A2, A3](implicit asTriple: ((String, ModelNode)) ⇒ (A1, A2, A3)): (Traversable[A1], Traversable[A2], Traversable[A3])

def update(name: String, value: Any): Unit

Adds a given key/value pair.

def values: Iterable[ModelNode]

Returns the values for this model node

def view(from: Int, until: Int): TraversableView[(String, ModelNode), ModelNode]

def view: TraversableView[(String, ModelNode), ModelNode]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFilter(p: ((String, ModelNode)) ⇒ Boolean): FilterMonadic[(String, ModelNode), ModelNode]

def /:\[A1 >: (String, ModelNode)](z: A1)(op: (A1, A1) ⇒ A1): A1