MemberList Class Reference

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 ClassDef *inheritedFrom) const
int	numDecMembers () const
int	numDecEnumValues () const
int	numDocMembers () const
int	numDocEnumValues () const
bool	needsSorting () const
void	countDecMembers () const
std::pair< int, int >	countDecMembers (const ClassDef *inheritedFrom) const
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 DString &inheritId) const
void	writeDeclarations (OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, const DString &title, const DString &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 DString &scopeName, const Definition *container, const DString &title, const DString &anchor, bool showEnumValues=false, bool showInline=false) const
void	writeSimpleDocumentation (OutputList &ol, const Definition *container) const
void	writeDocumentationPage (OutputList &ol, const DString &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 (const Definition *def)
void	addRequirementReferences (const 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
const MemberDef *	find (const DString &name) const
MemberDef *	find (const DString &name)
const MemberDef *	findRev (const DString &name) const
MemberDef *	findRev (const DString &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 124 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 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.

{
}

Member Function Documentation

addListReferences()

void MemberList::addListReferences

(

const Definition *

def

)

Definition at line 805 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(), 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 800 of file memberlist.cpp.

{
  m_memberGroupRefList.push_back(mg);
}

References m_memberGroupRefList.

Referenced by MemberGroup::addToDeclarationSection().

addRequirementReferences()

void MemberList::addRequirementReferences

(

const Definition *

def

)

Definition at line 835 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->addRequirementReferences(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->addRequirementReferences(def);
          }
        }
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->addRequirementReferences(def);
  }
}

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

container()

MemberListContainer MemberList::container ( ) const

inline

Definition at line 131 of file memberlist.h.

{ return m_container; }

References m_container.

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

countDecMembers() [1/2]

void MemberList::countDecMembers

(

)

const

Definition at line 184 of file memberlist.cpp.

{
  if (m_numDecMembers!=-1) return; // already cached
  std::tie(m_numDecMembers, m_numDecEnumValues) = countDecMembers(nullptr); // cache new values
}

References countDecMembers(), m_numDecEnumValues, and m_numDecMembers.

Referenced by MemberGroup::addGroupedInheritedMembers(), countDecMembers(), and numDecMembers().

countDecMembers() [2/2]

std::pair< int, int > MemberList::countDecMembers

(

const ClassDef *

inheritedFrom

)

const

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.

{
  //printf("----- countDecMembers count=%d ----\n",count());
  int numDecMembers=0;
  int numDecEnumValues=0;
  for (const auto &md : m_members)
  {
    //printf("MemberList::countDecMembers(md=%s,%d)\n",qPrint(md->name()),md->isBriefSectionVisible());
    if ((inheritedFrom==nullptr || !md->isReimplementedBy(inheritedFrom)) &&
        md->isBriefSectionVisible())
    {
      switch(md->memberType())
      {
        case MemberType::Variable:    // fall through
        case MemberType::Event:       // fall through
        case MemberType::Property:   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())
                                     numDecMembers++;
                                     break;
        case MemberType::Enumeration:
                                     numDecMembers++;
                                     break;
        case MemberType::EnumValue:  numDecEnumValues++;
                                     numDecMembers++;
                                     break;
        case MemberType::Typedef:    numDecMembers++;
                                     break;
        case MemberType::Sequence:   numDecMembers++;
                                     break;
        case MemberType::Dictionary: numDecMembers++;
                                     break;
        case MemberType::Define:      if (Config_getBool(EXTRACT_ALL) ||
                                         !md->argsString().empty() ||
                                         !md->initializer().empty() ||
                                         md->hasDocumentation()
                                        ) numDecMembers++;
                                     break;
        case MemberType::Friend:     numDecMembers++;
                                     break;
        default:
          err("Unknown member type found for member '{}'!\n",md->name());
      }
    }
  }
  for (const auto &mg : m_memberGroupRefList)
  {
    mg->countDecMembers();
    numDecMembers+=mg->numDecMembers();
    numDecEnumValues+=mg->numDecEnumValues();
  }
  //printf("----- end countDecMembers ----\n");
 
  return std::make_pair(numDecMembers,numDecEnumValues);
}

References Config_getBool, err, m_memberGroupRefList, MemberVector::m_members, numDecEnumValues(), and numDecMembers().

