The `classdef.cpp` File Reference

Included Headers

#include <cstdio> #include <algorithm> #include "types.h" #include "classdef.h" #include "classlist.h" #include "entry.h" #include "doxygen.h" #include "membername.h" #include "message.h" #include "config.h" #include "util.h" #include "diagram.h" #include "language.h" #include "htmlhelp.h" #include "example.h" #include "outputlist.h" #include "dot.h" #include "dotclassgraph.h" #include "dotrunner.h" #include "defargs.h" #include "debug.h" #include "docparser.h" #include "searchindex.h" #include "vhdldocgen.h" #include "layout.h" #include "arguments.h" #include "memberlist.h" #include "groupdef.h" #include "filedef.h" #include "namespacedef.h" #include "membergroup.h" #include "definitionimpl.h" #include "symbolresolver.h" #include "fileinfo.h" #include "trace.h" #include "moduledef.h"

Classes Index

class	ClassDefImpl
	Implementation of the ClassDef interface. More...

class	ClassDefAliasImpl

Functions Index

static QCString	makeQualifiedNameWithTemplateParameters (const ClassDef cd, const ArgumentLists actualParams, uint32_t *actualParamIndex)


static QCString	makeDisplayName (const ClassDef *cd, bool includeScope)


static QCString	getCompoundTypeString (SrcLangExt lang, ClassDef::CompoundType compType, bool isJavaEnum)


std::unique_ptr< ClassDef >	createClassDef (const QCString &fileName, int startLine, int startColumn, const QCString &name, ClassDef::CompoundType ct, const QCString &ref, const QCString &fName, bool isSymbol, bool isJavaEnum)
	Factory method to create a new ClassDef object. More...

std::unique_ptr< ClassDef >	createClassDefAlias (const Definition newScope, const ClassDef cd)


static void	writeInheritanceSpecifier (OutputList &ol, const BaseClassDef &bcd)


static void	searchTemplateSpecs (const Definition *d, ArgumentLists &result, QCString &name, SrcLangExt lang)


static bool	hasNonReferenceSuperClassRec (const ClassDef *cd, int level)


static bool	isStandardFunc (const MemberDef *md)


ClassDef *	toClassDef (Definition *d)


ClassDef *	toClassDef (DefinitionMutable *md)


const ClassDef *	toClassDef (const Definition *d)


ClassDefMutable *	toClassDefMutable (Definition *d)


ClassDef *	getClass (const QCString &n)


bool	classHasVisibleRoot (const BaseClassList &bcl)


bool	classHasVisibleChildren (const ClassDef *cd)


bool	classVisibleInIndex (const ClassDef *cd)


int	minClassDistance (const ClassDef cd, const ClassDef bcd, int level)


Protection	classInheritedProtectionLevel (const ClassDef cd, const ClassDef bcd, Protection prot, int level)

Functions

classHasVisibleChildren()

bool classHasVisibleChildren (const ClassDef * cd)

Definition at line 5489 of file classdef.cpp.

5489bool classHasVisibleChildren(const ClassDef *cd)

5490{

5491 BaseClassList bcl;

5492

5493 if (cd->getLanguage()==SrcLangExt::VHDL) // reverse baseClass/subClass relation

5494 {

5495 if (cd->baseClasses().empty()) return FALSE;

5496 bcl=cd->baseClasses();

5497 }

5498 else

5499 {

5500 if (cd->subClasses().empty()) return FALSE;

5501 bcl=cd->subClasses();

5502 }

5503

5504 for (const auto &bcd : bcl)

5505 {

5506 if (bcd.classDef->isVisibleInHierarchy())

5507 {

5508 return TRUE;

5509 }

5510 }

5511 return FALSE;

5512}

References ClassDef::baseClasses, FALSE, Definition::getLanguage, ClassDef::subClasses and TRUE.

Referenced by writeClassTreeForList and writeClassTreeToOutput.

classHasVisibleRoot()

bool classHasVisibleRoot (const BaseClassList & bcl)

Definition at line 5478 of file classdef.cpp.

