Display the source code in dmd/dclass.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Class `dmd.dclass.InterfaceDeclaration`


						
				class InterfaceDeclaration
				
  : ClassDeclaration
				;

Fields

Name	Type	Description
`baseok`	`dmd.aggregate.Baseok`	set the progress of base classes resolving
`classKind`	`ClassKind`	specifies whether this is a D, C++, Objective-C or anonymous class/interface
`objc`	`ObjcClassDeclaration`	Data for a class declaration that is needed for the Objective-C integration.
`stack`	`bool`	true if this is a scope class

Methods

Name	Description
`isBaseOf`	Determine if 'this' is a base class of cd. (Actually, if it is an interface supported by cd)
`kind`
`vtblOffset`	Determine if slot 0 of the vtbl[] is reserved for something else. For class objects, yes, this is where the ClassInfo ptr goes. For COM interfaces, no. For non-COM interfaces, yes, this is where the Interface ptr goes.
`accept`
`addComment`	Add documentation comment to Dsymbol. Ignore NULL comments.
`addLocalClass`
`alignmember`	Do byte or word alignment as necessary. Align sizes of 0, as we may not know array sizes yet.
`apply`	Iterate this dsymbol or members of this scoped dsymbol, then call `fp` with the found symbol and `param`.
`arraySyntaxCopy`	Do syntax copy of an array of Dsymbol's.
`checkOverlappedFields`	Calculate field[i].overlapped and overlapUnsafe, and check that all of explicit field initializers have unique memory space on instance.
`determineFields`	Find all instance fields, then push them into `fields`.
`determineSize`	Collect all instance fields, then determine instance size.
`dim`	Determine number of Dsymbols, folding in AttribDeclaration members.
`factory`	Create instance of class specified by the fully qualified name classname. The class must either have no constructors or have a default constructor.
`fill`	Fill out remainder of elements[] with default initializers for fields[].
`findFunc`	Find virtual function matching identifier and type. Used to build virtual function tables for interface implementations.
`findGetMembers`	Look for member of the form: const(MemberInfo)[] getMembers(string); Returns NULL if not found
`getAccessModule`	Determine which Module a Dsymbol is in, as far as access rights go.
`getModule`	Determine which Module a Dsymbol is in.
`getNth`	Get nth Dsymbol, folding in AttribDeclaration members.
`hasPointers`	Is Dsymbol a variable that contains pointers?
`hasStaticCtorOrDtor`	Return true if any of the members are static ctors or static dtors, or if any members have members that are.
`inNonRoot`	Returns true if this symbol is defined in a non-root module without instantiation.
`isAbstract`
`isBaseInfoComplete`	Determine if 'this' has complete base class information. This is used to detect forward references in covariant overloads.
`isBaseOf2`	Determine if 'this' is a base class of cd. This is used to detect circular inheritance only.
`isCOMclass`
`isMember`	Returns an AggregateDeclaration when toParent() is that.
`isMember2`	Returns an AggregateDeclaration when toParent2() is that.
`isNested`	Returns true if there's an extra member which is the 'this' pointer to the enclosing context (enclosing aggregate or function)
`newScope`	Create a new scope from sc. semantic, semantic2 and semantic3 will use this for aggregate members.
`oneMember`	Determine if this symbol is only one.
`oneMembers`	Same as Dsymbol::oneMember(), but look at an array of Dsymbols.
`opCmp`	Compare with another Object obj.
`opEquals`	Test whether `this` is equal to `o`. The default implementation only compares by identity (using the `is` operator). Generally, overrides for `opEquals` should attempt to compare objects by their contents.
`placeField`	Place a member (mem) into an aggregate (agg), which can be a struct, union or class
`prot`
`search`	This function is #1 on the list of functions that eat cpu time. Be very, very careful about slowing it down.
`searchBase`	Search base classes in depth-first, left-to-right order for a class or interface named 'ident'. Stops at first found. Does not look for additional matches.
`searchCtor`	Look for constructor declaration.
`searchX`	Search for identifier id as a member of `this`. `id` may be a template instance.
`setScope`	Set scope for future semantic analysis so we can deal better with forward references.
`size`
`symtabLookup`	Look up identifier in symbol table.
`syntaxCopy`	Copy the syntax. Used for template instantiations. If s is NULL, allocate the new object, otherwise fill it in.
`toAlias`	If this symbol is really an alias for another, return that other. If needed, semantic() is invoked due to resolve forward reference.
`toAlias2`	Resolve recursive tuple expansion in eponymous template.
`toHash`	Compute hash function for Object.
`toParent`	`parent` field returns a lexically enclosing scope symbol this is a member of.
`toParent2`	`parent` field returns a lexically enclosing scope symbol this is a member of.
`toString`	Convert Object to a human readable string.
`_foreach`	Expands attribute declarations in members in depth first order. Calls dg(size_t symidx, Dsymbol *sym) for each member. If dg returns !=0, stops and returns that value else returns 0. Use this function to avoid the O(N + N^2/2) complexity of calculating dim and calling N times getNth.

Authors

Walter Bright

License

Boost License 1.0