countDocMembers()

void MemberList::countDocMembers

(

)

Definition at line 190 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 m_container, m_memberGroupRefList, MemberVector::m_members, m_numDocEnumValues, and m_numDocMembers.

countEnumValues()

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

private

Definition at line 247 of file memberlist.cpp.

{
  int numEnumValues=0;
  DString name(md->name());
  if (size_t i=name.rfind("::"); i!=DString::npos) name=name.mid(i+2);
  if (name[0]=='@')
  {
    for (const auto &vmd : m_members)
    {
      DString vtype=vmd->typeString();
      if ((vtype.find(name))!=DString::npos)
      {
        numEnumValues++;
      }
    }
  }
  return numEnumValues;
}

References DString::find(), MemberVector::m_members, DString::mid(), Definition::name(), DString::npos, and DString::rfind().

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 m_memberGroupRefList, and MemberVector::m_members.

Referenced by ClassDefImpl::countMembersIncludingGrouped().

declVisible()

bool MemberList::declVisible

(

)

const

Definition at line 266 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(), Group, m_container, and MemberVector::m_members.

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

findSectionsInDocumentation()

void MemberList::findSectionsInDocumentation

(

const Definition *

d

)

Definition at line 865 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 166 of file memberlist.h.

{ return m_memberGroupRefList; }

References m_memberGroupRefList.

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

listType()

MemberListType MemberList::listType ( ) const

inline

Definition at line 130 of file memberlist.h.

{ return m_listType; }

References listType(), and m_listType.

Referenced by MemberGroup::addGroupedInheritedMembers(), MemberGroup::countGroupedInheritedMembers(), generateSqlite3ForClass(), generateSqlite3ForFile(), generateSqlite3ForGroup(), generateSqlite3ForModule(), generateSqlite3ForNamespace(), generateXMLForClass(), generateXMLForFile(), generateXMLForGroup(), generateXMLForModule(), generateXMLForNamespace(), listType(), writeDeclarations(), ClassDefImpl::writeMemberDocumentation(), FileDefImpl::writeMemberDocumentation(), GroupDefImpl::writeMemberDocumentation(), ModuleDefImpl::writeMemberDocumentation(), NamespaceDefImpl::writeMemberDocumentation(), ClassDefImpl::writeSummaryLinks(), FileDefImpl::writeSummaryLinks(), GroupDefImpl::writeSummaryLinks(), ModuleDefImpl::writeSummaryLinks(), NamespaceDefImpl::writeSummaryLinks(), and VhdlDocGen::writeVHDLDeclarations().

needsSorting()

bool MemberList::needsSorting ( ) const

inline

Definition at line 140 of file memberlist.h.

{ return m_needsSorting; }

References m_needsSorting.

Referenced by FileDefImpl::sortMemberLists().

numDecEnumValues()

int MemberList::numDecEnumValues ( ) const

inline

Definition at line 137 of file memberlist.h.

{ return m_numDecEnumValues; }

References m_numDecEnumValues.

Referenced by countDecMembers(), writeDeclarations(), and writePlainDeclarations().

numDecMembers() [1/2]

int MemberList::numDecMembers ( ) const

inline

Definition at line 135 of file memberlist.h.

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

References ASSERT, and m_numDecMembers.

numDecMembers() [2/2]

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

inline

Definition at line 133 of file memberlist.h.

    { return countDecMembers(inheritedFrom).first; }

References countDecMembers().

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

numDocEnumValues()

int MemberList::numDocEnumValues ( ) const

inline

Definition at line 139 of file memberlist.h.

{ return m_numDocEnumValues; }

References m_numDocEnumValues.

Referenced by writeDocumentation(), and writeSimpleDocumentation().

numDocMembers()

int MemberList::numDocMembers ( ) const

inline

Definition at line 138 of file memberlist.h.

