ClassFileParser

Type Members

case class Annotation(typeIndex: Int, elementValuePairs: Seq[AnnotationElement]) extends ElementValue with Product with Serializable
case class AnnotationElement(elementNameIndex: Int, elementValue: ElementValue) extends Product with Serializable
case class ArrayValue(values: Seq[ElementValue]) extends ElementValue with Product with Serializable
case class ClassInfoIndex(index: Int) extends ElementValue with Product with Serializable
case class ConstValueIndex(index: Int) extends ElementValue with Product with Serializable
class DefaultRule[In, Out, A, X] extends Rule[In, Out, A, X]

Definition Classes
Rules
abstract class ElementValue extends AnyRef
case class EnumConstValue(typeNameIndex: Int, constNameIndex: Int) extends ElementValue with Product with Serializable
type Parser[A] = rules.Rule[S, S, A, String]

Definition Classes
ByteCodeReader
type Rule[+A, +X] = rules.Rule[S, S, A, X]

Definition Classes
StateRules
type S = ByteCode

Definition Classes
ByteCodeReader → StateRules

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 add1[T](f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool
def add2[T](f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool
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.
rules
the rules to apply in sequence.

Definition Classes
StateRules
val annotation: Parser[Annotation]
val annotations: rules.Rule[S, S, Seq[Annotation], String]
def anyOf[A, X](rules: Seq[Rule[A, X]]): rules.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.
rules
the rules to apply in sequence.

Definition Classes
StateRules
def apply[A, X](f: (S) ⇒ Result[S, A, X]): rules.Rule[S, S, A, X]

Definition Classes
StateRules
final def asInstanceOf[T0]: T0

Definition Classes
Any
val attribute: rules.Rule[S, S, Attribute, Nothing]
val attributes: rules.Rule[S, S, Seq[Attribute], Nothing]
val byte: rules.Rule[S, S, Byte, Nothing]

Definition Classes
ByteCodeReader
def bytes(n: Int): rules.Rule[S, S, ByteCode, Nothing]

Definition Classes
ByteCodeReader
val classFile: rules.Rule[S, S, ClassFile, String]
val classRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def cond(f: (S) ⇒ Boolean): rules.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.

Definition Classes
StateRules
val constantPool: rules.Rule[S, S, ConstantPool, Nothing]
val constantPoolEntry: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val doubleConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def element_value: Parser[ElementValue]
val element_value_pair: rules.Rule[S, S, AnnotationElement, String]
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def error[X](err: X): rules.Rule[Any, Nothing, Nothing, X]

Definition Classes
Rules
def error[In]: rules.Rule[In, Nothing, Nothing, In]

Definition Classes
Rules
def expect[In, Out, A, Any](rule: rules.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.

Definition Classes
Rules
val factory: RulesWithState

Definition Classes
RulesWithState → StateRules
def failure: rules.Rule[Any, Nothing, Nothing, Nothing]

Definition Classes
Rules
val field: rules.Rule[S, S, Field, Nothing]
val fieldRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val fields: rules.Rule[S, S, Seq[Field], Nothing]
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val floatConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def from[In]: AnyRef { def apply[Out, A, X](f: In => com.codahale.jerkson.util.scalax.rules.Result[Out,A,X]): com.codahale.jerkson.util.scalax.rules.Rule[In,Out,A,X] }

Definition Classes
Rules
def get: rules.Rule[S, S, S, Nothing]

Definition Classes
StateRules
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
val header: rules.Rule[S, S, ClassFileHeader, String]
implicit def inRule[In, Out, A, X](rule: rules.Rule[In, Out, A, X]): InRule[In, Out, A, X]

Definition Classes
Rules
val intConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val interfaceMethodRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val interfaces: rules.Rule[S, S, Seq[Int], Nothing]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
val longConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val magicNumber: rules.Rule[S, S, Int, String]
def memberRef(description: String): rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val method: rules.Rule[S, S, Method, Nothing]
val methodRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val methods: rules.Rule[S, S, Seq[Method], Nothing]
val nameAndType: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def nil: rules.Rule[S, S, Nil.type, Nothing]

Definition Classes
StateRules
def none: rules.Rule[S, S, None.type, Nothing]

Definition Classes
StateRules
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def oneOf[In, Out, A, X](rules: rules.Rule[In, Out, A, X]*): rules.Rule[In, Out, A, X]

Definition Classes
Rules
def parse(byteCode: ByteCode): ClassFile
def parseAnnotations(byteCode: ByteCode): Seq[Annotation]
def read[A](f: (S) ⇒ A): rules.Rule[S, S, A, Nothing]

Definition Classes
StateRules
def repeatUntil[T, X](rule: Rule[(T) ⇒ T, X])(finished: (T) ⇒ Boolean)(initial: T): rules.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.

Definition Classes
StateRules
implicit def rule[In, Out, A, X](f: (In) ⇒ Result[Out, A, X]): rules.Rule[In, Out, A, X]

Definition Classes
Rules
def ruleWithName[In, Out, A, X](_name: String, f: (In) ⇒ Result[Out, A, X]): rules.Rule[In, Out, A, X] with Name

Definition Classes
Rules
implicit def seqRule[In, A, X](rule: rules.Rule[In, In, A, X]): SeqRule[In, A, X]

Definition Classes
Rules
def set(s: ⇒ S): rules.Rule[S, S, S, Nothing]

Definition Classes
StateRules
def state[s]: StateRules { type S = s }

Definition Classes
Rules
val stringRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
def success[Out, A](out: Out, a: A): rules.Rule[Any, Out, A, Nothing]

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

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
val u1: rules.Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
val u2: rules.Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
val u4: rules.Rule[S, S, Int, Nothing]

Definition Classes
ByteCodeReader
def unit[A](a: ⇒ A): rules.Rule[S, S, A, Nothing]

Definition Classes
StateRules
def update(f: (S) ⇒ S): rules.Rule[S, S, S, Nothing]

Definition Classes
StateRules
val utf8String: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]
val version: rules.Rule[S, S, (Int, Int), Nothing]
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 scalasig

object ClassFileParser extends ByteCodeReader

Type Members

case class Annotation(typeIndex: Int, elementValuePairs: Seq[AnnotationElement]) extends ElementValue with Product with Serializable

case class AnnotationElement(elementNameIndex: Int, elementValue: ElementValue) extends Product with Serializable

case class ArrayValue(values: Seq[ElementValue]) extends ElementValue with Product with Serializable

case class ClassInfoIndex(index: Int) extends ElementValue with Product with Serializable

case class ConstValueIndex(index: Int) extends ElementValue with Product with Serializable

class DefaultRule[In, Out, A, X] extends Rule[In, Out, A, X]

abstract class ElementValue extends AnyRef

case class EnumConstValue(typeNameIndex: Int, constNameIndex: Int) extends ElementValue with Product with Serializable

type Parser[A] = rules.Rule[S, S, A, String]

type Rule[+A, +X] = rules.Rule[S, S, A, X]

type S = ByteCode

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def add1[T](f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool

def add2[T](f: (T) ⇒ (ConstantPool) ⇒ Any)(raw: T)(pool: ConstantPool): ConstantPool

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

val annotation: Parser[Annotation]

val annotations: rules.Rule[S, S, Seq[Annotation], String]

def anyOf[A, X](rules: Seq[Rule[A, X]]): rules.Rule[S, S, List[A], X]

def apply[A, X](f: (S) ⇒ Result[S, A, X]): rules.Rule[S, S, A, X]

final def asInstanceOf[T0]: T0

val attribute: rules.Rule[S, S, Attribute, Nothing]

val attributes: rules.Rule[S, S, Seq[Attribute], Nothing]

val byte: rules.Rule[S, S, Byte, Nothing]

def bytes(n: Int): rules.Rule[S, S, ByteCode, Nothing]

val classFile: rules.Rule[S, S, ClassFile, String]

val classRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def clone(): AnyRef

def cond(f: (S) ⇒ Boolean): rules.Rule[S, S, S, Nothing]

val constantPool: rules.Rule[S, S, ConstantPool, Nothing]

val constantPoolEntry: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val doubleConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def element_value: Parser[ElementValue]

val element_value_pair: rules.Rule[S, S, AnnotationElement, String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error[X](err: X): rules.Rule[Any, Nothing, Nothing, X]

def error[In]: rules.Rule[In, Nothing, Nothing, In]

def expect[In, Out, A, Any](rule: rules.Rule[In, Out, A, Any]): (In) ⇒ A

val factory: RulesWithState

def failure: rules.Rule[Any, Nothing, Nothing, Nothing]

val field: rules.Rule[S, S, Field, Nothing]

val fieldRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val fields: rules.Rule[S, S, Seq[Field], Nothing]

def finalize(): Unit

val floatConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

def from[In]: AnyRef { def apply[Out, A, X](f: In => com.codahale.jerkson.util.scalax.rules.Result[Out,A,X]): com.codahale.jerkson.util.scalax.rules.Rule[In,Out,A,X] }

def get: rules.Rule[S, S, S, Nothing]

final def getClass(): Class[_]

def hashCode(): Int

val header: rules.Rule[S, S, ClassFileHeader, String]

implicit def inRule[In, Out, A, X](rule: rules.Rule[In, Out, A, X]): InRule[In, Out, A, X]

val intConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val interfaceMethodRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val interfaces: rules.Rule[S, S, Seq[Int], Nothing]

final def isInstanceOf[T0]: Boolean

val longConstant: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val magicNumber: rules.Rule[S, S, Int, String]

def memberRef(description: String): rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val method: rules.Rule[S, S, Method, Nothing]

val methodRef: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

val methods: rules.Rule[S, S, Seq[Method], Nothing]

val nameAndType: rules.Rule[S, S, (ConstantPool) ⇒ ConstantPool, Nothing]

final def ne(arg0: AnyRef): Boolean

def nil: rules.Rule[S, S, Nil.type, Nothing]

def none: rules.Rule[S, S, None.type, Nothing]

final def notify(): Unit

final def notifyAll(): Unit

def oneOf[In, Out, A, X](rules: rules.Rule[In, Out, A, X]*): rules.Rule[In, Out, A, X]

def parse(byteCode: ByteCode): ClassFile

def parseAnnotations(byteCode: ByteCode): Seq[Annotation]

def read[A](f: (S) ⇒ A): rules.Rule[S, S, A, Nothing]

def repeatUntil[T, X](rule: Rule[(T) ⇒ T, X])(finished: (T) ⇒ Boolean)(initial: T): rules.Rule[S, S, T, X]

implicit def rule[In, Out, A, X](f: (In) ⇒ Result[Out, A, X]): rules.Rule[In, Out, A, X]