5478bool classHasVisibleRoot(const BaseClassList &bcl)

5479{

5480 for (const auto &bcd : bcl)

5481 {

5482 const ClassDef *cd=bcd.classDef;

5483 if (cd->isVisibleInHierarchy()) return true;

5484 if (classHasVisibleRoot(cd->baseClasses())) return true;

5485 }

5486 return false;

5487}

References ClassDef::baseClasses, classHasVisibleRoot and ClassDef::isVisibleInHierarchy.

Referenced by DotGfxHierarchyTable::addClassList, DotGfxHierarchyTable::addHierarchy, classHasVisibleRoot, countClassesInTreeList, writeClassTreeForList and writeClassTreeToOutput.

classInheritedProtectionLevel()

Protection classInheritedProtectionLevel (const ClassDef * cd, const ClassDef * bcd, Protection prot, int level)

Definition at line 5548 of file classdef.cpp.

5548Protection classInheritedProtectionLevel(const ClassDef *cd,const ClassDef *bcd,Protection prot,int level)

5549{

5550 if (bcd->categoryOf()) // use class that is being extended in case of

5551 // an Objective-C category

5552 {

5553 bcd=bcd->categoryOf();

5554 }

5555 if (cd==bcd)

5556 {

5557 goto exit;

5558 }

5559 if (level==256)

5560 {

5561 err("Internal inconsistency: found class {} seem to have a recursive "

5562 "inheritance relation! Please send a bug report to doxygen@gmail.com\n",cd->name());

5563 }

5564 else if (prot!=Protection::Private)

5565 {

5566 for (const auto &bcdi : cd->baseClasses())

5567 {

5568 Protection baseProt = classInheritedProtectionLevel(bcdi.classDef,bcd,bcdi.prot,level+1);

5569 if (baseProt==Protection::Private) prot=Protection::Private;

5570 else if (baseProt==Protection::Protected) prot=Protection::Protected;

5571 }

5572 }

5573exit:

5574 //printf("classInheritedProtectionLevel(%s,%s)=%d\n",qPrint(cd->name()),qPrint(bcd->name()),prot);

5575 return prot;

5576}

References ClassDef::baseClasses, ClassDef::categoryOf, classInheritedProtectionLevel, err and Definition::name.

Referenced by classInheritedProtectionLevel.

classVisibleInIndex()

bool classVisibleInIndex (const ClassDef * cd)

Definition at line 5514 of file classdef.cpp.

5514bool classVisibleInIndex(const ClassDef *cd)

5515{

5516 bool allExternals = Config_getBool(ALLEXTERNALS);

5517 return (allExternals && cd->isLinkable()) || cd->isLinkableInProject();

5518}

References Config_getBool, Definition::isLinkable and Definition::isLinkableInProject.

Referenced by writeClassTree.

createClassDef()

std::unique_ptr< ClassDef > createClassDef (const QCString & fileName, int startLine, int startColumn, const QCString & name, ClassDef::CompoundType ct, const QCString & ref, const QCString & fName, bool isSymbol, bool isJavaEnum)

Factory method to create a new ClassDef object.

Definition at line 559 of file classdef.cpp.

559std::unique_ptr<ClassDef> createClassDef(

560 const QCString &fileName,int startLine,int startColumn,

561 const QCString &name,ClassDef::CompoundType ct,

562 const QCString &ref,const QCString &fName,

563 bool isSymbol,bool isJavaEnum)

564{

565 return std::make_unique<ClassDefImpl>(fileName,startLine,startColumn,name,ct,ref,fName,isSymbol,isJavaEnum);

566}

Referenced by addClassToContext, createTagLessInstance, findClassRelation, findUsedClassesForClass, findUsingDeclarations and ClassDefMutable::sortAllMembersList.

createClassDefAlias()

std::unique_ptr< ClassDef > createClassDefAlias (const Definition * newScope, const ClassDef * cd)

Definition at line 788 of file classdef.cpp.

788std::unique_ptr<ClassDef> createClassDefAlias(const Definition *newScope,const ClassDef *cd)

