TypeName

abstract def createCompanionName(h: Int): TermName

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andThen[A](g: (Char) ⇒ A): (Int) ⇒ A

def append(suffix: Name): ThisNameType

def append(suffix: String): ThisNameType

def append(ch: Char): ThisNameType

TODO - find some efficiency.

final def apply(i: Int): Char

final def asInstanceOf[T0]: T0

def bothNames: List[Name]

def clone(): AnyRef

def companionName: TermName

def compose[A](g: (A) ⇒ Int): (A) ⇒ Char

final def containsChar(ch: Char): Boolean

final def containsName(subname: Name): Boolean

final def containsName(subname: String): Boolean

final def copyChars(cs: Array[Char], offset: Int): Unit

Copy bytes of this name to buffer cs, starting at position offset.

final def copyUTF8(bs: Array[Byte], offset: Int): Int

Write to UTF8 representation of this name to given character array.

def debugString: String

def decode: String

Replace $op_name by corresponding operator symbol.

def decoded: String

!!! Duplicative but consistently named.

def decodedName: ThisNameType

def drop(n: Int): ThisNameType

def dropRight(n: Int): ThisNameType

def encode: ThisNameType

Replace operator symbols by corresponding $op_name.

def encoded: String

def encodedName: ThisNameType

final def endChar: Char

final def endsWith(name: String): Boolean

final def endsWith(char: Char): Boolean

final def endsWith(suffix: Name, end: Int): Boolean

Does this name end with suffix just before given end index?

final def endsWith(suffix: Name): Boolean

Does this name end with suffix?

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final def hashCode(): Int

val index: Int

def indexOf(ch: Char, fromIndex: Int): Int

def indexOf(ch: Char): Int

final def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isOperatorName: Boolean

def isTermName: Boolean

def isTypeName: Boolean

def lastIndexOf(ch: Char, fromIndex: Int): Int

def lastIndexOf(ch: Char): Int

final def lastPos(s: String, start: Int): Int

Returns the index of the last occurrence of string s in this name from start, -1 if not found.

final def lastPos(c: Char, start: Int): Int

Returns the index of the last occurrence of char c in this name from start, -1 if not found.

final def lastPos(s: String): Int

final def lastPos(c: Char): Int

Returns the index of last occurrence of char c in this name, -1 if not found.

val len: Int

final def length: Int

The length of this name.

def longString: String

def mapName(f: (String) ⇒ String): ThisNameType

Return a new name based on string transformation.

def nameKind: String

final def ne(arg0: AnyRef): Boolean

def newName(str: String): TypeName

Return a new name of the same variety.

var next: TypeName

The next name in the same hash bucket.

final def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def pos(s: String, start: Int): Int

Returns the index of the first occurrence of nonempty string s in this name from start, length if not found.

final def pos(c: Char, start: Int): Int

Returns the index of the first occurrence of character c in this name from start, length if not found.

final def pos(s: String): Int

final def pos(c: Char): Int

def prepend(prefix: Name): ThisNameType

def prepend(prefix: String): ThisNameType

def prepend(ch: Char): ThisNameType

def replace(from: Char, to: Char): Name

Replace all occurrences of from by to in name; result is always a term name.

def start: Int

Index into name table

final def startChar: Char

Some thoroughly self-explanatory convenience functions.

final def startsWith(name: String): Boolean

final def startsWith(char: Char): Boolean

final def startsWith(prefix: Name, start: Int): Boolean

Does this name start with prefix at given start index?

final def startsWith(prefix: Name): Boolean

Does this name start with prefix?

def subName(from: Int, to: Int): TypeName

Return the subname with characters from from to to-1.

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

def thisName: TypeName

final def toChars: Array[Char]

def toString(): String

def toTermName: TermName

def toTypeName: TypeName

final def wait(): Unit

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

final def wait(arg0: Long): Unit