json4s-scalap/org.json4s.scalap.scalasig/ScalaSigEntryParsers

ScalaSigEntryParsers

object ScalaSigEntryParsers extends RulesWithState with MemoisableRules
trait Rules
class Object
trait Matchable
class Any

Type members

Inherited classlikes

class DefaultRule[In, Out, A, X](f: In => Result[Out, A, X])
Inherited from
Rules
trait FromRule[In]
Inherited from
Rules

Types

type EntryParser[A] = Rule[A, String]
type S = Entry

Inherited types

type Rule[+A, +X] = Rule[S, S, A, X]
Inherited from
StateRules

Value members

Concrete methods

def isTopLevel(symbol: Symbol): Boolean
def isTopLevelClass(symbol: Symbol): Boolean
def parseEntry[A](parser: EntryParser[A])(index: Int): Rule[S, Entry, A, String]
def refTo[A](rule: EntryParser[A]): EntryParser[A]
def symHeader(key: Int): EntryParser[Any]
def symbolEntry(key: Int): Rule[S, Entry, SymbolInfo, String]
def toEntry[A](index: Int): Rule[S, S, Int, Nothing]

Inherited methods

def allOf[A, X](rules: Seq[Rule[A, X]]): S => Result[S, List[A], X]

Create a rule that succeeds if all of the given rules succeed.

Create a rule that succeeds if all of the given rules succeed.

Value Params
rules

the rules to apply in sequence.

Inherited from
StateRules
def anyOf[A, X](rules: Seq[Rule[A, X]]): Rule[S, S, List[A], X]

Create a rule that succeeds with a list of all the provided rules that succeed.

Create a rule that succeeds with a list of all the provided rules that succeed.

Value Params
rules

the rules to apply in sequence.

Inherited from
StateRules
def apply[A, X](f: S => Result[S, A, X]): Rule[S, S, A, X]
Inherited from
StateRules
def cond(f: S => Boolean): Rule[S, S, S, Nothing]

Create a rule that identities if f(in) is true.

Create a rule that identities if f(in) is true.

Inherited from
StateRules
def error[X](err: X): Rule[Any, Nothing, Nothing, X]
Inherited from
Rules
def error[In]: Rule[In, Nothing, Nothing, In]
Inherited from
Rules
def expect[In, Out, A, Any](rule: Rule[In, Out, A, Any]): In => A

Converts a rule into a function that throws an Exception on failure.

Converts a rule into a function that throws an Exception on failure.

Inherited from
Rules
def failure: Rule[Any, Nothing, Nothing, Nothing]
Inherited from
Rules
def from[In]: FromRule[In]
Inherited from
Rules
def get: Rule[S, S, S, Nothing]
Inherited from
StateRules
def memo[In <: Memoisable, Out, A, X](key: AnyRef)(toRule: => In => Result[Out, A, X]): Rule[In, Out, A, X]
Inherited from
MemoisableRules
def nil: Rule[S, S, Nil, Nothing]
Inherited from
StateRules
def none: Rule[S, S, None, Nothing]
Inherited from
StateRules
def oneOf[In, Out, A, X](rules: Rule[In, Out, A, X]*): Rule[In, Out, A, X]
Inherited from
Rules
def read[A](f: S => A): Rule[S, S, A, Nothing]
Inherited from
StateRules
def repeatUntil[T, X](rule: Rule[T => T, X])(finished: T => Boolean)(initial: T): Rule[S, S, T, X]

Repeatedly apply a rule from initial value until finished condition is met.

Repeatedly apply a rule from initial value until finished condition is met.

Inherited from
StateRules
override def ruleWithName[In, Out, A, X](name: String, f: In => Result[Out, A, X]): Rule[In, Out, A, X] & Name
Definition Classes
Inherited from
MemoisableRules
def set(s: => S): Rule[S, S, S, Nothing]
Inherited from
StateRules
def state[s]: StateRules { type S = s; }
Inherited from
Rules
def success[Out, A](out: Out, a: A): Rule[Any, Out, A, Nothing]
Inherited from
Rules
def unit[A](a: => A): Rule[S, S, A, Nothing]
Inherited from
StateRules
def update(f: S => S): Rule[S, S, S, Nothing]
Inherited from
StateRules

Concrete fields

val aliasSymbol: Rule[S, Entry, AliasSymbol, String] & Name
lazy val annotInfo: Rule[S, Entry, AnnotInfo, String]
lazy val attributeInfo: Rule[S, Entry, AttributeInfo, String]
lazy val children: Rule[S, Entry, Children, String]
val classSymbol: Rule[S, Entry, ClassSymbol, String] & Name
lazy val constantRef: EntryParser[Any]
lazy val entry: EntryParser[Any]
val extRef: Rule[S, Entry, ExternalSymbol, String] & Name
val index: Rule[S, S, Int, Nothing]
val key: Rule[S, S, Int, Nothing]
lazy val literal: EntryParser[Any]
val name: Rule[S, Entry, String, String] & Name
lazy val nameRef: EntryParser[String]
val noSymbol: Rule[S, S, NoSymbol, Nothing]
val ref: EntryParser[Int]
val symbolInfo: Rule[S, Entry, SymbolInfo, String]
val termName: Rule[S, Entry, String, String]
lazy val topLevelClass: Rule[S, Entry, ClassSymbol, String]
lazy val topLevelObject: Rule[S, Entry, ObjectSymbol, String]
val typeIndex: Rule[S, S, Int, Nothing]
val typeLevel: Rule[S, S, Int, Nothing]
val typeName: Rule[S, Entry, String, String]
val typeSymbol: Rule[S, Entry, TypeSymbol, String] & Name

Inherited fields

val factory: Rules
Inherited from
RulesWithState

Implicits

Implicits

implicit def byteCodeEntryParser[A](rule: Parser[A]): EntryParser[A]
implicit def entryType(code: Int): Rule[S, S, Int, Nothing]

Inherited implicits

implicit def inRule[In, Out, A, X](rule: Rule[In, Out, A, X]): InRule[In, Out, A, X]
Inherited from
Rules
implicit def rule[In, Out, A, X](f: In => Result[Out, A, X]): Rule[In, Out, A, X]
Inherited from
Rules
implicit def seqRule[In, A, X](rule: Rule[In, In, A, X]): SeqRule[In, A, X]
Inherited from
Rules