789{

790 auto acd = std::make_unique<ClassDefAliasImpl>(newScope,cd);

791 //printf("cd name=%s localName=%s qualifiedName=%s qualifiedNameWith=%s displayName()=%s\n",

792 // qPrint(acd->name()),qPrint(acd->localName()),qPrint(acd->qualifiedName()),

793 // qPrint(acd->qualifiedNameWithTemplateParameters()),qPrint(acd->displayName()));

794 return acd;

795}

Referenced by ClassDefAliasImpl::deepCopy, findUsingDeclImports, resolveClassNestingRelations and ClassDefMutable::sortAllMembersList.

getClass()

ClassDef * getClass (const QCString & n)

Get a class definition given its name. Returns nullptr if the class is not found.

Definition at line 5472 of file classdef.cpp.

5472ClassDef *getClass(const QCString &n)

5473{

5474 if (n.isEmpty()) return nullptr;

5475 return Doxygen::classLinkedMap->find(n);

5476}

References Doxygen::classLinkedMap and QCString::isEmpty.

Referenced by addVariable, buildScopeFromQualifiedName, extractNamespaceName, findClassWithinClassContext, findEnumDocumentation, findEnums, findMember, findUsingDeclarations, generateClassOrGlobalLink, generateClassOrGlobalLink, generateMemberLink, MemberDefImpl::getClassDefOfAnonymousType, getClassMutable, getScopeDefs, getTemplateArgumentsFromName, DocParser::handleLinkedWord, insertTemplateSpecifierInScope, MemberDefImpl::isDocumentedFriendClass, linkifyText, SymbolResolver::resolveClass, resolveLink, resolveRef, setCallContextForVar, ClassDefMutable::sortAllMembersList, stripTemplateSpecifiersFromScope and MemberDefImpl::writeDeclaration.

getCompoundTypeString()

QCString getCompoundTypeString (SrcLangExt lang, ClassDef::CompoundType compType, bool isJavaEnum)

static

Definition at line 146 of file classdef.cpp.

146static QCString getCompoundTypeString(SrcLangExt lang,ClassDef::CompoundType compType,bool isJavaEnum)

147{

148 if (lang==SrcLangExt::Fortran)

149 {

150 switch (compType)

151 {

152 case ClassDef::Class: return "module";

153 case ClassDef::Struct: return "type";

154 case ClassDef::Union: return "union";

155 case ClassDef::Interface: return "interface";

156 case ClassDef::Protocol: return "protocol";

157 case ClassDef::Category: return "category";

158 case ClassDef::Exception: return "exception";

159 default: return "unknown";

160 }

161 }

162 else

163 {

164 switch (compType)

165 {

166 case ClassDef::Class: return isJavaEnum ? "enum" : "class";

167 case ClassDef::Struct: return "struct";

168 case ClassDef::Union: return "union";

169 case ClassDef::Interface: return lang==SrcLangExt::ObjC ? "class" : "interface";

170 case ClassDef::Protocol: return "protocol";

171 case ClassDef::Category: return "category";

172 case ClassDef::Exception: return "exception";

173 case ClassDef::Service: return "service";

174 case ClassDef::Singleton: return "singleton";

175 default: return "unknown";

176 }

177 }

178}

References ClassDef::Category, ClassDef::Class, ClassDef::Exception, ClassDef::Interface, ClassDef::Protocol, ClassDef::Service, ClassDef::Singleton, ClassDef::Struct and ClassDef::Union.

Referenced by ClassDefImpl::ClassDefImpl, ClassDefImpl::compoundTypeString and ClassDefImpl::deepCopy.

hasNonReferenceSuperClassRec()

bool hasNonReferenceSuperClassRec (const ClassDef * cd, int level)

static

Definition at line 3480 of file classdef.cpp.

3480static bool hasNonReferenceSuperClassRec(const ClassDef *cd,int level)

