RootPackageImpl

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): ((ModelFactory.this)#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[(ModelFactory.this)#ImplicitConversionImpl]

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.

def constructors: List[(ModelFactory.this)#MemberImpl with Constructor]

All constructors of this class, including the primary constructor.

def contentDiagram: Option[Diagram]

If this template contains other templates, such as classes and traits, they will be shown in this diagram

val conversions: List[(ModelFactory.this)#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: collection.immutable.List[DocTemplateEntity]

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

def ensuring(cond: ((ModelFactory.this)#RootPackageImpl) ⇒ Boolean, msg: ⇒ Any): (ModelFactory.this)#RootPackageImpl

def ensuring(cond: ((ModelFactory.this)#RootPackageImpl) ⇒ Boolean): (ModelFactory.this)#RootPackageImpl

def ensuring(cond: Boolean, msg: ⇒ Any): (ModelFactory.this)#RootPackageImpl

def ensuring(cond: Boolean): (ModelFactory.this)#RootPackageImpl

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def flags: collection.immutable.List[Paragraph]

The flags that have been set for this entity.

def formatted(fmtstr: String): String

final def getClass(): java.lang.Class[_]

def group: String

The group this member is from

def groupDescription(group: String): Option[Body]

Returns the group description taken either from this template or its linearizationTypes

def groupName(group: String): String

Returns the group description taken either from this template or its linearizationTypes

def groupPriority(group: String): Int

Returns the group description taken either from this template or its linearizationTypes

def groupSearch[T](extractor: (Comment) ⇒ Option[T]): Option[T]

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

lazy val inSource: Option[(AbstractFile, Int)]

def inSourceFromSymbol(symbol: Global.Symbol): Option[(AbstractFile, Int)]

def inTemplate: (ModelFactory.this)#PackageImpl

The package of which this package is a member.

val inTpl: (ModelFactory.this)#TemplateImpl

def incomingImplicitlyConvertedClasses: List[((ModelFactory.this)#DocTemplateImpl, (ModelFactory.this)#ImplicitConversionImpl)]

Classes that can be implcitly converted to this class

def inheritanceDiagram: Option[Diagram]

If this template takes place in inheritance and implicit conversion relations, it will be shown in this 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 isAmbiguousImplicit: Boolean

Indicates whether there are other implicitly inherited members that have similar signatures (and thus they all become ambiguous)

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.

def isImplicitlyInherited: Boolean

Indicates whether the member is inherited by implicit conversion

final def isInstanceOf[T0]: Boolean

def isLazyVal: Boolean

Whether this member is a lazy value.

def isNoDocMemberTemplate: Boolean

Whether documentation is available for this template.

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 isShadowedImplicit: Boolean

Indicates whether there is another member with the same name in the template that will take precendence

def isShadowedOrAmbiguousImplicit: Boolean

Indicates whether the implicitly inherited member is shadowed or ambiguous in its template

def isTemplate: Boolean

Whether this member is a template.

def isTerm: Boolean

Indicates whether this entity lives in the terms namespace (objects, packages, methods, values)

def isTrait: Boolean

Whether this template is a trait.

def isType: Boolean

Indicates whether this entity lives in the types namespace (classes, traits, abstract/alias types)

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: Global.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[Global.Symbol]

var memberSymsEager: collection.immutable.List[Global.Symbol]

var memberSymsLazy: collection.immutable.List[Global.Symbol]

var members: List[(ModelFactory.this)#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, (ModelFactory.this)#ImplicitConversionImpl)]

val ownMembers: collection.immutable.List[(ModelFactory.this)#MemberImpl]

def packages: List[Package]

All packages that are member of this package.

def parentTypes: List[(TemplateEntity, TypeEntity)]

TODO, these are now only computed for DocTemplates

def primaryConstructor: Option[(ModelFactory.this)#MemberImpl with Constructor]

The primary constructor of this class, if it has been defined.

def qualifiedName: String

The qualified name of the entity.

def registerImplicitlyConvertibleClass(dtpl: (ModelFactory.this)#DocTemplateImpl, conv: (ModelFactory.this)#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 signature: String

The identity of this member, used for linking

lazy val signatureCompat: String

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[TemplateEntity with MemberEntity]

All templates that are members of this template.

def toRoot: List[(ModelFactory.this)#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 valueParams: List[List[ValueParam]]

The value parameters of this case class, or an empty list if this class is not a case class.

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): ((ModelFactory.this)#RootPackageImpl, B)

val self: Any

val self: Any

def x: (ModelFactory.this)#RootPackageImpl

def x: (ModelFactory.this)#RootPackageImpl