package utils
The scales.utils packages provide the basis functionality for scales.xml.
The Tree an Path collections that underpin the XML model, as well as the iteratee functionality are located in the relevant sub-packages.
The package object itself pulls in the main utility functions for tree, path and iteratee handling. Import the scales.utils.ScalesUtils object implicit members to provide the path & and | extension functions, the iteratorEnumerator and the +:+ lazy appender for scalaz.EphemeralStream.
- Alphabetic
- By Inheritance
- utils
- ConcurrentMapUtils
- Paths
- Trees
- EquivFunctions
- Iteratees
- StackUtils
- AsBooleanTrait
- IterableUtils
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
Type Members
- type AsBoolean[T] = (T) => Boolean
- Definition Classes
- AsBooleanTrait
- trait AsBooleanTrait extends AnyRef
Provides the conversion type class AsBoolean, and simple matchers (extractor builders) to use them.
Provides the conversion type class AsBoolean, and simple matchers (extractor builders) to use them. Used by the xpath boolean function and xmltree matching
- class BooleanAndTMatcher[X, T] extends AnyRef
- Definition Classes
- AsBooleanTrait
- class BooleanMatcher[X, T] extends AnyRef
- Definition Classes
- AsBooleanTrait
- sealed trait EitherLike[+L, +R] extends AnyRef
Either is great, perfect for what is needed, except for the indirection and the added memory and cpu costs thereof.
Either is great, perfect for what is needed, except for the indirection and the added memory and cpu costs thereof. If ScalesXml is meant to be used in the placesthat JAXP and friends would live it should perform the best it can.
That means reducing allocations wherever possible and optimising up to the point of model damage. I think this unfortunately crosses that line but meets the aim.
- class Equiv[A] extends AnyRef
Provides evidence that two instances of two disctinct types are equivalent after a conversion.
Provides evidence that two instances of two disctinct types are equivalent after a conversion. Requires an instance of Equal for the common convertable type.
- trait EquivFunctions extends AnyRef
- type FoldR[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]] = Either[Path[Item, Section, CC], FoldError]
- Definition Classes
- Paths
- type ItemOrSectionWalk[Item, Section] = Either[Item, SectionWalk[Section]]
badly named the boolean should indicate if it has any children
badly named the boolean should indicate if it has any children
- Definition Classes
- Trees
- type ItemOrTree[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]] = EitherLike[Item, Tree[Item, Section, CC]]
- Definition Classes
- Trees
- trait LeftLike[+L, +R] extends LeftLikeProjection[L] with EitherLike[L, R]
- type PathFoldR[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]] = (Path[Item, Section, CC]) => FoldR[Item, Section, CC]
- Definition Classes
- Paths
- trait RightLike[+L, +R] extends RightLikeProjection[R] with EitherLike[L, R]
- type TreeCBF[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]] = BuildFrom[CC[_], ItemOrTree[Item, Section, CC], CC[ItemOrTree[Item, Section, CC]]]
- Definition Classes
- Trees
Value Members
- val ALREADY_RESTARTED: String
- Definition Classes
- IterableUtils
- val NotSameRoot: Int
- Definition Classes
- Paths
- val US_ASCII: Charset
- val UTF_8: Charset
- def boolean[T](it: T)(implicit arg0: AsBoolean[T]): Boolean
- Definition Classes
- AsBooleanTrait
- def booleanAndTMatcher[X, T](eval: (X) => T)(implicit arg0: AsBoolean[T]): BooleanAndTMatcher[X, T]
Calls eval to return a T t'.
Calls eval to return a T t'. This T is then evaluated with the AsBoolean type class.
When evaluated to true (t',x) is returned. val Matcher = booleanMatcher( (x) => T ); val Matcher(t,x) = x
- Definition Classes
- AsBooleanTrait
- def booleanMatcher[X, T](eval: (X) => T)(implicit arg0: AsBoolean[T]): BooleanMatcher[X, T]
Calls eval to return a T t'.
Calls eval to return a T t'. This T is then evaluated with the AsBoolean type class.
When evaluated to true t' is returned. val Matcher = booleanMatcher( (x) => T ); val Matcher(t) = x
- Definition Classes
- AsBooleanTrait
- def calcOnce[K, T](key: K, map: ConcurrentHashMap[K, Once[T]])(calc: => T): T
Calculates the value once and only once (using a lazy val), returning the result, use this approach for expensive calculations.
Calculates the value once and only once (using a lazy val), returning the result, use this approach for expensive calculations.
- Definition Classes
- ConcurrentMapUtils
- def capture[A](orig: Iterator[A]): CapturedIterator[A]
- Definition Classes
- IterableUtils
- def collectFirst[A, B](in: Iterable[A])(f: (A) => Option[B]): Option[B]
Collects the first Some
Collects the first Some
- Definition Classes
- IterableUtils
- def comparePathPositions[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path1: Position[Item, Section, CC], path2: Position[Item, Section, CC]): Int
When paths are not in the same root, they are compared based on the identity hash of the given roots.
When paths are not in the same root, they are compared based on the identity hash of the given roots. Of course this relies on that function having a decent vm implementation.
- returns
1 if path1 is before path2, -1 if path2 is before path1, 0 if they are the same and NotSameRoot+-1 if they are not in the same root
- Definition Classes
- Paths
- def comparePaths[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path1: Path[Item, Section, CC], path2: Path[Item, Section, CC]): (Int, Position[Item, Section, CC], Position[Item, Section, CC])
When paths are not in the same root, they are compared based on the identity hash of the given roots.
When paths are not in the same root, they are compared based on the identity hash of the given roots. Of course this relies on that function having a decent vm implementation. See http://www.w3.org/TR/2007/REC-xpath20-20070123/#dt-document-order, tree order must remain constant. Its also a pretty sensible approach for non xml trees.
- returns
1 if path1 is before path2, -1 if path2 is before path1, 0 if they are the same and NotSameRoot+-1 if they are not in the same root
- Definition Classes
- Paths
- def comparePathsDirect[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path1: Path[Item, Section, CC], path2: Path[Item, Section, CC]): Boolean
Helper for comparePaths, will not evaluate position if the paths are equal
Helper for comparePaths, will not evaluate position if the paths are equal
- Definition Classes
- Paths
- def comparePathsP[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path1: (Position[Item, Section, CC], Path[Item, Section, CC]), path2: (Position[Item, Section, CC], Path[Item, Section, CC])): (Int, Position[Item, Section, CC], Position[Item, Section, CC])
- Definition Classes
- Paths
- def comparePathsT[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_], T](path1: (Position[Item, Section, CC], (T, Path[Item, Section, CC])), path2: (Position[Item, Section, CC], (T, Path[Item, Section, CC]))): (Int, Position[Item, Section, CC], Position[Item, Section, CC])
- Definition Classes
- Paths
- final def compareStack(p1: List[Int], p2: List[Int]): Int
- Definition Classes
- StackUtils
- Annotations
- @tailrec()
- def deepestLast[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path: Path[Item, Section, CC]): Path[Item, Section, CC]
Deepest last child
Deepest last child
- Definition Classes
- Paths
- val defaultCharset: Charset
A usable default of UTF8 NOT the vm's Charset.defaultCharset based on its locale, use vmDefaultCharset for that
- def equivalent[A, B, C](a: A, b: B)(implicit equiv: Equiv[C], viewA: (A) => C, viewB: (B) => C): Boolean
Are these two parameters (convertable to a C) equal for a given Equiv[C] instance
Are these two parameters (convertable to a C) equal for a given Equiv[C] instance
- Definition Classes
- EquivFunctions
- def error(string: String): Nothing
- Definition Classes
- Iteratees
- final def fold[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_], A](a: A)(folder: (ItemOrSectionWalk[Item, Section], A) => A)(tree: Tree[Item, Section, CC]): A
- Definition Classes
- Trees
- def foldPositions[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](locations: Iterable[Path[Item, Section, CC]])(folder: (Path[Item, Section, CC]) => FoldOperation[Item, Section, CC])(implicit iseqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC], cm: ClassManifest[(Position[Item, Section, CC], Path[Item, Section, CC])]): FoldR[Item, Section, CC]
Folds over positions within a single path, for example all given children.
Folds over positions within a single path, for example all given children. As such positions must be calculated.
Takes the first root, returning Right(NoSingleRoot) if any of the subsequent roots don't match.
folder retrieves the current path
Each iteration folds the resulting tree back into the path. As this function must maintain the Path it does not expose the new path root until the result.
- Definition Classes
- Paths
- def foldPositions[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_], ACC](locations: Iterable[Path[Item, Section, CC]], accumulator: ACC)(folder: (ACC, Path[Item, Section, CC]) => (ACC, FoldOperation[Item, Section, CC]))(implicit iseqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC], cm: ClassManifest[(Position[Item, Section, CC], Path[Item, Section, CC])]): Either[(ACC, Path[Item, Section, CC]), FoldError]
As per the non accumalating version, folds over positions within a given tree but allows for an additional accumalation.
As per the non accumalating version, folds over positions within a given tree but allows for an additional accumalation.
The progress through the document is in reverse document order. This ensures that transformations can always be safely composed, e.g. a delete of a path won't stop changes below it. This, however, implies the developer must also handle any accumulation in "reverse".
- Definition Classes
- Paths
- def following[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path: Path[Item, Section, CC]): Option[Path[Item, Section, CC]]
gets the next following:: sibling in document order
gets the next following:: sibling in document order
- Definition Classes
- Paths
- def getList[K, T](key: K, mapToList: ConcurrentHashMap[K, ConcurrentLinkedQueue[T]]): ConcurrentLinkedQueue[T]
- Definition Classes
- ConcurrentMapUtils
- implicit val idIteratees: IterateeFunctions[scalaz.Id.Id]
Warning: Id does not trampoline, consider trampolineIteratees or ioIteratees to import from
Warning: Id does not trampoline, consider trampolineIteratees or ioIteratees to import from
- Definition Classes
- Iteratees
- implicit val ioIteratees: IterateeFunctions[IO]
- Definition Classes
- Iteratees
- final def item[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](item: Item): ItemOrTree[Item, Section, CC]
- Annotations
- @inline()
- def iterateesOf[F[_]](implicit F: Monad[F]): IterateeFunctions[F]
- Definition Classes
- Iteratees
- def mkString[A](itr: Iterable[A], builder: StringBuilder = new java.lang.StringBuilder(1000), separator: String = " ")(thunk: (A) => String): StringBuilder
Makes a StringBuilder from an iterable using the builder parameter.
Makes a StringBuilder from an iterable using the builder parameter.
- Definition Classes
- IterableUtils
- def moveTo[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path: Path[Item, Section, CC], newPos: Position[Item, Section, CC])(implicit seqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC]): Path[Item, Section, CC]
Navigates the path until the new position is reached, throws if either its a new root or the position is not reachable
Navigates the path until the new position is reached, throws if either its a new root or the position is not reachable
- Definition Classes
- Paths
- def noPath[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](implicit seqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC]): Path[Item, Section, CC]
- Definition Classes
- Paths
- final def one[T](i: T): List[T]
- Annotations
- @inline()
- def positions[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](paths: Iterable[Path[Item, Section, CC]]): Iterable[(Position[Item, Section, CC], Path[Item, Section, CC])]
Obtain the positions for the paths
Obtain the positions for the paths
- Definition Classes
- Paths
- def positionsT[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_], T](paths: Iterable[(T, Path[Item, Section, CC])]): Iterable[(Position[Item, Section, CC], (T, Path[Item, Section, CC]))]
positions with tuples (T, Path)
positions with tuples (T, Path)
- Definition Classes
- Paths
- def preceding[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path: Path[Item, Section, CC]): Option[Path[Item, Section, CC]]
gets the next preceding:: sibling equivalent in document order, unlike XPath preceding:: it does not exclude parents
gets the next preceding:: sibling equivalent in document order, unlike XPath preceding:: it does not exclude parents
- Definition Classes
- Paths
- def removeList[K, T](key: K, mapToList: ConcurrentHashMap[K, ConcurrentLinkedQueue[T]]): ConcurrentLinkedQueue[T]
- Definition Classes
- ConcurrentMapUtils
- def removeOr[K, T](key: K, map: ConcurrentHashMap[K, T])(newT: => T): T
Removes the value, returning either it or a new item (stops end code worrying about nulls etc..
Removes the value, returning either it or a new item (stops end code worrying about nulls etc..
- Definition Classes
- ConcurrentMapUtils
- def resource(a: AnyRef, path: String): URL
Simple grabber of resources
- def rootPath[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](path: Path[Item, Section, CC]): Path[Item, Section, CC]
Returns the root path for its input, uses zipUp to ensure changes are kept
Returns the root path for its input, uses zipUp to ensure changes are kept
- Definition Classes
- Paths
- def sameBase(test: List[Int], against: List[Int]): Boolean
- Definition Classes
- StackUtils
- def sort[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](paths: Iterable[Path[Item, Section, CC]], isDescending: Boolean = true)(implicit cm: ClassManifest[(Position[Item, Section, CC], Path[Item, Section, CC])]): Iterable[Path[Item, Section, CC]]
Sorts according to position of each path item, descending or descending based on a depth first then rightwise order.
Sorts according to position of each path item, descending or descending based on a depth first then rightwise order.
- Definition Classes
- Paths
- def sortPositions[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](paths: Iterable[Path[Item, Section, CC]], isDescending: Boolean = true)(implicit cm: ClassManifest[(Position[Item, Section, CC], Path[Item, Section, CC])]): Iterable[(Position[Item, Section, CC], Path[Item, Section, CC])]
Sorts according to position of each path item, descending or descending based on a depth first then rightwise order.
Sorts according to position of each path item, descending or descending based on a depth first then rightwise order.
- Definition Classes
- Paths
- def sortPositionsT[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[X], T](paths: Iterable[(T, Path[Item, Section, CC])], isDescending: Boolean = true)(implicit cm: ClassManifest[(Position[Item, Section, CC], (T, Path[Item, Section, CC]))]): Iterable[(Position[Item, Section, CC], (T, Path[Item, Section, CC]))]
sortPositions with a tuple T, Path
sortPositions with a tuple T, Path
- Definition Classes
- Paths
- def sortT[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_], T](paths: Iterable[(T, Path[Item, Section, CC])], isDescending: Boolean = true)(implicit cm: ClassManifest[(Position[Item, Section, CC], (T, Path[Item, Section, CC]))]): Iterable[(T, Path[Item, Section, CC])]
sort with a tuple T, Path
sort with a tuple T, Path
- Definition Classes
- Paths
- final def subtree[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](section: Section, children: CC[ItemOrTree[Item, Section, CC]])(implicit iseqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC]): ItemOrTree[Item, Section, CC]
- Annotations
- @inline()
- def toPositionalEqual[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]]: Equal[Path[Item, Section, CC]]
Provides an instance of the Equal type class for positional Equality
Provides an instance of the Equal type class for positional Equality
- Definition Classes
- Paths
- def top[Item <: LeftLike[Item, Tree[Item, Section, CC]], Section, CC[_]](tree: Tree[Item, Section, CC])(implicit seqLikeThing: SeqLikeThing[CC[_], ItemOrTree[Item, Section, CC], CC]): Path[Item, Section, CC]
- Definition Classes
- Paths
- implicit val trampolineIteratees: IterateeFunctions[Trampoline]
- Definition Classes
- Iteratees
- def valueOf[K, T](key: K, map: ConcurrentHashMap[K, T])(newT: => T): T
retrieves the value of a concurrent hashmap against a given key, creating if necessary.
retrieves the value of a concurrent hashmap against a given key, creating if necessary. Note it makes no gaurantee of once only semantics for the value generation
- Definition Classes
- ConcurrentMapUtils
- object ScalesUtils extends ScalesUtilsImplicits
Allows importing all scales.utils implicits directly