3481{

3482 bool found=!cd->isReference() && cd->isLinkableInProject() && !cd->isHidden();

3483 if (found)

3484 {

3485 return TRUE; // we're done if this class is not a reference

3486 }

3487 for (const auto &ibcd : cd->subClasses())

3488 {

3489 const ClassDef *bcd=ibcd.classDef;

3490 if (level>256)

3491 {

3492 err("Possible recursive class relation while inside {} and looking for base class {}\n",cd->name(),bcd->name());

3493 return FALSE;

3494 }

3495 // recurse into the super class branch

3496 found = found || hasNonReferenceSuperClassRec(bcd,level+1);

3497 if (!found)

3498 {

3499 // look for template instances that might have non-reference super classes

3500 for (const auto &cil : bcd->getTemplateInstances())

3501 {

3502 // recurse into the template instance branch

3503 found = hasNonReferenceSuperClassRec(cil.classDef,level+1);

3504 if (found) break;

3505 }

3506 }

3507 else

3508 {

3509 break;

3510 }

3511 }

3512 return found;

3513}

References err, FALSE, ClassDef::getTemplateInstances, hasNonReferenceSuperClassRec, Definition::isHidden, Definition::isLinkableInProject, Definition::isReference, Definition::name, ClassDef::subClasses and TRUE.

Referenced by ClassDefImpl::hasNonReferenceSuperClass and hasNonReferenceSuperClassRec.

isStandardFunc()

bool isStandardFunc (const MemberDef * md)

static

Definition at line 3718 of file classdef.cpp.

3718static bool isStandardFunc(const MemberDef *md)

3719{

3720 return md->name()=="operator=" || // assignment operator

3721 md->isConstructor() || // constructor

3722 md->isDestructor(); // destructor

3723}

References MemberDef::isConstructor, MemberDef::isDestructor and Definition::name.

Referenced by ClassDefImpl::mergeMembersFromBaseClasses.

makeDisplayName()

QCString makeDisplayName (const ClassDef * cd, bool includeScope)

static

Definition at line 107 of file classdef.cpp.

107static QCString makeDisplayName(const ClassDef *cd,bool includeScope)

108{

109 //bool optimizeOutputForJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);

110 SrcLangExt lang = cd->getLanguage();

111 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);

112 QCString n;

113 if (lang==SrcLangExt::VHDL)

114 {

115 n = VhdlDocGen::getClassName(cd);

116 }

117 else

118 {

119 if (includeScope)

120 {

121 n=cd->qualifiedNameWithTemplateParameters();

122 }

123 else

124 {

125 n=cd->className();

126 }

127 }

128 if (cd->isAnonymous())

129 {

130 n = removeAnonymousScopes(n);

131 }

132 QCString sep=getLanguageSpecificSeparator(lang);

133 if (sep!="::")

134 {

135 n=substitute(n,"::",sep);

136 }

137 if (cd->compoundType()==ClassDef::Protocol && n.endsWith("-p"))

138 {

139 n="<"+n.left(n.length()-2)+">";

140 }

141 return n;

142}

References ClassDef::className, ClassDef::compoundType, QCString::endsWith, VhdlDocGen::getClassName, Definition::getLanguage, getLanguageSpecificSeparator, Definition::isAnonymous, QCString::left, QCString::length, ClassDef::Protocol, ClassDef::qualifiedNameWithTemplateParameters, removeAnonymousScopes and substitute.

Referenced by ClassDefAliasImpl::displayName and ClassDefImpl::displayName.

makeQualifiedNameWithTemplateParameters()

QCString makeQualifiedNameWithTemplateParameters (const ClassDef * cd, const ArgumentLists * actualParams, uint32_t * actualParamIndex)

static

Definition at line 56 of file classdef.cpp.

56static QCString makeQualifiedNameWithTemplateParameters(const ClassDef *cd,

57 const ArgumentLists *actualParams,uint32_t *actualParamIndex)

