Abstract Value Members
-
abstract
def
getCharLength(s: PState): Long
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
final
def
==(arg0: Any): Boolean
-
def
PE(pstate: PState, s: String, args: Any*): Unit
-
final
def
areLogging(lvl: Type): Boolean
-
final
def
asInstanceOf[T0]: T0
-
def
briefXMLAttributes: String
-
final
def
captureValueLength(state: PState, startBitPos0b: ULong, endBitPos0b: ULong): Unit
-
final
def
captureValueLengthOfString(state: PState, str: String): Unit
-
def
charsetEv: Nothing
-
lazy val
childProcessors: Seq[Parser]
-
def
clone(): AnyRef
-
-
def
doLogging(lvl: Type, msg: String, args: Seq[Any]): Unit
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equals(arg0: Any): Boolean
-
def
finalize(): Unit
-
final
def
getBitLength(s: PState): MaybeULong
-
final
def
getClass(): Class[_]
-
def
getLogWriter(): LogWriter
-
final
def
getLoggingLevel(): Type
-
def
hashCode(): Int
-
var
isInitialized: Boolean
-
final
def
isInstanceOf[T0]: Boolean
-
final
def
isPrimitive: Boolean
-
final macro
def
log(lvl: Type, msg: String, args: Any*): Unit
-
lazy val
logID: String
-
var
logLevel: Maybe[Type]
-
var
logWriter: Maybe[LogWriter]
-
final
def
ne(arg0: AnyRef): Boolean
-
def
nom: String
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
final
def
parse(pState: PState): Unit
-
final
def
parse1(pstate: PState): Unit
-
def
parserName: String
-
def
processingError(state: PState, str: String, args: Any*): Unit
-
lazy val
runtimeDependencies: Nil.type
-
def
setLogWriter(lw: LogWriter): Unit
-
def
setLoggingLevel(level: Type): Unit
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toBriefXML(depthLimit: Int = 1): String
-
def
toString(): String
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
macro
def
withLoggingLevel[S](newLevel: Type)(body: ⇒ S): Unit
Inherited from Serializable
Inherited from Serializable
Inherited from Logging
Inherited from Identity
Inherited from AnyRef
Inherited from Any
This is used when length is measured in characters, and couldn't be converted to a computation on length in bits because a character is encoded as a variable number of bytes, e.g., in utf-8 encoding where a character can be 1 to 4 bytes.
Alternatively, this is also used if the encoding is coming from an expression, so we don't know if it will come back as utf-8 (variable width) or ascii (fixed width)
This base is used for complex types where we need to know how long the "box" is, that all the complex content must fit within, where that box length is measured in characters. In the complex content case we do not need the string that is all the characters, as we're going to recursively descend and parse it into the complex structure.