classdef.cpp File Reference

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

Include dependency graph for classdef.cpp:

Go to the source code of this file.

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

Functions
static DString	makeQualifiedNameWithTemplateParameters (const ClassDef *cd, const ArgumentLists *actualParams, uint32_t *actualParamIndex)
static DString	makeDisplayName (const ClassDef *cd, bool includeScope)
static DString	getCompoundTypeString (SrcLangExt lang, ClassDef::CompoundType compType, bool isJavaEnum)
std::unique_ptr< ClassDef >	createClassDef (const DString &fileName, int startLine, size_t startColumn, const DString &name, ClassDef::CompoundType ct, const DString &ref, const DString &fName, bool isSymbol, bool isJavaEnum)
	Factory method to create a new ClassDef object.
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, DString &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 DString &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)

Function Documentation

classHasVisibleChildren()

bool classHasVisibleChildren

(

const ClassDef *

cd

)

Definition at line 5611 of file classdef.cpp.

{
  BaseClassList bcl;
 
  if (cd->getLanguage()==SrcLangExt::VHDL) // reverse baseClass/subClass relation
  {
    if (cd->baseClasses().empty()) return false;
    bcl=cd->baseClasses();
  }
  else
  {
    if (cd->subClasses().empty()) return false;
    bcl=cd->subClasses();
  }
 
  for (const auto &bcd : bcl)
  {
    if (bcd.classDef->isVisibleInHierarchy())
    {
      return true;
    }
  }
  return false;
}

References ClassDef::baseClasses(), Definition::getLanguage(), and ClassDef::subClasses().

Referenced by writeClassTreeForList(), and writeClassTreeToOutput().

classHasVisibleRoot()

bool classHasVisibleRoot

(

const BaseClassList &

bcl

)

Definition at line 5600 of file classdef.cpp.

{
  for (const auto &bcd : bcl)
  {
    const ClassDef *cd=bcd.classDef;
    if (cd->isVisibleInHierarchy()) return true;
    if (classHasVisibleRoot(cd->baseClasses())) return true;
  }
  return false;
}

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 5670 of file classdef.cpp.

{
  if (bcd->categoryOf()) // use class that is being extended in case of
    // an Objective-C category
  {
    bcd=bcd->categoryOf();
  }
  if (cd==bcd)
  {
    goto exit;
  }
  if (level==256)
  {
    err("Internal inconsistency: found class {} seem to have a recursive "
        "inheritance relation! Please send a bug report to doxygen@gmail.com\n",cd->name());
  }
  else if (prot!=Protection::Private)
  {
    for (const auto &bcdi : cd->baseClasses())
    {
      Protection baseProt = classInheritedProtectionLevel(bcdi.classDef,bcd,bcdi.prot,level+1);
      if (baseProt==Protection::Private)        prot=Protection::Private;
      else if (baseProt==Protection::Protected) prot=Protection::Protected;
    }
  }
exit:
  //printf("classInheritedProtectionLevel(%s,%s)=%d\n",qPrint(cd->name()),qPrint(bcd->name()),prot);
  return prot;
}

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

Referenced by classInheritedProtectionLevel().

classVisibleInIndex()

bool classVisibleInIndex

(

const ClassDef *

cd

)

Definition at line 5636 of file classdef.cpp.

{
  bool allExternals = Config_getBool(ALLEXTERNALS);
  return (allExternals && cd->isLinkable()) || cd->isLinkableInProject();
}

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

Referenced by writeClassTree().

createClassDef()

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

Factory method to create a new ClassDef object.

Definition at line 583 of file classdef.cpp.

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

Referenced by addClassToContext(), createTagLessInstance(), findClassRelation(), findUsedClassesForClass(), findUsingDeclarations(), and ClassDefMutable::setPrimaryConstructorParams().

createClassDefAlias()

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

Definition at line 816 of file classdef.cpp.

{
  auto acd = std::make_unique<ClassDefAliasImpl>(newScope,cd);
  //printf("cd name=%s localName=%s qualifiedName=%s qualifiedNameWith=%s displayName()=%s\n",
  //    qPrint(acd->name()),qPrint(acd->localName()),qPrint(acd->qualifiedName()),
  //    qPrint(acd->qualifiedNameWithTemplateParameters()),qPrint(acd->displayName()));
  return acd;
}