58{

59 //bool optimizeOutputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);

60 bool hideScopeNames = Config_getBool(HIDE_SCOPE_NAMES);

61 //printf("qualifiedNameWithTemplateParameters() localName=%s\n",qPrint(cd->localName()));

62 QCString scName;

63 const Definition *d=cd->getOuterScope();

64 if (d)

65 {

66 if (d->definitionType()==Definition::TypeClass)

67 {

68 const ClassDef *ocd=toClassDef(d);

69 scName = ocd->qualifiedNameWithTemplateParameters(actualParams,actualParamIndex);

70 }

71 else if (!hideScopeNames)

72 {

73 scName = d->qualifiedName();

74 }

75 }

77 SrcLangExt lang = cd->getLanguage();

78 QCString scopeSeparator = getLanguageSpecificSeparator(lang);

79 if (!scName.isEmpty()) scName+=scopeSeparator;

81 bool isSpecialization = cd->localName().find('<')!=-1;

82 QCString clName = cd->className();

83 scName+=clName;

84 if (lang!=SrcLangExt::CSharp && !cd->templateArguments().empty())

85 {

86 if (actualParams && *actualParamIndex<actualParams->size())

87 {

88 const ArgumentList &al = actualParams->at(*actualParamIndex);

89 if (!isSpecialization)

90 {

91 scName+=tempArgListToString(al,lang);

92 }

93 (*actualParamIndex)++;

94 }

95 else

96 {

97 if (!isSpecialization)

98 {

99 scName+=tempArgListToString(cd->templateArguments(),lang);

100 }

101 }

102 }

103 //printf("qualifiedNameWithTemplateParameters: scope=%s qualifiedName=%s\n",qPrint(name()),qPrint(scName));

104 return scName;

105}

References ArgumentList::at, ClassDef::className, Config_getBool, Definition::definitionType, ArgumentList::empty, QCString::find, Definition::getLanguage, getLanguageSpecificSeparator, Definition::getOuterScope, QCString::isEmpty, isSpecialization, Definition::localName, Definition::qualifiedName, ClassDef::qualifiedNameWithTemplateParameters, tempArgListToString, ClassDef::templateArguments, toClassDef and Definition::TypeClass.

Referenced by ClassDefAliasImpl::qualifiedNameWithTemplateParameters and ClassDefImpl::qualifiedNameWithTemplateParameters.

minClassDistance()

int minClassDistance (const ClassDef * cd, const ClassDef * bcd, int level)

Definition at line 5524 of file classdef.cpp.

5524int minClassDistance(const ClassDef *cd,const ClassDef *bcd,int level)

5525{

5526 const int maxInheritanceDepth = 100000;

5527 if (bcd->categoryOf()) // use class that is being extended in case of

5528 // an Objective-C category

5529 {

5530 bcd=bcd->categoryOf();

5531 }

5532 if (cd==bcd) return level;

5533 if (level==256)

5534 {

5535 warn_uncond("class {} seem to have a recursive inheritance relation!\n",cd->name());

5536 return -1;

5537 }

5538 int m=maxInheritanceDepth;

5539 for (const auto &bcdi : cd->baseClasses())

5540 {

5541 int mc=minClassDistance(bcdi.classDef,bcd,level+1);

5542 if (mc<m) m=mc;

5543 if (m<0) break;

5544 }

5545 return m;

5546}

References ClassDef::baseClasses, ClassDef::categoryOf, maxInheritanceDepth, minClassDistance, Definition::name and warn_uncond.

Referenced by getDefsOld, ClassDefImpl::getMemberByName and minClassDistance.

searchTemplateSpecs()

void searchTemplateSpecs (const Definition * d, ArgumentLists & result, QCString & name, SrcLangExt lang)

static

Definition at line 1467 of file classdef.cpp.

1467static void searchTemplateSpecs(/*in*/ const Definition *d,

1468 /*out*/ ArgumentLists &result,

1469 /*out*/ QCString &name,

1470 /*in*/ SrcLangExt lang)

