RootPackageImpl

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (RootPackageImpl, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def abstractTypes: List[AbstractType]

All abstract types that are members of this template.

def aliasTypes: List[AliasType]

All type aliases that are members of this template.

def allSubClasses: List[DocTemplateEntity]

All class, trait and object templates for which this template is a direct or indirect super-class or super-trait.

def annotations: List[Annotation]

The annotations attached to this entity, if any.

final def asInstanceOf[T0]: T0

def byConversion: Option[ImplicitConversion]

If this member originates from an implicit conversion, we set the implicit information to the correct origin

def clone(): AnyRef

lazy val comment: Option[Comment]

def companion: Option[DocTemplateEntity]

The companion of this template, or none.

def completeModel: Unit

This is the final point in the core model creation: no DocTemplates are created after the model has finished, but inherited templates and implicit members are added to the members at this point.

lazy val contentDiagram: Option[Diagram]

val conversions: List[ImplicitConversionImpl]

The implicit conversions this template (class or trait, objects and packages are not affected)

lazy val definitionName: String

def deprecation: Option[Body]

Some deprecation message if this member is deprecated, or none otherwise.

def directSubClasses: List[DocTemplateEntity]

All class, trait and object templates for which this template is a *direct* super-class or super-trait.

def ensuring(cond: (RootPackageImpl) ⇒ Boolean, msg: ⇒ Any): RootPackageImpl

def ensuring(cond: (RootPackageImpl) ⇒ Boolean): RootPackageImpl

def ensuring(cond: Boolean, msg: ⇒ Any): RootPackageImpl

def ensuring(cond: Boolean): RootPackageImpl

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flags: List[Paragraph]

The flags that have been set for this entity.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

val id: Int

Similar to symbols, so we can track entities

var implicitsShadowing: Map[MemberEntity, ImplicitMemberShadowing]

The shadowing information for the implicitly added members

def inDefinitionTemplates: List[TemplateEntity]

The templates in which this member has been declared.

def inPackageObject: Boolean

Whether or not the template was defined in a package object

def inSource: Option[(AbstractFile, Int)]

The source file in which the current template is defined and the line where the definition starts, if they exist.

def inTemplate: PackageImpl

The package of which this package is a member.

val inTpl: TemplateImpl

def incomingImplicitlyConvertedClasses: List[(DocTemplateEntity, ImplicitConversionImpl)]

Classes that can be implcitly converted to this class

lazy val inheritanceDiagram: Option[Diagram]

def inheritedFrom: List[TemplateEntity]

def isAbstract: Boolean

Whether this member is abstract.

def isAbstractType: Boolean

Whether this member is an abstract type.

def isAliasType: Boolean

Whether this member is an alias type.

def isCaseClass: Boolean

Whether this template is a case class.

def isClass: Boolean

Whether this template is a class.

def isConstructor: Boolean

Whether this member is a constructor.

def isDef: Boolean

Whether this member is a method.

def isDocTemplate: Boolean

Whether documentation is available for this template.

def isImplicit: Boolean

Whether this member is implicit.

final def isInstanceOf[T0]: Boolean

def isLazyVal: Boolean

Whether this member is a lazy value.

def isObject: Boolean

Whether this template is an object.

def isPackage: Boolean

Whether this template is a package (including the root package).

def isRootPackage: Boolean

Whether this template is the root package.

def isTemplate: Boolean

Whether this member is a template.

def isTrait: Boolean

Whether this template is a trait.

def isVal: Boolean

Whether this member is a value (this excludes lazy values).

def isVar: Boolean

Whether this member is a variable.

def kind: String

The kind of the entity

lazy val linearization: List[(TemplateEntity, TypeEntity)]

def linearizationFromSymbol(symbol: Symbol): List[(TemplateEntity, TypeEntity)]

def linearizationTemplates: List[TemplateEntity]

All class, trait and object templates which are part of this template's linearization, in lineratization order.

def linearizationTypes: List[TypeEntity]

All instantiated types which are part of this template's linearization, in lineratization order.

lazy val memberSyms: List[Symbol]

var memberSymsEager: List[Symbol]

var memberSymsLazy: List[Symbol]

var members: List[MemberImpl]

All members of this template.

def methods: List[Def]

All methods that are members of this template.

def migration: Option[Body]

Some migration warning if this member has a migration annotation, or none otherwise.

val name: String

The name of the entity.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val outgoingImplicitlyConvertedClasses: List[(TemplateEntity, TypeEntity, ImplicitConversionImpl)]

val ownMembers: List[MemberImpl]

def ownType: TypeEntity

The type of this entity, with type members

def packages: List[Package]

All packages that are member of this package.

def parentTemplates: List[TemplateImpl]

def parentTypes: List[(TemplateEntity, TypeEntity)]

The direct super-type of this template e.

class A extends B[C[Int]] with D[E]

def qualifiedName: String

The qualified name of the entity.

def registerImplicitlyConvertibleClass(dtpl: DocTemplateEntity, conv: ImplicitConversionImpl): Unit

def registerSubClass(sc: DocTemplateEntity): Unit

def resultType: TypeEntity

For members representing values: the type of the value returned by this member; for members representing types: the type itself.

def selfType: Option[TypeEntity]

The self-type of this template, if it differs from the template type.

def sourceUrl: Option[URL]

An HTTP address at which the source of this template is available, if it is available.

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

def templates: List[DocTemplateEntity]

All templates that are members of this template.

def toRoot: List[PackageImpl]

The package such that each is a member of the package that follows it; the first package is always this package, the last the root package.

def toString(): String

The qualified name of this entity.

def typeParams: List[TypeParam]

The type parameters of this entity.

val universe: Universe

The Scaladoc universe of which this entity is a member.

def useCaseOf: Option[MemberEntity]

If this symbol is a use case, the useCaseOf will contain the member it was derived from, containing the full signature and the complete parameter descriptions.

def values: List[Val]

All values, lazy values and variables that are members of this template.

def visibility: Visibility

The visibility of this member.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (RootPackageImpl, B)

val self: Any

val self: Any

def x: RootPackageImpl

def x: RootPackageImpl