{ 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 921 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(), GroupDefImpl::computeAnchors(), and NamespaceDefImpl::computeAnchors().

setAnonymousEnumType()

void MemberList::setAnonymousEnumType

(

)

Definition at line 215 of file memberlist.cpp.

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

References DString::find(), m_memberGroupRefList, MemberVector::m_members, DString::mid(), DString::npos, DString::rfind(), MemberDefMutable::setAnonymousEnumType(), and toMemberDefMutable().

Referenced by ClassDefImpl::setAnonymousEnumType().

setNeedsSorting()

void MemberList::setNeedsSorting

(

bool

b

)

Definition at line 881 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 DString &	title,
		const DString &	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 503 of file memberlist.cpp.

{
  //printf("----- writeDeclaration() this=%p ---- inheritedFrom=%p\n",this,inheritedFrom);
  bool optimizeVhdl = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
  DString 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(inheritedFrom);
  int numEnumValues = numDecEnumValues();
  if (inheritedFrom && num>0)
  {
    if (cd && !optimizeVhdl)
    {
      inheritId = substitute(lt.toLabel(),"-","_")+"_"+
                  stripPath(cd->getOutputFileBase());
      if (showSectionTitle && !title.empty())
      {
        ol.writeInheritedSectionTitle(inheritId,cd->getReference(),
                                      cd->getOutputFileBase(),
                                      cd->anchor(),title,cd->displayName());
      }
    }
  }
  else if (num>numEnumValues)
  {
    if (!title.empty())
    {
      if (showInline)
      {
        ol.startInlineHeader();
      }
      else
      {
        ol.startMemberHeader(m_listType.toLabel());
      }
      ol.parseText(title);
      if (showInline)
      {
        ol.endInlineHeader();
      }
      else
      {
        ol.endMemberHeader();
      }
    }
    if (!subtitle.stripWhiteSpace().empty())
    {
      ol.startMemberSubtitle();
      ol.generateDoc("[generated]", -1, ctx, nullptr, subtitle, DocOptions());
      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);
    int groupId=0;
    for (const auto &mg : m_memberGroupRefList)
    {
      bool hasHeader=!mg->header().empty();
      if (inheritId.empty())
      {
        DString groupAnchor = DString(listType().toLabel())+"-"+DString().setNum(groupId++);
        //printf("mg->header=%s hasHeader=%d\n",qPrint(mg->header()),hasHeader);
        ol.startMemberGroupHeader(groupAnchor,hasHeader);
        if (hasHeader)
        {
          ol.parseText(mg->header());
        }
        ol.endMemberGroupHeader(hasHeader);
        if (!mg->documentation().empty())
        {
          //printf("Member group has docs!\n");
          ol.startMemberGroupDocs();
          ol.generateDoc(mg->docFile(),
                         mg->docLine(),
                         mg->memberContainer(),
                         nullptr,
                         mg->documentation()+"\n",
                         DocOptions());
          ol.endMemberGroupDocs();
        }
        ol.startMemberGroup();
      }
      //printf("--- mg->writePlainDeclarations ---\n");
      mg->writePlainDeclarations(ol,inGroup,cd,nd,fd,gd,mod,0,inheritedFrom,inheritId);
      if (inheritId.empty())
      {
        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(), DString::DString(), DString::empty(), OutputList::endInlineHeader(), OutputList::endMemberGroup(), OutputList::endMemberGroupDocs(), OutputList::endMemberGroupHeader(), OutputList::endMemberHeader(), OutputList::endMemberSubtitle(), OutputList::generateDoc(), Definition::getOutputFileBase(), Definition::getReference(), Group, listType(), m_container, m_listType, m_memberGroupRefList, numDecEnumValues(), numDecMembers(), OutputList::parseText(), DString::setNum(), OutputList::startInlineHeader(), OutputList::startMemberGroup(), OutputList::startMemberGroupDocs(), OutputList::startMemberGroupHeader(), OutputList::startMemberHeader(), OutputList::startMemberSubtitle(), stripPath(), DString::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 DString &	scopeName,
		const Definition *	container,
		const DString &	title,
		const DString &	anchor,
		bool	showEnumValues = false,
		bool	showInline = false ) const

Definition at line 630 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.empty())
  {
    ol.pushGeneratorState();
      ol.disable(OutputType::Html);
      ol.writeRuler();
    ol.popGeneratorState();
    if (container) ol.writeAnchor(container->getOutputFileBase(),anchor);
    ol.startGroupHeader(anchor,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(), DString::empty(), OutputList::endGroupHeader(), OutputList::endMemberDocList(), err, Definition::getOutputFileBase(), Group, Html, m_container, m_memberGroupRefList, MemberVector::m_members, numDocEnumValues(), numDocMembers(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startGroupHeader(), OutputList::startMemberDocList(), toMemberDefMutable(), OutputList::writeAnchor(), 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 DString &	scopeName,
		const DefinitionMutable *	container,
		int	hierarchyLevel = 0 ) const

Definition at line 723 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;
      DString diskName=md->getOutputFileBase();
      DString title=md->qualifiedName();
      startFile(ol,diskName,false,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);
      }
      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(), DString::str(), toDefinition(), toMemberDefMutable(), MemberDefMutable::writeDocumentation(), DefinitionMutable::writeNavigationPath(), DefinitionMutable::writeQuickMemberLinks(), 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 DString &	inheritId ) const

Definition at line 314 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(),DString(),md->anchor(),md->name(),DString());
                ol.addLabel(md->getOutputFileBase(),md->anchor());
              }
              if (md->isSliceLocal())
              {
                ol.writeString("local ");
              }
              DString enumType = "enum ";
              if (md->getLanguage()==SrcLangExt::Cpp && md->isStrong())
              {
                if (md->isEnumStruct())
                {
                  enumType+="struct ";
                }
                else
                {
                  enumType+="class ";
                }
              }
              if (md->name().startsWith("@"))
              {
                ol.writeObjectLink(md->getReference(),md->getOutputFileBase(),md->anchor(),enumType);
              }
              else
              {
                ol.writeString(enumType);
              }
              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().empty() && Config_getBool(BRIEF_MEMBER_DESC))
              {
                auto parser { createDocParser() };
                auto ast    { validatingParseDoc(*parser.get(),
                                                 md->briefFile(),
                                                 md->briefLine(),
                                                 cd ? cd : md->getOuterScope(),
                                                 md,
                                                 md->briefDescription(),
                                                 DocOptions()
                                                 .setIndexWords(true)
                                                 .setSingleLine(true))
                            };
                if (!ast->empty())
                {
                  ol.startMemberDescription(md->anchor(),inheritId);
                  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(), createDocParser(), OutputList::disableAllBut(), OutputList::docify(), OutputList::enableAll(), OutputList::endDoxyAnchor(), OutputList::endMemberDeclaration(), OutputList::endMemberDescription(), OutputList::endMemberItem(), OutputList::endMemberList(), OutputList::endTextLink(), err, Definition::getOuterScope(), Html, OutputList::insertMemberAlign(), MemberVector::m_members, OutputGenerator::Normal, numDecEnumValues(), numDecMembers(), OutputList::parseText(), OutputList::popGeneratorState(), OutputList::pushGeneratorState(), OutputList::startDoxyAnchor(), OutputList::startMemberDeclaration(), OutputList::startMemberDescription(), OutputList::startMemberItem(), OutputList::startMemberList(), OutputList::startTextLink(), theTranslator, Translator::trMore(), validatingParseDoc(), OutputList::writeDoc(), OutputList::writeObjectLink(), and OutputList::writeString().

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

writeSimpleDocumentation()

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

Definition at line 699 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(), Definition::definitionType(), 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 886 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 MemberDef::enumFieldList(), Definition::getLanguage(), MemberDef::isStrong(), m_memberGroupRefList, MemberVector::m_members, MemberDef::memberType(), toMemberDefMutable(), 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 177 of file memberlist.h.

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

m_listType

MemberListType MemberList::m_listType

private

Definition at line 178 of file memberlist.h.

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

m_memberGroupRefList

MemberGroupRefList MemberList::m_memberGroupRefList

private

Definition at line 176 of file memberlist.h.

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

m_needsSorting

bool MemberList::m_needsSorting

private

Definition at line 179 of file memberlist.h.

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

m_numDecEnumValues

int MemberList::m_numDecEnumValues

mutableprivate

Definition at line 173 of file memberlist.h.

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

m_numDecMembers

int MemberList::m_numDecMembers

mutableprivate

Definition at line 172 of file memberlist.h.

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

m_numDocEnumValues

int MemberList::m_numDocEnumValues

private

Definition at line 175 of file memberlist.h.

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

m_numDocMembers

int MemberList::m_numDocMembers

private

Definition at line 174 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