Referenced by ClassDefAliasImpl::deepCopy(), findUsingDeclImports(), resolveClassNestingRelations(), and ClassDefMutable::setPrimaryConstructorParams().

getClass()

ClassDef * getClass

(

const DString &

n

)

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

Definition at line 5594 of file classdef.cpp.

{
  if (n.empty()) return nullptr;
  return Doxygen::classLinkedMap->find(n);
}

References Doxygen::classLinkedMap, DString::empty(), and LinkedMap< T, Hash, KeyEqual, Map >::find().

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

getCompoundTypeString()

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

static

Definition at line 162 of file classdef.cpp.

{
  if (lang==SrcLangExt::Fortran)
  {
    switch (compType)
    {
      case ClassDef::Class:     return "module";
      case ClassDef::Struct:    return "type";
      case ClassDef::Union:     return "union";
      case ClassDef::Interface: return "interface";
      case ClassDef::Protocol:  return "protocol";
      case ClassDef::Category:  return "category";
      case ClassDef::Exception: return "exception";
      default:                  return "unknown";
    }
  }
  else
  {
    switch (compType)
    {
      case ClassDef::Class:     return isJavaEnum ? "enum" : "class";
      case ClassDef::Struct:    return "struct";
      case ClassDef::Union:     return "union";
      case ClassDef::Interface: return lang==SrcLangExt::ObjC ? "class" : "interface";
      case ClassDef::Protocol:  return "protocol";
      case ClassDef::Category:  return "category";
      case ClassDef::Exception: return "exception";
      case ClassDef::Service:   return "service";
      case ClassDef::Singleton: return "singleton";
      default:                  return "unknown";
    }
  }
}

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 3554 of file classdef.cpp.

{
  bool found=!cd->isReference() && cd->isLinkableInProject() && !cd->isHidden();
  if (found)
  {
    return true; // we're done if this class is not a reference
  }
  for (const auto &ibcd : cd->subClasses())
  {
    const ClassDef *bcd=ibcd.classDef;
    if (level>256)
    {
      err("Possible recursive class relation while inside {} and looking for base class {}\n",cd->name(),bcd->name());
      return false;
    }
    // recurse into the super class branch
    found = found || hasNonReferenceSuperClassRec(bcd,level+1);
    if (!found)
    {
      // look for template instances that might have non-reference super classes
      for (const auto &cil : bcd->getTemplateInstances())
      {
        // recurse into the template instance branch
        found = hasNonReferenceSuperClassRec(cil.classDef,level+1);
        if (found) break;
      }
    }
    else
    {
      break;
    }
  }
  return found;
}

References err, ClassDef::getTemplateInstances(), hasNonReferenceSuperClassRec(), Definition::isHidden(), Definition::isLinkableInProject(), Definition::isReference(), Definition::name(), and ClassDef::subClasses().

Referenced by ClassDefImpl::hasNonReferenceSuperClass(), and hasNonReferenceSuperClassRec().

isStandardFunc()

bool isStandardFunc ( const MemberDef * md )

static

Definition at line 3791 of file classdef.cpp.

{
  return md->name()=="operator=" || // assignment operator
         md->isConstructor() ||     // constructor
         md->isDestructor();        // destructor
}

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

Referenced by ClassDefImpl::mergeMembersFromBaseClasses().

makeDisplayName()

DString makeDisplayName ( const ClassDef * cd, bool includeScope )

static

Definition at line 111 of file classdef.cpp.

{
  //bool optimizeOutputForJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
  SrcLangExt lang = cd->getLanguage();
  //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  DString n;
  if (lang==SrcLangExt::VHDL)
  {
    n = VhdlDocGen::getClassName(cd);
  }
  else
  {
    if (cd->taglessParent())
    {
      size_t idx=cd->name().rfind("::");
      if (includeScope || idx==DString::npos)
      {
        n=cd->name();
      }
      else
      {
        n=cd->name().mid(idx+2);
      }
    }
    else if (includeScope)
    {
      n=cd->qualifiedNameWithTemplateParameters();
    }
    else
    {
      n=cd->className();
    }
  }
  if (cd->isAnonymous())
  {
    n = removeAnonymousScopes(n);
  }
  DString sep=getLanguageSpecificSeparator(lang);
  if (sep!="::")
  {
    n=substitute(n,"::",sep);
  }
  if (cd->compoundType()==ClassDef::Protocol && n.endsWith("-p"))
  {
    n="<"+n.left(n.length()-2)+">";
  }
  return n;
}

