A list of MemberDef objects as shown in documentation sections. More...

#include <src/memberlist.h>

Inheritance diagram for MemberList:

Collaboration diagram for MemberList:

Public Member Functions
	MemberList (MemberListType lt, MemberListContainer container)

	~MemberList ()

MemberListType	listType () const

MemberListContainer	container () const

int	numDecMembers () const

int	numDecEnumValues () const

int	numDocMembers () const

int	numDocEnumValues () const

bool	needsSorting () const

void	countDecMembers ()

void	countDocMembers ()

int	countInheritableMembers (const ClassDef *inheritedFrom) const

void	writePlainDeclarations (OutputList &ol, bool inGroup, const ClassDef cd, const NamespaceDef nd, const FileDef fd, const GroupDef gd, const ModuleDef mod, int indentLevel, const ClassDef inheritedFrom, const QCString &inheritId) const

void	writeDeclarations (OutputList &ol, const ClassDef cd, const NamespaceDef nd, const FileDef fd, const GroupDef gd, const ModuleDef mod, const QCString &title, const QCString &subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, const ClassDef inheritedFrom=nullptr, MemberListType lt=MemberListType::PubMethods(), bool showSectionTitle=true) const
	Writes the list of members to the output.

void	writeDocumentation (OutputList &ol, const QCString &scopeName, const Definition *container, const QCString &title, bool showEnumValues=FALSE, bool showInline=FALSE) const

void	writeSimpleDocumentation (OutputList &ol, const Definition *container) const

void	writeDocumentationPage (OutputList &ol, const QCString &scopeName, const DefinitionMutable *container, int hierarchyLevel=0) const

void	writeTagFile (TextStream &, bool useQualifiedName=false, bool showNamespaceMembers=true)

bool	declVisible () const

void	addMemberGroup (MemberGroup *mg)

void	addListReferences (Definition *def)

void	findSectionsInDocumentation (const Definition *d)

void	setNeedsSorting (bool b)

const MemberGroupRefList &	getMemberGroupList () const

void	setAnonymousEnumType ()

void	setAnchors ()

Public Member Functions inherited from MemberVector
void	push_back (const T &value)

void	push_back (T &&value)

iterator	erase (iterator pos)

iterator	erase (const_iterator pos)

iterator	begin () noexcept

const_iterator	begin () const noexcept

iterator	end () noexcept

const_iterator	end () const noexcept

size_type	size () const noexcept

bool	empty () const noexcept

reference	front ()

const_reference	front () const

reference	back ()

const_reference	back () const

reference	operator[] (size_type pos)

const_reference	operator[] (size_type pos) const

void	sort ()

void	inSort (MemberDef *md)

void	remove (const MemberDef *md)

bool	contains (const MemberDef *md) const

MemberDef *	find (const QCString &name)

Private Member Functions
int	countEnumValues (const MemberDef *md) const

Private Attributes
int	m_numDecMembers

int	m_numDecEnumValues

int	m_numDocMembers

int	m_numDocEnumValues

MemberGroupRefList	m_memberGroupRefList

MemberListContainer	m_container

MemberListType	m_listType

bool	m_needsSorting

Additional Inherited Members
Public Types inherited from MemberVector
using	T = MemberDef*

using	Vec = std::vector<T>

using	value_type = Vec::value_type

using	allocator_type = Vec::allocator_type

using	size_type = Vec::size_type

using	difference_type = Vec::difference_type

using	reference = Vec::reference

using	const_reference = Vec::const_reference

using	iterator = Vec::iterator

using	const_iterator = Vec::const_iterator

Static Public Member Functions inherited from MemberVector
static bool	lessThan (const MemberDef md1, const MemberDef md2)

Protected Attributes inherited from MemberVector
Vec	m_members

Detailed Description

A list of MemberDef objects as shown in documentation sections.

Definition at line 107 of file memberlist.h.

Constructor & Destructor Documentation

◆ MemberList()

MemberList::MemberList	(	MemberListType	lt,
		MemberListContainer	container )

Definition at line 34 of file memberlist.cpp.

                                                                : m_container(con), m_listType(lt)
{
  //printf("%p: MemberList::MemberList(%d)\n",this,lt);
  m_numDecMembers=-1; // special value indicating that value needs to be computed
  m_numDecEnumValues=0;
  m_numDocMembers=-1; // special value indicating that value needs to be computed
  m_numDocEnumValues=0;
  m_needsSorting=FALSE;
}

References FALSE, m_container, m_listType, m_needsSorting, m_numDecEnumValues, m_numDecMembers, m_numDocEnumValues, and m_numDocMembers.

◆ ~MemberList()

MemberList::~MemberList ( )

Definition at line 44 of file memberlist.cpp.

45{

46}

Member Function Documentation

◆ addListReferences()

void MemberList::addListReferences ( Definition * def )

Definition at line 808 of file memberlist.cpp.

