zinc ApiInfo/xsbt.api/HashAPI

HashAPI

final class HashAPI

Implements hashing of public API.

Value parameters:
includeDefinitions

when hashing a structure (e.g. of a class) should hashes of definitions (members) be included in a hash sum. Structure can appear as a type (in structural type). In that case we always include definitions in a hash sum.

includeParamNames

should parameter names for methods be included in a hash sum

includePrivate

should private definitions be included in a hash sum

includeSealedChildren

Controls if types of children of sealed class should be included in hash.

Companion:
object
class Object
trait Matchable
class Any

Value members

Constructors

def this(includePrivate: Boolean, includeParamNames: Boolean)

Concrete methods

final def extend(a: Hash): Unit
def hashAPI(c: ClassLike): Unit
def hashAccess(a: Access): Unit
def hashAnnotated(a: Annotated): Unit
def hashAnnotation(annotation: Annotation): Unit
def hashAnnotationArgument(arg: AnnotationArgument): Unit
def hashAnnotationArguments(args: Array[AnnotationArgument]): Unit
def hashAnnotations(annotations: Array[Annotation]): Unit
final def hashArray[T <: AnyRef](s: Array[T], hashF: T => Unit): Unit
final def hashBoolean(b: Boolean): Unit
final def hashClass(c: ClassLike): Unit
def hashClass0(c: ClassLike): Unit
final def hashClassDef(c: ClassLikeDef): Unit
def hashConstant(c: Constant): Unit
def hashDef(d: Def): Unit
def hashDefinition(d: Definition): Unit
def hashDefinitions(ds: Seq[Definition], topLevel: Boolean, isTrait: Boolean): Unit
def hashDefinitionsWithExtraHash(ds: IterableOnce[Definition], extraHash: Hash): Unit

Hashes a sequence of definitions by combining each definition's own hash with extra one supplied.

Hashes a sequence of definitions by combining each definition's own hash with extra one supplied.

It's useful when one wants to influence hash of a definition by some external (to definition) factor (e.g. location of definition).

NOTE: This method doesn't perform any filtering of passed definitions.

def hashExistential(e: Existential): Unit
def hashField(f: FieldLike): Unit
def hashIdPath(id: Id): Unit
def hashModifiers(m: Modifiers): Unit
def hashPackage(p: Package): Unit
def hashParameterRef(p: ParameterRef): Unit
def hashParameterized(p: Parameterized): Unit
def hashParameterizedDefinition[T <: ParameterizedDefinition](d: T): Unit
def hashParameters(parameters: Array[TypeParameter], base: Type): Unit
def hashPath(path: Path): Unit
def hashPathComponent(pc: PathComponent): Unit
def hashPolymorphic(p: Polymorphic): Unit
def hashProjection(p: Projection): Unit
def hashQualified(qual: Qualified): Unit
def hashQualifier(qual: Qualifier): Unit
def hashSingleton(s: Singleton): Unit
final def hashString(s: String): Unit
def hashStructure(structure: Structure, includeDefinitions: Boolean, isTrait: Boolean): Unit
def hashStructure0(structure: Structure, includeDefinitions: Boolean, isTrait: Boolean): Unit
def hashSuperPath(s: Super): Unit
final def hashSymmetric[T](ts: IterableOnce[T], hashF: T => Unit): Unit
def hashType(t: Type, includeDefinitions: Boolean): Unit
def hashTypeAlias(d: TypeAlias): Unit
def hashTypeDeclaration(d: TypeDeclaration): Unit
def hashTypeParameter(parameter: TypeParameter): Unit
def hashTypeParameters(parameters: Array[TypeParameter]): Unit
def hashTypes(ts: Array[Type], includeDefinitions: Boolean): Unit
def hashTypesSymmetric(ts: Array[Type], includeDefinitions: Boolean): Unit
def hashValueParameter(parameter: MethodParameter): Unit
def hashValueParameterList(list: ParameterList): Unit
def hashValueParameters(valueParameters: Array[ParameterList]): Unit