1471{

1472 if (d->definitionType()==Definition::TypeClass)

1473 {

1474 if (d->getOuterScope())

1475 {

1476 searchTemplateSpecs(d->getOuterScope(),result,name,lang);

1477 }

1478 const ClassDef *cd=toClassDef(d);

1479 if (!name.isEmpty()) name+="::";

1480 QCString clName = d->localName();

1481 if (clName.endsWith("-p"))

1482 {

1483 clName = clName.left(clName.length()-2);

1484 }

1485 name+=clName;

1486 bool isSpecialization = d->localName().find('<')!=-1;

1487 if (!cd->templateArguments().empty())

1488 {

1489 result.push_back(cd->templateArguments());

1490 if (!isSpecialization)

1491 {

1492 name+=tempArgListToString(cd->templateArguments(),lang);

1493 }

1494 }

1495 }

1496 else

1497 {

1498 name+=d->qualifiedName();

1499 }

1500}

References Definition::definitionType, ArgumentList::empty, QCString::endsWith, QCString::find, Definition::getOuterScope, QCString::isEmpty, isSpecialization, QCString::left, QCString::length, Definition::localName, Definition::qualifiedName, searchTemplateSpecs, tempArgListToString, ClassDef::templateArguments, toClassDef and Definition::TypeClass.

Referenced by searchTemplateSpecs and ClassDefImpl::writeTemplateSpec.

toClassDef()

ClassDef * toClassDef (Definition * d)

Definition at line 5418 of file classdef.cpp.

5418ClassDef *toClassDef(Definition *d)

5419{

5420 if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))

5421 {

5422 return static_cast<ClassDef*>(d);

5423 }

5424 else

5425 {

5426 return nullptr;

5427 }

5428}

Referenced by DocSets::addIndexItem, ClassDefImpl::addInnerCompound, NamespaceDefImpl::addInnerCompound, MemberDefImpl::addListReference, definitionToName, findMemberLink, findModuleDef, findUsingDeclImports, SymbolResolver::Private::followPath, generateClassMemberLink, generateClassOrGlobalLink, generateClassOrGlobalLink, FTVHelp::Private::generateTree, ClassDefAliasImpl::getCdAlias, getDefsNew, SymbolResolver::Private::getResolvedSymbol, SymbolResolver::Private::getResolvedType, SymbolResolver::Private::getResolvedTypeRec, ClassDefImpl::getTemplateParameterLists, SymbolResolver::Private::isAccessibleFrom, SymbolResolver::Private::isAccessibleFromWithExpScope, makeQualifiedNameWithTemplateParameters, MemberDefImpl::moveTo, DefinitionImpl::navigationPathAsString, scopeIsTemplate, searchTemplateSpecs, SearchIndex::setCurrentDoc, ClassDefMutable::sortAllMembersList, updateCallContextForSmartPointer, writeDefArgumentList, writeJavasScriptSearchDataPage, MemberDefImpl::writeMemberDocSimple, writeObjCMethodCall, MemberList::writeSimpleDocumentation and VhdlDocGen::writeVHDLTypeDocumentation.

toClassDef()

ClassDef * toClassDef (DefinitionMutable * md)

Definition at line 5430 of file classdef.cpp.

5430ClassDef *toClassDef(DefinitionMutable *md)

5431{

5432 Definition *d = toDefinition(md);

5433 if (d && typeid(*d)==typeid(ClassDefImpl))

5434 {

5435 return static_cast<ClassDef*>(d);

5436 }

5437 else

5438 {

5439 return nullptr;

5440 }

5441}

Reference toDefinition.

toClassDef()

const ClassDef * toClassDef (const Definition * d)

Definition at line 5443 of file classdef.cpp.

5443const ClassDef *toClassDef(const Definition *d)

5444{

5445 if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))

5446 {

5447 return static_cast<const ClassDef*>(d);

5448 }

5449 else

5450 {

5451 return nullptr;

5452 }

5453}

toClassDefMutable()

ClassDefMutable * toClassDefMutable (Definition * d)

Definition at line 5455 of file classdef.cpp.

5455ClassDefMutable *toClassDefMutable(Definition *d)

5456{

5457 if (d && typeid(*d)==typeid(ClassDefImpl))

5458 {

5459 return static_cast<ClassDefMutable*>(d);

5460 }

5461 else

5462 {

5463 return nullptr;

5464 }

5465}