{
  for (const auto &imd : m_members)
  {
    MemberDefMutable *md = toMemberDefMutable(imd);
    if (md && !md->isAlias() && (md->getGroupDef()==nullptr || def->definitionType()==Definition::TypeGroup))
    {
      md->addListReference(def);
      const MemberVector &enumFields = md->enumFieldList();
      if (md->memberType()==MemberType::Enumeration && !enumFields.empty())
      {
        //printf("  Adding enum values!\n");
        for (const auto &vmd : enumFields)
        {
          MemberDefMutable *vmdm = toMemberDefMutable(vmd);
          if (vmdm)
          {
            //printf("   adding %s\n",qPrint(vmd->name()));
            vmdm->addListReference(def);
          }
        }
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->addListReferences(def);
  }
}

References MemberDefMutable::addListReference(), Definition::definitionType(), MemberVector::empty(), Enumeration, MemberDef::enumFieldList(), MemberDef::getGroupDef(), Definition::isAlias(), m_memberGroupRefList, MemberVector::m_members, MemberDef::memberType(), toMemberDefMutable(), and Definition::TypeGroup.

◆ addMemberGroup()

void MemberList::addMemberGroup ( MemberGroup * mg )

Definition at line 803 of file memberlist.cpp.

{
  m_memberGroupRefList.push_back(mg);
}

References m_memberGroupRefList.

◆ container()

MemberListContainer MemberList::container ( ) const

inline

Definition at line 114 of file memberlist.h.

114{ return m_container; }

References m_container.

Referenced by addMembersToMemberGroup(), writeDocumentation(), writeDocumentationPage(), and writeSimpleDocumentation().

◆ countDecMembers()

void MemberList::countDecMembers ( )

Count the number of members in this list that are visible in the declaration part of a compound's documentation page.

Definition at line 122 of file memberlist.cpp.

{
  if (m_numDecMembers!=-1) return;
 
  //printf("----- countDecMembers count=%d ----\n",count());
  /*
  m_varCnt=m_funcCnt=m_enumCnt=m_enumValCnt=0;
  m_typeCnt=m_seqCnt=m_dictCnt=m_protoCnt=m_defCnt=m_friendCnt=0;
  */
  m_numDecMembers=0;
  for (const auto &md : m_members)
  {
    //printf("MemberList::countDecMembers(md=%s,%d)\n",qPrint(md->name()),md->isBriefSectionVisible());
    if (md->isBriefSectionVisible())
    {
      switch(md->memberType())
      {
        case MemberType::Variable:    // fall through
        case MemberType::Event:       // fall through
        case MemberType::Property:    /*m_varCnt++,*/
                                     m_numDecMembers++;
                                     break;
// apparently necessary to get this to show up in declarations section?
        case MemberType::Interface:   // fall through
        case MemberType::Service:     // fall through
        case MemberType::Function:    // fall through
        case MemberType::Signal:      // fall through
        case MemberType::DCOP:        // fall through
        case MemberType::Slot:        if (!md->isRelated() || md->getClassDef())
                                       /*m_funcCnt++,*/
                                       m_numDecMembers++;
                                     break;
        case MemberType::Enumeration: /*m_enumCnt++,*/
                                     m_numDecMembers++;
                                     break;
        case MemberType::EnumValue:   m_numDecEnumValues++;
                                     m_numDecMembers++;
                                     break;
        case MemberType::Typedef:     /*m_typeCnt++,*/
                                     m_numDecMembers++;
                                     break;
        case MemberType::Sequence:    /*m_seqCnt++,*/
                                     m_numDecMembers++;
                                     break;
        case MemberType::Dictionary:  /*m_dictCnt++,*/
                                     m_numDecMembers++;
                                     break;
        //case MemberType::Prototype:   m_protoCnt++,m_numDecMembers++; break;
        case MemberType::Define:      if (Config_getBool(EXTRACT_ALL) ||
                                         !md->argsString().isEmpty() ||
                                         !md->initializer().isEmpty() ||
                                         md->hasDocumentation()
                                        ) /*m_defCnt++,*/ m_numDecMembers++;
                                     break;
        case MemberType::Friend:      /*m_friendCnt++,*/
                                     m_numDecMembers++;
                                     break;
        default:
          err("Unknown member type found for member '%s'!\n",qPrint(md->name()));
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->countDecMembers();
    /*
    m_varCnt+=mg->varCount();
    m_funcCnt+=mg->funcCount();
    m_enumCnt+=mg->enumCount();
    m_enumValCnt+=mg->enumValueCount();
    m_typeCnt+=mg->typedefCount();
    m_seqCnt+=mg->sequenceCount();
    m_dictCnt+=mg->dictionaryCount();
    m_protoCnt+=mg->protoCount();
    m_defCnt+=mg->defineCount();
    m_friendCnt+=mg->friendCount();
    */
    m_numDecMembers+=mg->numDecMembers();
    m_numDecEnumValues+=mg->numDecEnumValues();
  }
  //printf("----- end countDecMembers ----\n");
 
  //printf("MemberList::countDecMembers()=%d\n",m_numDecMembers);
}

References Config_getBool, DCOP, Define, Dictionary, Enumeration, EnumValue, err, Event, Friend, Function, Interface, m_memberGroupRefList, MemberVector::m_members, m_numDecEnumValues, m_numDecMembers, Property, qPrint(), Sequence, Service, Signal, Slot, Typedef, and Variable.

Referenced by MemberGroup::addGroupedInheritedMembers().

◆ countDocMembers()

void MemberList::countDocMembers ( )

Definition at line 207 of file memberlist.cpp.

{
  if (m_numDocMembers!=-1) return; // used cached value
  m_numDocMembers=0;
  for (const auto &md : m_members)
  {
    if (md->isDetailedSectionVisible(m_container) && !md->isAlias())
    {
      // do not count enum values, since they do not produce entries of their own
      if (md->memberType()==MemberType::EnumValue)
      {
        m_numDocEnumValues++;
      }
      m_numDocMembers++;
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->countDocMembers();
    m_numDocMembers+=mg->numDocMembers();
    m_numDocEnumValues+=mg->numDocEnumValues();
  }
  //printf("MemberList::countDocMembers()=%d memberGroupList=%p\n",m_numDocMembers,memberGroupList);
}

References EnumValue, m_container, m_memberGroupRefList, MemberVector::m_members, m_numDocEnumValues, and m_numDocMembers.

◆ countEnumValues()

int MemberList::countEnumValues ( const MemberDef * md ) const

private

Definition at line 265 of file memberlist.cpp.

{
  int numEnumValues=0;
  QCString name(md->name());
  int i=name.findRev("::");
  if (i!=-1) name=name.right(name.length()-i-2);
  if (name[0]=='@')
  {
    for (const auto &vmd : m_members)
    {
      QCString vtype=vmd->typeString();
      if ((vtype.find(name))!=-1)
      {
        numEnumValues++;
      }
    }
  }
  return numEnumValues;
}

References QCString::find(), QCString::findRev(), QCString::length(), MemberVector::m_members, Definition::name(), and QCString::right().

Referenced by declVisible(), and writePlainDeclarations().

◆ countInheritableMembers()

int MemberList::countInheritableMembers ( const ClassDef * inheritedFrom ) const

Definition at line 85 of file memberlist.cpp.

{
  int count=0;
  for (const auto &md : m_members)
  {
    if (md->isBriefSectionVisible())
    {
      if (md->memberType()!=MemberType::Friend &&
          md->memberType()!=MemberType::EnumValue)
      {
        //printf("member %s: isReimplementedBy(%s)=%d\n",qPrint(md->name()),
        //    qPrint(inheritedFrom->name()),
        //    md->isReimplementedBy(inheritedFrom));
        if (md->memberType()==MemberType::Function)
        {
          if (!md->isReimplementedBy(inheritedFrom)) count++;
        }
        else
        {
          count++;
        }
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    count+=mg->countInheritableMembers(inheritedFrom);
  }
  //printf("%s::countInheritableMembers(%s)=%d\n",
  //    qPrint(m_listType.toLabel()),
  //    qPrint(inheritedFrom->name()),count);
  return count;
}

References EnumValue, Friend, Function, m_memberGroupRefList, and MemberVector::m_members.

Referenced by ClassDefImpl::countMembersIncludingGrouped().

◆ declVisible()

bool MemberList::declVisible ( ) const

Definition at line 285 of file memberlist.cpp.

{
  for (const auto &md : m_members)
  {
    if (md->isBriefSectionVisible())
    {
      switch (md->memberType())
      {
        case MemberType::Define:     // fall through
        case MemberType::Typedef:    // fall through
        case MemberType::Variable:   // fall through
        case MemberType::Function:   // fall through
        case MemberType::Signal:     // fall through
        case MemberType::Slot:       // fall through
        case MemberType::DCOP:       // fall through
        case MemberType::Property:   // fall through
        case MemberType::Interface:  // fall through
        case MemberType::Service:    // fall through
        case MemberType::Sequence:   // fall through
        case MemberType::Dictionary: // fall through
        case MemberType::Event:
          return TRUE;
        case MemberType::Enumeration:
          {
            // if this is an anonymous enum and there are variables of this
            // enum type (i.e. enumVars>0), then we do not show the enum here.
            if (countEnumValues(md)==0) // show enum here
            {
              return TRUE;
            }
          }
          break;
        case MemberType::Friend:
          return TRUE;
        case MemberType::EnumValue:
          {
            if (m_container==MemberListContainer::Group)
            {
              return TRUE;
            }
          }
          break;
      }
    }
  }
  return FALSE;
}

References countEnumValues(), DCOP, Define, Dictionary, Enumeration, EnumValue, Event, FALSE, Friend, Function, Group, Interface, m_container, MemberVector::m_members, Property, Sequence, Service, Signal, Slot, TRUE, Typedef, and Variable.

Referenced by ClassDefImpl::writeSummaryLinks(), FileDefImpl::writeSummaryLinks(), GroupDefImpl::writeSummaryLinks(), ModuleDefImpl::writeSummaryLinks(), and NamespaceDefImpl::writeSummaryLinks().

◆ findSectionsInDocumentation()

void MemberList::findSectionsInDocumentation ( const Definition * d )

Definition at line 838 of file memberlist.cpp.

{
  for (const auto &imd : m_members)
  {
    MemberDefMutable *md = toMemberDefMutable(imd);
    if (md)
    {
      md->findSectionsInDocumentation();
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->findSectionsInDocumentation(d);
  }
}

References MemberDefMutable::findSectionsInDocumentation(), m_memberGroupRefList, MemberVector::m_members, and toMemberDefMutable().

◆ getMemberGroupList()

const MemberGroupRefList & MemberList::getMemberGroupList ( ) const

inline

Definition at line 144 of file memberlist.h.

144{ return m_memberGroupRefList; }

References m_memberGroupRefList.

Referenced by membersHaveSpecificType(), and VhdlDocGen::writeVHDLDeclarations().

◆ listType()

MemberListType MemberList::listType ( ) const

inline

◆ needsSorting()

bool MemberList::needsSorting ( ) const

inline

Definition at line 120 of file memberlist.h.

120{ return m_needsSorting; }

References m_needsSorting.

Referenced by FileDefImpl::sortMemberLists().

◆ numDecEnumValues()

int MemberList::numDecEnumValues ( ) const

inline

Definition at line 117 of file memberlist.h.

117{ return m_numDecEnumValues; }

References m_numDecEnumValues.

Referenced by writeDeclarations(), and writePlainDeclarations().

◆ numDecMembers()

int MemberList::numDecMembers ( ) const

inline

Definition at line 116 of file memberlist.h.

116{ ASSERT(m_numDecMembers!=-1); return m_numDecMembers; }

ASSERT

#define ASSERT(x)

Definition qcstring.h:39

References ASSERT, and m_numDecMembers.

Referenced by ClassDefImpl::countMemberDeclarations(), FileDefImpl::numDecMembers(), writeDeclarations(), and writePlainDeclarations().

◆ numDocEnumValues()

int MemberList::numDocEnumValues ( ) const

inline

Definition at line 119 of file memberlist.h.

119{ return m_numDocEnumValues; }

References m_numDocEnumValues.

Referenced by writeDocumentation(), and writeSimpleDocumentation().

◆ numDocMembers()

int MemberList::numDocMembers ( ) const

inline

Definition at line 118 of file memberlist.h.

118{ ASSERT(m_numDocMembers!=-1); return m_numDocMembers; }

References ASSERT, and m_numDocMembers.

Referenced by FileDefImpl::numDocMembers(), NamespaceDefImpl::numDocMembers(), writeDocumentation(), and writeSimpleDocumentation().

◆ setAnchors()

void MemberList::setAnchors ( )

Definition at line 894 of file memberlist.cpp.

{
  //int count=0;
  for (const auto &md : m_members)
  {
    MemberDefMutable *mdm = toMemberDefMutable(md);
    if (mdm && !md->isReference())
    {
      mdm->setAnchor();
    }
  }
}

References Definition::isReference(), MemberVector::m_members, MemberDefMutable::setAnchor(), and toMemberDefMutable().

Referenced by FileDefImpl::computeAnchors(), and NamespaceDefImpl::computeAnchors().

◆ setAnonymousEnumType()

void MemberList::setAnonymousEnumType ( )

Definition at line 232 of file memberlist.cpp.

{
  //printf("MemberList(%p)::setAnonymousEnumType()\n",this);
  for (const auto &md : m_members)
  {
    if (md->isBriefSectionVisible())
    {
      QCString name(md->name());
      int i=name.findRev("::");
      if (i!=-1) name=name.right(name.length()-i-2);
      if (md->memberType()==MemberType::Enumeration && name[0]=='@')
      {
        for (const auto &vmd : md->enumFieldList())
        {
          MemberDefMutable *vmdm = toMemberDefMutable(vmd);
          if (vmdm)
          {
            QCString vtype=vmd->typeString();
            if ((vtype.find(name))!=-1)
            {
              vmdm->setAnonymousEnumType(md);
            }
          }
        }
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->setAnonymousEnumType();
  }
}

References Enumeration, QCString::find(), QCString::findRev(), QCString::length(), m_memberGroupRefList, MemberVector::m_members, QCString::right(), MemberDefMutable::setAnonymousEnumType(), and toMemberDefMutable().

Referenced by ClassDefImpl::setAnonymousEnumType().

◆ setNeedsSorting()

void MemberList::setNeedsSorting ( bool b )

Definition at line 854 of file memberlist.cpp.

{
  m_needsSorting = b;
}

References m_needsSorting.

Referenced by FileDefImpl::sortMemberLists().

◆ writeDeclarations()

void MemberList::writeDeclarations	(	OutputList &	ol,
		const ClassDef *	cd,
		const NamespaceDef *	nd,
		const FileDef *	fd,
		const GroupDef *	gd,
		const ModuleDef *	mod,
		const QCString &	title,
		const QCString &	subtitle,
		bool	showEnumValues = FALSE,
		bool	showInline = FALSE,
		const ClassDef *	inheritedFrom = nullptr,
		MemberListType	lt = MemberListType::PubMethods(),
		bool	showSectionTitle = true ) const

Writes the list of members to the output.

Parameters

ol	Output list to write to
cd	non-null if this list is part of class documentation.
nd	non-null if this list is part of namespace documentation.
fd	non-null if this list is part of file documentation.
gd	non-null if this list is part of group documentation.
mod	non-null if this list is part of module documentation.
title	Title to use for the member list.
subtitle	Sub title to use for the member list.
showEnumValues	Obsolete, always set to FALSE.
showInline	if set to TRUE if title is rendered differently
inheritedFrom	if not 0, the list is shown inside the given class as inherited members, parameter cd points to the class containing the members.
lt	Type of list that is inherited from.
showSectionTitle	do we show the "additional members" header or not? When combining public and protected inherited members under a single header only for the first list it should be shown

Definition at line 511 of file memberlist.cpp.

{
  (void)showEnumValues; // unused
 
  //printf("----- writeDeclaration() this=%p ---- inheritedFrom=%p\n",this,inheritedFrom);
  bool optimizeVhdl = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  QCString inheritId;
 
  const Definition  *ctx =  cd;
  if (ctx==nullptr &&  nd) ctx =  nd;
  if (ctx==nullptr &&  gd) ctx =  gd;
  if (ctx==nullptr && mod) ctx = mod;
  if (ctx==nullptr &&  fd) ctx =  fd;
 
  //printf("%p: MemberList::writeDeclaration(title='%s',subtitle='%s')=%d inheritedFrom=%p\n",
  //       (void*)this,qPrint(title),qPrint(subtitle),numDecMembers(),(void*)inheritedFrom);
 
  int num = numDecMembers();
  int numEnumValues = numDecEnumValues();
  if (inheritedFrom)
  {
    if (cd && !optimizeVhdl)
    {
      inheritId = substitute(lt.toLabel(),"-","_")+"_"+
                  stripPath(cd->getOutputFileBase());
      if (showSectionTitle && !title.isEmpty())
      {
        ol.writeInheritedSectionTitle(inheritId,cd->getReference(),
                                      cd->getOutputFileBase(),
                                      cd->anchor(),title,cd->displayName());
      }
    }
  }
  else if (num>numEnumValues)
  {
    if (!title.isEmpty())
    {
      if (showInline)
      {
        ol.startInlineHeader();
      }
      else
      {
        ol.startMemberHeader(m_listType.toLabel());
      }
      ol.parseText(title);
      if (showInline)
      {
        ol.endInlineHeader();
      }
      else
      {
        ol.endMemberHeader();
      }
    }
    if (!subtitle.stripWhiteSpace().isEmpty())
    {
      ol.startMemberSubtitle();
      ol.generateDoc("[generated]",-1,ctx,nullptr,subtitle,FALSE,FALSE,
                     QCString(),FALSE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
      ol.endMemberSubtitle();
    }
  }
  if (num>numEnumValues)
  {
     bool inGroup = m_container==MemberListContainer::Group;
    // TODO: Two things need to be worked out for proper VHDL output:
    // 1. Signals and types under the group need to be
    //    formatted to associate them with the group somehow
    //    indentation, or at the very least, extra space after
    //    the group is done
    // 2. This might need to be repeated below for memberGroupLists
    if (optimizeVhdl) // use specific declarations function
    {
      VhdlDocGen::writeVhdlDeclarations(this,ol,nullptr,cd,nullptr,nullptr,nullptr);
    }
    else
    {
      writePlainDeclarations(ol,inGroup,cd,nd,fd,gd,mod,0,inheritedFrom,inheritId);
    }
 
    //printf("memberGroupList=%p\n",memberGroupList);
    for (const auto &mg : m_memberGroupRefList)
    {
      bool hasHeader=!mg->header().isEmpty();
      if (inheritId.isEmpty())
      {
        //printf("mg->header=%s hasHeader=%d\n",qPrint(mg->header()),hasHeader);
        ol.startMemberGroupHeader(hasHeader);
        if (hasHeader)
        {
          ol.parseText(mg->header());
        }
        ol.endMemberGroupHeader();
        if (!mg->documentation().isEmpty())
        {
          //printf("Member group has docs!\n");
          ol.startMemberGroupDocs();
          ol.generateDoc(mg->docFile(),mg->docLine(),mg->memberContainer(),nullptr,mg->documentation()+"\n",FALSE,FALSE,
              QCString(),FALSE,FALSE,Config_getBool(MARKDOWN_SUPPORT));
          ol.endMemberGroupDocs();
        }
        ol.startMemberGroup();
      }
      //printf("--- mg->writePlainDeclarations ---\n");
      mg->writePlainDeclarations(ol,inGroup,cd,nd,fd,gd,mod,0,inheritedFrom,inheritId);
      if (inheritId.isEmpty())
      {
        ol.endMemberGroup(hasHeader);
      }
    }
  }
  if (inheritedFrom && cd)
  {
    // also add members that of this list type, that are grouped together
    // in a separate list in class 'inheritedFrom'
    cd->addGroupedInheritedMembers(ol,m_listType,inheritedFrom,inheritId);
  }
  //printf("----- end writeDeclaration() ----\n");
}

References ClassDef::addGroupedInheritedMembers(), Definition::anchor(), Config_getBool, Definition::displayName(), OutputList::endInlineHeader(), OutputList::endMemberGroup(), OutputList::endMemberGroupDocs(), OutputList::endMemberGroupHeader(), OutputList::endMemberHeader(), OutputList::endMemberSubtitle(), FALSE, OutputList::generateDoc(), Definition::getOutputFileBase(), Definition::getReference(), Group, QCString::isEmpty(), m_container, m_listType, m_memberGroupRefList, numDecEnumValues(), numDecMembers(), OutputList::parseText(), OutputList::startInlineHeader(), OutputList::startMemberGroup(), OutputList::startMemberGroupDocs(), OutputList::startMemberGroupHeader(), OutputList::startMemberHeader(), OutputList::startMemberSubtitle(), stripPath(), QCString::stripWhiteSpace(), substitute(), MemberListType::toLabel(), OutputList::writeInheritedSectionTitle(), writePlainDeclarations(), and VhdlDocGen::writeVhdlDeclarations().

Referenced by ClassDefImpl::writeMemberDeclarations(), FileDefImpl::writeMemberDeclarations(), GroupDefImpl::writeMemberDeclarations(), ModuleDefImpl::writeMemberDeclarations(), and NamespaceDefImpl::writeMemberDeclarations().

◆ writeDocumentation()

void MemberList::writeDocumentation	(	OutputList &	ol,
		const QCString &	scopeName,
		const Definition *	container,
		const QCString &	title,
		bool	showEnumValues = FALSE,
		bool	showInline = FALSE ) const

Definition at line 635 of file memberlist.cpp.

{
  if (numDocMembers()==-1)
  {
    err("MemberList::numDocMembers()==-1, so the members of this list have not been counted. Please report as a bug.\n");
    abort();
  }
 
  if (numDocMembers()==0) return;
  if (!showEnumValues && numDocMembers()<=numDocEnumValues()) return;
 
  if (!title.isEmpty())
  {
    ol.pushGeneratorState();
      ol.disable(OutputType::Html);
      ol.writeRuler();
    ol.popGeneratorState();
    ol.startGroupHeader(showInline ? 2 : 0);
    ol.parseText(title);
    ol.endGroupHeader(showInline ? 2 : 0);
  }
  ol.startMemberDocList();
 
  struct OverloadInfo
  {
    uint32_t count = 1;
    uint32_t total = 0;
  };
  std::unordered_map<std::string,OverloadInfo> overloadInfo;
  // count the number of overloaded members
  for (const auto &md : m_members)
  {
    if (md->isDetailedSectionVisible(m_container) &&
        !(md->isEnumValue() && !showInline))
    {
      auto it = overloadInfo.emplace(md->name().str(),OverloadInfo()).first;
      it->second.total++;
    }
  }
 
  for (const auto &md : m_members)
  {
    if (md->isDetailedSectionVisible(m_container) &&
        !(md->isEnumValue() && !showInline))
    {
      auto it = overloadInfo.find(md->name().str());
      uint32_t overloadCount = it->second.total;
      uint32_t &count = it->second.count;
      MemberDefMutable *mdm = toMemberDefMutable(md);
      if (mdm)
      {
        mdm->writeDocumentation(this,count++,overloadCount,ol,scopeName,container,
            m_container==MemberListContainer::Group,showEnumValues,showInline);
      }
    }
  }
  //printf("MemberList::writeDocumentation()  --  member groups %d\n",memberGroupList->count());
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->writeDocumentation(ol,scopeName,container,showEnumValues,showInline);
  }
  ol.endMemberDocList();
}

References container(), OutputList::disable(), OutputList::endGroupHeader(), OutputList::endMemberDocList(), err, Group, Html, QCString::isEmpty(), m_container, m_memberGroupRefList, MemberVector::m_members, numDocEnumValues(), numDocMembers(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startGroupHeader(), OutputList::startMemberDocList(), toMemberDefMutable(), MemberDefMutable::writeDocumentation(), and OutputList::writeRuler().

Referenced by ClassDefImpl::writeMemberDocumentation(), FileDefImpl::writeMemberDocumentation(), GroupDefImpl::writeMemberDocumentation(), ModuleDefImpl::writeMemberDocumentation(), and NamespaceDefImpl::writeMemberDocumentation().

◆ writeDocumentationPage()

void MemberList::writeDocumentationPage	(	OutputList &	ol,
		const QCString &	scopeName,
		const DefinitionMutable *	container,
		int	hierarchyLevel = 0 ) const

Definition at line 726 of file memberlist.cpp.

{
  bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
 
  struct OverloadInfo
  {
    uint32_t count = 1;
    uint32_t total = 0;
  };
  std::unordered_map<std::string,OverloadInfo> overloadInfo;
 
  // count the number of overloaded members
  for (const auto &imd : m_members)
  {
    MemberDefMutable *md = toMemberDefMutable(imd);
 
    if (md && md->hasDetailedDescription())
    {
      auto it = overloadInfo.emplace(md->name().str(),OverloadInfo()).first;
      it->second.total++;
    }
  }
 
  for (const auto &imd : m_members)
  {
    Definition *container_d = toDefinition(const_cast<DefinitionMutable*>(container));
    MemberDefMutable *md = toMemberDefMutable(imd);
    if (md && md->hasDetailedDescription())
    {
      auto it = overloadInfo.find(md->name().str());
      uint32_t overloadCount = it->second.total;
      uint32_t &count = it->second.count;
      QCString diskName=md->getOutputFileBase();
      QCString title=md->qualifiedName();
      startFile(ol,diskName,md->name(),title,HighlightedItem::None,!generateTreeView,diskName, hierarchyLevel);
      if (!generateTreeView)
      {
        container->writeNavigationPath(ol);
        ol.endQuickIndices();
      }
      ol.startContents();
 
      if (generateTreeView)
      {
        md->writeDocumentation(this,count++,overloadCount,ol,scopeName,container_d,m_container==MemberListContainer::Group);
 
        ol.endContents();
        endFileWithNavPath(ol,container_d);
      }
      else
      {
        ol.writeString("<table cellspacing=\"0\" cellpadding=\"0\" border=\"0\">\n"
            "  <tr>\n"
            "   <td valign=\"top\">\n");
 
        container->writeQuickMemberLinks(ol,md);
 
        ol.writeString("   </td>\n");
        ol.writeString("   <td valign=\"top\" class=\"mempage\">\n");
 
        md->writeDocumentation(this,count++,overloadCount,ol,scopeName,container_d,m_container==MemberListContainer::Group);
 
        ol.writeString("    </td>\n");
        ol.writeString("  </tr>\n");
        ol.writeString("</table>\n");
 
        endFile(ol);
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->writeDocumentationPage(ol,scopeName,container);
  }
}

References Config_getBool, container(), OutputList::endContents(), endFile(), endFileWithNavPath(), OutputList::endQuickIndices(), Definition::getOutputFileBase(), Group, MemberDef::hasDetailedDescription(), m_container, m_memberGroupRefList, MemberVector::m_members, Definition::name(), None, Definition::qualifiedName(), OutputList::startContents(), startFile(), QCString::str(), toDefinition(), toMemberDefMutable(), MemberDefMutable::writeDocumentation(), and OutputList::writeString().

◆ writePlainDeclarations()

void MemberList::writePlainDeclarations	(	OutputList &	ol,
		bool	inGroup,
		const ClassDef *	cd,
		const NamespaceDef *	nd,
		const FileDef *	fd,
		const GroupDef *	gd,
		const ModuleDef *	mod,
		int	indentLevel,
		const ClassDef *	inheritedFrom,
		const QCString &	inheritId ) const

Definition at line 333 of file memberlist.cpp.

{
  //printf("----- writePlainDeclaration() ----\n");
  if (numDecMembers()==-1)
  {
    err("MemberList::numDecMembers()==-1, so the members of this list have not been counted. Please report as a bug.\n");
    abort();
  }
  if (numDecMembers()<=numDecEnumValues())
  {
    //printf("  --> no members!\n");
    return; // no members in this list
  }
  //printf("  --> writePlainDeclaration() numDecMembers()=%d\n",
  //    numDecMembers());
 
  ol.pushGeneratorState();
 
  bool first=TRUE;
  for (const auto &md : m_members)
  {
    //printf(">>> Member '%s' type=%d visible=%d inheritedFrom=%p inheritId=%s\n",
    //   qPrint(md->name()),md->memberType(),md->isBriefSectionVisible(),(void*)inheritedFrom,qPrint(inheritId));
    if ((inheritedFrom==nullptr || !md->isReimplementedBy(inheritedFrom)) &&
        md->isBriefSectionVisible())
    {
      //printf(">>> rendering\n");
      switch(md->memberType())
      {
        case MemberType::Define:      // fall through
        //case MemberType::Prototype: // fall through
        case MemberType::Typedef:     // fall through
        case MemberType::Variable:    // fall through
        case MemberType::Function:    // fall through
        case MemberType::Signal:      // fall through
        case MemberType::Slot:        // fall through
        case MemberType::DCOP:        // fall through
        case MemberType::Property:    // fall through
        case MemberType::Interface:   // fall through
        case MemberType::Service:     // fall through
        case MemberType::Sequence:    // fall through
        case MemberType::Dictionary:  // fall through
        case MemberType::Event:
          {
            if (first) ol.startMemberList(),first=FALSE;
            md->writeDeclaration(ol,cd,nd,fd,gd,mod,inGroup,indentLevel,inheritedFrom,inheritId);
            break;
          }
        case MemberType::Enumeration:
          {
            // if this is an anonymous enum and there are variables of this
            // enum type (i.e. enumVars>0), then we do not show the enum here.
            if (countEnumValues(md)==0) // show enum here
            {
              //printf("Enum!!\n");
              if (first)
              {
                ol.startMemberList();
                first=FALSE;
              }
              ol.startMemberDeclaration();
              ol.startMemberItem(md->anchor(),OutputGenerator::MemberItemType::Normal,inheritId);
              bool detailsLinkable = md->hasDetailedDescription();
              if (!detailsLinkable)
              {
                ol.startDoxyAnchor(md->getOutputFileBase(),QCString(),md->anchor(),md->name(),QCString());
                ol.addLabel(md->getOutputFileBase(),md->anchor());
              }
              if (md->isSliceLocal())
              {
                ol.writeString("local ");
              }
              ol.writeString("enum ");
              if (md->getLanguage()==SrcLangExt::Cpp && md->isStrong())
              {
                if (md->isEnumStruct())
                {
                  ol.writeString("struct ");
                }
                else
                {
                  ol.writeString("class ");
                }
              }
              ol.insertMemberAlign();
              md->writeEnumDeclaration(ol,cd,nd,fd,gd,mod);
              if (!detailsLinkable)
              {
                ol.endDoxyAnchor(md->getOutputFileBase(),md->anchor());
              }
              ol.endMemberItem(OutputGenerator::MemberItemType::Normal);
              if (!md->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
              {
                auto parser { createDocParser() };
                auto ast    { validatingParseDoc(*parser.get(),
                                                 md->briefFile(),md->briefLine(),
                                                 cd,md,
                                                 md->briefDescription(),
                                                 TRUE,FALSE,
                                                 QCString(),TRUE,FALSE,
                                                 Config_getBool(MARKDOWN_SUPPORT)) };
                if (!ast->isEmpty())
                {
                  ol.startMemberDescription(md->anchor());
                  ol.writeDoc(ast.get(),cd,md);
                  if (md->hasDetailedDescription())
                  {
                    ol.disableAllBut(OutputType::Html);
                    ol.docify(" ");
                    ol.startTextLink(md->getOutputFileBase(),
                        md->anchor());
                    ol.parseText(theTranslator->trMore());
                    ol.endTextLink();
                    ol.enableAll();
                  }
                  ol.endMemberDescription();
                }
              }
              ol.endMemberDeclaration(md->anchor(),inheritId);
            }
            md->warnIfUndocumented();
            break;
          }
        case MemberType::Friend:
          if (inheritedFrom==nullptr)
          {
            if (first)
            {
              ol.startMemberList();
              first=FALSE;
            }
            md->writeDeclaration(ol,cd,nd,fd,gd,mod,inGroup,indentLevel,inheritedFrom,inheritId);
            break;
          }
        case MemberType::EnumValue:
          {
            if (inGroup)
            {
              //printf("EnumValue!\n");
              if (first) ol.startMemberList(),first=FALSE;
              md->writeDeclaration(ol,cd,nd,fd,gd,mod,true,indentLevel,inheritedFrom,inheritId);
            }
          }
          break;
      }
    }
  }
 
  if (!first)
  {
    ol.endMemberList();
  }
 
  ol.popGeneratorState();
  //printf("----- end writePlainDeclaration() ----\n");
}

References OutputList::addLabel(), Definition::briefDescription(), Config_getBool, countEnumValues(), Cpp, createDocParser(), DCOP, Define, Dictionary, OutputList::disableAllBut(), OutputList::docify(), OutputList::enableAll(), OutputList::endDoxyAnchor(), OutputList::endMemberDeclaration(), OutputList::endMemberDescription(), OutputList::endMemberItem(), OutputList::endMemberList(), OutputList::endTextLink(), Enumeration, EnumValue, err, Event, FALSE, Friend, Function, Html, OutputList::insertMemberAlign(), Interface, MemberVector::m_members, OutputGenerator::Normal, numDecEnumValues(), numDecMembers(), OutputList::parseText(), OutputList::popGeneratorState(), Property, OutputList::pushGeneratorState(), Sequence, Service, Signal, Slot, OutputList::startDoxyAnchor(), OutputList::startMemberDeclaration(), OutputList::startMemberDescription(), OutputList::startMemberItem(), OutputList::startMemberList(), OutputList::startTextLink(), theTranslator, Translator::trMore(), TRUE, Typedef, validatingParseDoc(), Variable, OutputList::writeDoc(), and OutputList::writeString().

Referenced by MemberGroup::addGroupedInheritedMembers(), writeDeclarations(), and ClassDefImpl::writePlainMemberDeclaration().

◆ writeSimpleDocumentation()

void MemberList::writeSimpleDocumentation	(	OutputList &	ol,
		const Definition *	container ) const

Definition at line 702 of file memberlist.cpp.

{
  //printf("MemberList count=%d enumValues=%d\n",numDocMembers(),numDocEnumValues());
  if (numDocMembers()<=numDocEnumValues()) return; // only enum values and they should be excluded
 
  const ClassDef *cd = nullptr;
  if (container && container->definitionType()==Definition::TypeClass)
  {
    cd = toClassDef(container);
  }
  ol.startMemberDocSimple(cd && cd->isJavaEnum());
  for (const auto &md : m_members)
  {
    MemberDefMutable *mdm = toMemberDefMutable(md);
    if (mdm)
    {
      mdm->writeMemberDocSimple(ol,container);
    }
  }
  ol.endMemberDocSimple(cd && cd->isJavaEnum());
}

References container(), OutputList::endMemberDocSimple(), ClassDef::isJavaEnum(), MemberVector::m_members, numDocEnumValues(), numDocMembers(), OutputList::startMemberDocSimple(), toClassDef(), toMemberDefMutable(), Definition::TypeClass, and MemberDefMutable::writeMemberDocSimple().

Referenced by ClassDefImpl::writeSimpleMemberDocumentation().

◆ writeTagFile()

void MemberList::writeTagFile	(	TextStream &	tagFile,
		bool	useQualifiedName = false,
		bool	showNamespaceMembers = true )

Definition at line 859 of file memberlist.cpp.

{
  for (const auto &imd : m_members)
  {
    MemberDefMutable *md = toMemberDefMutable(imd);
    if (md)
    {
      if (md->getLanguage()!=SrcLangExt::VHDL)
      {
        md->writeTagFile(tagFile,useQualifiedName,showNamespaceMembers);
        if (md->memberType()==MemberType::Enumeration && !md->isStrong())
        {
          for (const auto &ivmd : md->enumFieldList())
          {
            MemberDefMutable *vmd = toMemberDefMutable(ivmd);
            if (vmd)
            {
              vmd->writeTagFile(tagFile,useQualifiedName,showNamespaceMembers);
            }
          }
        }
      }
      else
      {
        VhdlDocGen::writeTagFile(md,tagFile);
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->writeTagFile(tagFile,useQualifiedName);
  }
}

References Enumeration, MemberDef::enumFieldList(), Definition::getLanguage(), MemberDef::isStrong(), m_memberGroupRefList, MemberVector::m_members, MemberDef::memberType(), toMemberDefMutable(), VHDL, MemberDefMutable::writeTagFile(), and VhdlDocGen::writeTagFile().

Referenced by ClassDefImpl::writeTagFile(), FileDefImpl::writeTagFile(), GroupDefImpl::writeTagFile(), ModuleDefImpl::writeTagFile(), and NamespaceDefImpl::writeTagFile().

Member Data Documentation

◆ m_container

MemberListContainer MemberList::m_container

private

Definition at line 155 of file memberlist.h.

Referenced by container(), countDocMembers(), declVisible(), MemberList(), writeDeclarations(), writeDocumentation(), and writeDocumentationPage().

◆ m_listType

MemberListType MemberList::m_listType

private

Definition at line 156 of file memberlist.h.

Referenced by listType(), MemberList(), and writeDeclarations().

◆ m_memberGroupRefList

MemberGroupRefList MemberList::m_memberGroupRefList

private

Definition at line 154 of file memberlist.h.

Referenced by addListReferences(), addMemberGroup(), countDecMembers(), countDocMembers(), countInheritableMembers(), findSectionsInDocumentation(), getMemberGroupList(), setAnonymousEnumType(), writeDeclarations(), writeDocumentation(), writeDocumentationPage(), and writeTagFile().

◆ m_needsSorting

bool MemberList::m_needsSorting

private

Definition at line 157 of file memberlist.h.

Referenced by MemberList(), needsSorting(), and setNeedsSorting().

◆ m_numDecEnumValues

int MemberList::m_numDecEnumValues

private

Definition at line 151 of file memberlist.h.

Referenced by countDecMembers(), MemberList(), and numDecEnumValues().

◆ m_numDecMembers

int MemberList::m_numDecMembers

private

Definition at line 150 of file memberlist.h.

Referenced by countDecMembers(), MemberList(), and numDecMembers().

◆ m_numDocEnumValues

int MemberList::m_numDocEnumValues

private

Definition at line 153 of file memberlist.h.

Referenced by countDocMembers(), MemberList(), and numDocEnumValues().

◆ m_numDocMembers

int MemberList::m_numDocMembers

private

Definition at line 152 of file memberlist.h.

Referenced by countDocMembers(), MemberList(), and numDocMembers().

The documentation for this class was generated from the following files:

src/memberlist.h
src/memberlist.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ MemberList()

◆ ~MemberList()

Member Function Documentation

◆ addListReferences()

◆ addMemberGroup()

◆ container()

◆ countDecMembers()

◆ countDocMembers()

◆ countEnumValues()

◆ countInheritableMembers()

◆ declVisible()

◆ findSectionsInDocumentation()

◆ getMemberGroupList()

◆ listType()

◆ needsSorting()

◆ numDecEnumValues()

◆ numDecMembers()

◆ numDocEnumValues()

◆ numDocMembers()

◆ setAnchors()

◆ setAnonymousEnumType()

◆ setNeedsSorting()

◆ writeDeclarations()

◆ writeDocumentation()

◆ writeDocumentationPage()

◆ writePlainDeclarations()

◆ writeSimpleDocumentation()

◆ writeTagFile()

Member Data Documentation

◆ m_container

◆ m_listType

◆ m_memberGroupRefList

◆ m_needsSorting

◆ m_numDecEnumValues

◆ m_numDecMembers

◆ m_numDocEnumValues

◆ m_numDocMembers