References ClassDef::className(), ClassDef::compoundType(), DString::endsWith(), VhdlDocGen::getClassName(), Definition::getLanguage(), getLanguageSpecificSeparator(), Definition::isAnonymous(), DString::left(), DString::length(), DString::mid(), Definition::name(), DString::npos, ClassDef::Protocol, ClassDef::qualifiedNameWithTemplateParameters(), removeAnonymousScopes(), DString::rfind(), substitute(), and ClassDef::taglessParent().

Referenced by ClassDefAliasImpl::displayName(), and ClassDefImpl::displayName().

makeQualifiedNameWithTemplateParameters()

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

static

Definition at line 60 of file classdef.cpp.

{
  //bool optimizeOutputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
  bool hideScopeNames = Config_getBool(HIDE_SCOPE_NAMES);
  //printf("qualifiedNameWithTemplateParameters() localName=%s\n",qPrint(cd->localName()));
  DString scName;
  const Definition *d=cd->getOuterScope();
  if (d)
  {
    if (d->definitionType()==Definition::TypeClass)
    {
      const ClassDef *ocd=toClassDef(d);
      scName = ocd->qualifiedNameWithTemplateParameters(actualParams,actualParamIndex);
    }
    else if (!hideScopeNames)
    {
      scName = d->qualifiedName();
    }
  }
 
  SrcLangExt lang = cd->getLanguage();
  DString scopeSeparator = getLanguageSpecificSeparator(lang);
  if (!scName.empty()) scName+=scopeSeparator;
 
  bool isSpecialization = cd->localName().find('<')!=DString::npos;
  DString clName = cd->className();
  scName+=clName;
  if (lang!=SrcLangExt::CSharp && !cd->templateArguments().empty())
  {
    if (actualParams && *actualParamIndex<actualParams->size())
    {
      const ArgumentList &al = actualParams->at(*actualParamIndex);
      if (!isSpecialization)
      {
        scName+=tempArgListToString(al,lang);
      }
      (*actualParamIndex)++;
    }
    else
    {
      if (!isSpecialization)
      {
        scName+=tempArgListToString(cd->templateArguments(),lang);
      }
    }
  }
  //printf("qualifiedNameWithTemplateParameters: scope=%s qualifiedName=%s\n",qPrint(name()),qPrint(scName));
  return scName;
}

References ClassDef::className(), Config_getBool, Definition::definitionType(), ArgumentList::empty(), DString::empty(), DString::find(), Definition::getLanguage(), getLanguageSpecificSeparator(), Definition::getOuterScope(), Definition::localName(), DString::npos, 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 5646 of file classdef.cpp.

{
  const int maxInheritanceDepth = 100000;
  if (bcd->categoryOf()) // use class that is being extended in case of
    // an Objective-C category
  {
    bcd=bcd->categoryOf();
  }
  if (cd==bcd) return level;
  if (level==256)
  {
    warn_uncond("class {} seem to have a recursive inheritance relation!\n",cd->name());
    return -1;
  }
  int m=maxInheritanceDepth;
  for (const auto &bcdi : cd->baseClasses())
  {
    int mc=minClassDistance(bcdi.classDef,bcd,level+1);
    if (mc<m) m=mc;
    if (m<0) break;
  }
  return m;
}

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

Referenced by ClassDefImpl::getMemberByName(), and minClassDistance().

searchTemplateSpecs()

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

static

Definition at line 1516 of file classdef.cpp.

{
  if (d->definitionType()==Definition::TypeClass)
  {
    if (d->getOuterScope())
    {
      searchTemplateSpecs(d->getOuterScope(),result,name,lang);
    }
    const ClassDef *cd=toClassDef(d);
    if (!name.empty()) name+="::";
    DString clName = d->localName();
    if (clName.endsWith("-p"))
    {
      clName = clName.left(clName.length()-2);
    }
    name+=clName;
    bool isSpecialization = d->localName().find('<')!=DString::npos;
    if (!cd->templateArguments().empty())
    {
      result.push_back(cd->templateArguments());
      if (!isSpecialization)
      {
        name+=tempArgListToString(cd->templateArguments(),lang);
      }
    }
  }
  else
  {
    name+=d->qualifiedName();
  }
}