Referenced by addClassAndNestedClasses, addClassToContext, addClassToGroups, ModuleDefImpl::addClassToModule, ModuleManager::addClassToModule, addListReferences, addMembersToMemberGroup, ClassDefImpl::addMembersToTemplateInstance, addMemberToGroups, ClassDefImpl::addTypeConstraint, buildCompleteMemberLists, computeMemberReferences, computeTemplateClassRelations, VhdlDocGen::computeVhdlComponentRelations, ClassDefImpl::countInheritedDecMembers, countMembers, createTagLessInstance, createTemplateInstanceMembers, ClassDefImpl::deepCopy, distributeClassGroupRelations, distributeMemberGroupDocumentation, findClassRelation, findSectionsInDocumentation, findTagLessClasses, findTemplateInstanceRelation, findUsedClassesForClass, findUsingDeclarations, findUsingDeclImports, generateClassDocs, generateClassOrGlobalLink, generateNamespaceClassDocs, MemberDefImpl::getClassDefMutable, getClassMutable, ClassDefImpl::hideDerivedVariablesInPython, insertMemberAlias, ClassDefImpl::insertTemplateInstance, ClassDefImpl::insertUsedFile, ClassDefImpl::internalInsertMember, mergeCategories, ClassDefImpl::mergeCategory, ClassDefImpl::mergeMembers, ClassDefImpl::mergeMembersFromBaseClasses, SymbolResolver::resolveClassMutable, resolveClassNestingRelations, setAnonymousEnumType, ClassDefImpl::setGroupDefForAllMembers, ClassDefMutable::sortAllMembersList, sortMemberLists, ClassDefImpl::writeInheritedMemberDeclarations and writeTagFile.

writeInheritanceSpecifier()

void writeInheritanceSpecifier (OutputList & ol, const BaseClassDef & bcd)

static

Definition at line 1406 of file classdef.cpp.

1406static void writeInheritanceSpecifier(OutputList &ol,const BaseClassDef &bcd)

1407{

1408 if (bcd.prot!=Protection::Public || bcd.virt!=Specifier::Normal)

1409 {

1410 ol.startTypewriter();

1411 ol.docify(" [");

1412 StringVector sl;

1413 if (bcd.prot==Protection::Protected) sl.emplace_back("protected");

1414 else if (bcd.prot==Protection::Private) sl.emplace_back("private");

1415 if (bcd.virt==Specifier::Virtual) sl.emplace_back("virtual");

1416 bool first=true;

1417 for (const auto &s : sl)

1418 {

1419 if (!first) ol.docify(", ");

1420 ol.docify(s.c_str());

1421 first=false;

1422 }

1423 ol.docify("]");

1424 ol.endTypewriter();

1425 }

1426}

References OutputList::docify, OutputList::endTypewriter, BaseClassDef::prot, OutputList::startTypewriter and BaseClassDef::virt.

Referenced by ClassDefImpl::writeInheritanceGraph.

Generated via doxygen2docusaurus by Doxygen 1.14.0.

Included Headers​

Classes Index​

Functions Index​

Functions​

classHasVisibleChildren()​

classHasVisibleRoot()​

classInheritedProtectionLevel()​

classVisibleInIndex()​

createClassDef()​

createClassDefAlias()​

getClass()​

getCompoundTypeString()​

hasNonReferenceSuperClassRec()​

isStandardFunc()​

makeDisplayName()​

makeQualifiedNameWithTemplateParameters()​

minClassDistance()​

searchTemplateSpecs()​

toClassDef()​

toClassDef()​

toClassDef()​

toClassDefMutable()​

writeInheritanceSpecifier()​

Included Headers

Classes Index

Functions Index

Functions

classHasVisibleChildren()

classHasVisibleRoot()

classInheritedProtectionLevel()

classVisibleInIndex()

createClassDef()

createClassDefAlias()

getClass()

getCompoundTypeString()

hasNonReferenceSuperClassRec()

isStandardFunc()

makeDisplayName()

makeQualifiedNameWithTemplateParameters()

minClassDistance()

searchTemplateSpecs()

toClassDef()

toClassDef()

toClassDef()

toClassDefMutable()

writeInheritanceSpecifier()