References Definition::definitionType(), ArgumentList::empty(), DString::endsWith(), DString::find(), Definition::getOuterScope(), DString::left(), DString::length(), Definition::localName(), DString::npos, Definition::qualifiedName(), searchTemplateSpecs(), tempArgListToString(), ClassDef::templateArguments(), toClassDef(), and Definition::TypeClass.

Referenced by searchTemplateSpecs(), and ClassDefImpl::writeTemplateSpec().

toClassDef() [1/3]

const ClassDef * toClassDef

(

const Definition *

d

)

Definition at line 5565 of file classdef.cpp.

{
  if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))
  {
    return static_cast<const ClassDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

toClassDef() [2/3]

ClassDef * toClassDef

(

Definition *

d

)

Definition at line 5540 of file classdef.cpp.

{
  if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))
  {
    return static_cast<ClassDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

Referenced by DocSets::addIndexItem(), ClassDefImpl::addInnerCompound(), NamespaceDefImpl::addInnerCompound(), MemberDefImpl::addListReference(), definitionToName(), findMemberLink(), findModuleDef(), findTagLessClasses(), findUsingDeclImports(), SymbolResolver::Private::followPath(), generateClassMemberLink(), generateClassOrGlobalLink(), generateClassOrGlobalLink(), FTVHelp::Private::generateTree(), ClassDefAliasImpl::getCdAlias(), getDefs(), 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::setPrimaryConstructorParams(), updateCallContextForSmartPointer(), writeDefArgumentList(), writeJavasScriptSearchDataPage(), MemberDefImpl::writeMemberDocSimple(), writeObjCMethodCall(), MemberList::writeSimpleDocumentation(), and VhdlDocGen::writeVHDLTypeDocumentation().

toClassDef() [3/3]

ClassDef * toClassDef

(

DefinitionMutable *

md

)

Definition at line 5552 of file classdef.cpp.

{
  Definition *d = toDefinition(md);
  if (d && typeid(*d)==typeid(ClassDefImpl))
  {
    return static_cast<ClassDef*>(d);
  }
  else
  {
    return nullptr;
  }
}

References toDefinition().

toClassDefMutable()

ClassDefMutable * toClassDefMutable

(

Definition *

d

)

Definition at line 5577 of file classdef.cpp.

{
  if (d && typeid(*d)==typeid(ClassDefImpl))
  {
    return static_cast<ClassDefMutable*>(d);
  }
  else
  {
    return nullptr;
  }
}

Referenced by addClassAndNestedClasses(), addClassToContext(), addClassToGroups(), ModuleDefImpl::addClassToModule(), ModuleManager::addClassToModule(), addMembersToMemberGroup(), ClassDefImpl::addMembersToTemplateInstance(), addMemberToGroups(), ClassDefImpl::addTypeConstraint(), applyToAllDefinitions(), buildCompleteMemberLists(), computeMemberReferences(), computeTemplateClassRelations(), VhdlDocGen::computeVhdlComponentRelations(), ClassDefImpl::countInheritedDecMembers(), countMembers(), createTagLessInstance(), createTemplateInstanceMembers(), ClassDefImpl::deepCopy(), distributeClassGroupRelations(), distributeMemberGroupDocumentation(), findClassRelation(), findSectionsInDocumentation(), 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::setPrimaryConstructorParams(), sortMemberLists(), ClassDefImpl::writeInheritedMemberDeclarations(), and writeTagFile().

writeInheritanceSpecifier()

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

static

Definition at line 1455 of file classdef.cpp.

{
  if (bcd.prot!=Protection::Public || bcd.virt!=Specifier::Normal)
  {
    ol.startTypewriter();
    ol.docify(" [");
    StringVector sl;
    if      (bcd.prot==Protection::Protected) sl.emplace_back("protected");
    else if (bcd.prot==Protection::Private)   sl.emplace_back("private");
    if      (bcd.virt==Specifier::Virtual)    sl.emplace_back("virtual");
    bool first=true;
    for (const auto &s : sl)
    {
      if (!first) ol.docify(", ");
      ol.docify(s);
      first=false;
    }
    ol.docify("]");
    ol.endTypewriter();
  }
}

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

Referenced by ClassDefImpl::writeInheritanceGraph().