#include <memberlist.h>

Inheritance diagram for MemberList:

Public Member Functions
	MemberList ()

	MemberList (MemberListType lt)

	~MemberList ()

MemberListType	listType () const

bool	insert (uint index, const MemberDef *md)

void	inSort (const MemberDef *md)

void	append (const MemberDef *md)

int	varCount () const

int	funcCount () const

int	enumCount () const

int	enumValueCount () const

int	typedefCount () const

int	protoCount () const

int	defineCount () const

int	friendCount () const

int	numDecMembers () const

int	numDocMembers () const

bool	needsSorting () const

void	countDecMembers (bool countEnumValues=FALSE, GroupDef *gd=0)

void	countDocMembers (bool countEnumValues=FALSE)

int	countInheritableMembers (ClassDef *inheritedFrom) const

void	writePlainDeclarations (OutputList &ol, ClassDef cd, NamespaceDef nd, FileDef fd, GroupDef gd, ClassDef inheritedFrom, const char inheritId)

void	writeDeclarations (OutputList &ol, ClassDef cd, NamespaceDef nd, FileDef fd, GroupDef gd, const char title, const char subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, ClassDef *inheritedFrom=0, MemberListType lt=MemberListType_pubMethods)

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

void	writeSimpleDocumentation (OutputList &ol, Definition *container)

void	writeDocumentationPage (OutputList &ol, const char scopeName, Definition container)

void	writeTagFile (FTextStream &)

bool	declVisible () const

void	addMemberGroup (MemberGroup *mg)

void	setInGroup (bool inGroup)

void	setInFile (bool inFile)

void	addListReferences (Definition *def)

void	findSectionsInDocumentation ()

void	setNeedsSorting (bool b)

MemberGroupList *	getMemberGroupList () const

void	marshal (StorageIntf *s)

void	unmarshal (StorageIntf *s)

Public Member Functions inherited from QList< MemberDef >
	QList ()

	QList (const QList< MemberDef > &l)

	~QList ()

QList< MemberDef > &	operator= (const QList< MemberDef > &l)

bool	operator== (const QList< MemberDef > &list) const

uint	count () const

bool	isEmpty () const

bool	insert (uint i, const MemberDef *d)

void	inSort (const MemberDef *d)

void	prepend (const MemberDef *d)

void	append (const MemberDef *d)

bool	remove (uint i)

bool	remove (const MemberDef *d)

bool	removeRef (const MemberDef *d)

bool	removeFirst ()

bool	removeLast ()

MemberDef *	take (uint i)

void	clear ()

void	sort ()

int	find (const MemberDef *d) const

int	findRef (const MemberDef *d) const

uint	contains (const MemberDef *d) const

uint	containsRef (const MemberDef *d) const

MemberDef *	at (uint i) const

MemberDef *	getFirst () const

MemberDef *	getLast () const

void	setAutoDelete (bool enable)

Static Public Member Functions
static QCString	listTypeAsString (MemberListType type)

Private Member Functions
int	compareValues (const MemberDef item1, const MemberDef item2) const

Private Attributes
int	m_varCnt

int	m_funcCnt

int	m_enumCnt

int	m_enumValCnt

int	m_typeCnt

int	m_protoCnt

int	m_defCnt

int	m_friendCnt

int	m_numDecMembers

int	m_numDocMembers

MemberGroupList *	memberGroupList

bool	m_inGroup

bool	m_inFile

MemberListType	m_listType

bool	m_needsSorting

Detailed Description

A list of MemberDef objects.

Definition at line 32 of file memberlist.h.

Constructor & Destructor Documentation

MemberList::MemberList ( )

Definition at line 36 of file memberlist.cpp.

                        : m_listType(MemberListType_pubMethods)
 {
   memberGroupList=0;
   m_varCnt=0;
   m_funcCnt=0;
   m_enumCnt=0;
   m_enumValCnt=0;
   m_typeCnt=0;
   m_protoCnt=0;
   m_defCnt=0;
   m_friendCnt=0;
   m_numDecMembers=-1; // special value indicating that value needs to be computed
   m_numDocMembers=-1; // special value indicating that value needs to be computed
   m_inGroup=FALSE;
   m_inFile=FALSE;
   m_needsSorting=FALSE;
 }

MemberList::MemberList ( MemberListType lt )

Definition at line 54 of file memberlist.cpp.

                                         : m_listType(lt)
 {
   memberGroupList=0;
   m_varCnt=0;
   m_funcCnt=0;
   m_enumCnt=0;
   m_enumValCnt=0;
   m_typeCnt=0;
   m_protoCnt=0;
   m_defCnt=0;
   m_friendCnt=0;
   m_numDecMembers=-1; // special value indicating that value needs to be computed
   m_numDocMembers=-1; // special value indicating that value needs to be computed
   m_inGroup=FALSE;
   m_inFile=FALSE;
   m_needsSorting=FALSE;
 }

MemberList::~MemberList ( )

Definition at line 72 of file memberlist.cpp.

 {
   delete memberGroupList;
 }

Member Function Documentation

void MemberList::addListReferences ( Definition * def )

Definition at line 784 of file memberlist.cpp.

 {
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     if (md->getGroupDef()==0 || def->definitionType()==Definition::TypeGroup)
     {
       md->addListReference(def);
       MemberList *enumFields = md->enumFieldList();
       if (md->memberType()==MemberType_Enumeration && enumFields)
       {
         //printf("  Adding enum values!\n");
         MemberListIterator vmli(*enumFields);
         MemberDef *vmd;
         for ( ; (vmd=vmli.current()) ; ++vmli)
         {
           //printf("   adding %s\n",vmd->name().data());  
           vmd->addListReference(def);
         }
       }
     }
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->addListReferences(def);
     }
   }
 }

void MemberList::addMemberGroup ( MemberGroup * mg )

Definition at line 774 of file memberlist.cpp.

 {
   if (memberGroupList==0)
   {
     memberGroupList=new MemberGroupList;
   }
   //printf("addMemberGroup: this=%p mg=%p\n",this,mg);
   memberGroupList->append(mg);
 }

void MemberList::append ( const MemberDef * md )

Definition at line 246 of file memberlist.cpp.

 {
   QList<MemberDef>::append(md);
 }

int MemberList::compareValues	(	const MemberDef *	item1,
		const MemberDef *	item2
	)		const

privatevirtual

Reimplemented from QList< MemberDef >.

Definition at line 77 of file memberlist.cpp.

 {
   static bool sortConstructorsFirst = Config_getBool("SORT_MEMBERS_CTORS_1ST");
   if (sortConstructorsFirst) {
     int ord1 = c1->isConstructor() ? 2 : (c1->isDestructor() ? 1 : 0);
     int ord2 = c2->isConstructor() ? 2 : (c2->isDestructor() ? 1 : 0);
     if (ord1 > ord2)
       return -1;
     else if (ord2 > ord1)
       return 1;
   }
   int cmp = qstricmp(c1->name(),c2->name());
   return cmp!=0 ? cmp : c1->getDefLine()-c2->getDefLine();
 }

void MemberList::countDecMembers	(	bool	countEnumValues = `FALSE`,
		GroupDef *	gd = `0`
	)

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

Definition at line 136 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_protoCnt=m_defCnt=m_friendCnt=0;
   m_numDecMembers=0;
   QListIterator<MemberDef> mli(*this);
   MemberDef *md;
   for (mli.toFirst();(md=mli.current());++mli)
   {
     //printf("MemberList::countDecMembers(md=%s,%d)\n",md->name().data(),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:   if (countEnumValues)
                                        m_enumValCnt++,m_numDecMembers++; 
                                      break;
         case MemberType_Typedef:     m_typeCnt++,m_numDecMembers++; break;
         //case MemberType_Prototype:   m_protoCnt++,m_numDecMembers++; break;
         case MemberType_Define:      if (Config_getBool("EXTRACT_ALL") || 
                                          md->argsString() || 
                                          !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!",md->name().data());
       }
     }
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->countDecMembers(gd);
       m_varCnt+=mg->varCount();
       m_funcCnt+=mg->funcCount();
       m_enumCnt+=mg->enumCount();
       m_enumValCnt+=mg->enumValueCount();
       m_typeCnt+=mg->typedefCount();
       m_protoCnt+=mg->protoCount();
       m_defCnt+=mg->defineCount();
       m_friendCnt+=mg->friendCount();
       m_numDecMembers+=mg->numDecMembers();
     }
   }
   //printf("----- end countDecMembers ----\n");
 
   //printf("MemberList::countDecMembers()=%d\n",m_numDecMembers);
 }

void MemberList::countDocMembers ( bool countEnumValues = FALSE )

Definition at line 208 of file memberlist.cpp.

 {
   if (m_numDocMembers!=-1) return; // used cached value
   m_numDocMembers=0;
   QListIterator<MemberDef> mli(*this);
   MemberDef *md;
   for (mli.toFirst();(md=mli.current());++mli)
   {
     if (md->isDetailedSectionVisible(m_inGroup,m_inFile)) 
     {
       // do not count enum values, since they do not produce entries of their own
       if (countEnumValues || md->memberType()!=MemberType_EnumValue) 
         m_numDocMembers++;
     }
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->countDocMembers();
       m_numDocMembers+=mg->numDocMembers();
     }
   }
   //printf("MemberList::countDocMembers()=%d memberGroupList=%p\n",m_numDocMembers,memberGroupList);
 }

int MemberList::countInheritableMembers ( ClassDef * inheritedFrom ) const

Definition at line 92 of file memberlist.cpp.

 {
   int count=0;
   QListIterator<MemberDef> mli(*this);
   MemberDef *md;
   for (mli.toFirst();(md=mli.current());++mli)
   {
     if (md->isBriefSectionVisible())
     {
       if (md->memberType()!=MemberType_Friend &&
           md->memberType()!=MemberType_EnumValue)
       {
         //printf("member %s: isReimplementedBy(%s)=%d\n",md->name().data(),
         //    inheritedFrom->name().data(),
         //    md->isReimplementedBy(inheritedFrom));
         if (md->memberType()==MemberType_Function)
         {
           if (!md->isReimplementedBy(inheritedFrom)) count++;
         }
         else
         {
           count++;
         }
       }
     }
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       count+=mg->countInheritableMembers(inheritedFrom);
     }
   }
   //printf("%s::countInheritableMembers(%s)=%d\n",
   //    listTypeAsString().data(),
   //    inheritedFrom->name().data(),count);
   return count;
 }

bool MemberList::declVisible ( ) const

Definition at line 256 of file memberlist.cpp.

 {
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()); ++mli )
   {
     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_Event:  
           return TRUE;
         case MemberType_Enumeration: 
           {
             int enumVars=0;
             MemberListIterator vmli(*this);
             MemberDef *vmd;
             QCString name(md->name());
             int i=name.findRev("::");
             if (i!=-1) name=name.right(name.length()-i-2); // strip scope (TODO: is this needed?)
             if (name[0]=='@') // anonymous enum => append variables
             {
               for ( ; (vmd=vmli.current()) ; ++vmli)
               {
                 QCString vtype=vmd->typeString();
                 if ((vtype.find(name))!=-1) 
                 {
                   enumVars++;
                 }
               }
             }
             // 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 (enumVars==0) // show enum here
             {
               return TRUE;
             }
           }
           break;
         case MemberType_Friend:
           return TRUE;
         case MemberType_EnumValue: 
           {
             if (m_inGroup)
             {
               return TRUE;
             }
           }
           break;
       }
     }
   }
   return FALSE;
 }

int MemberList::defineCount ( ) const

inline

Definition at line 49 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

MemberList::m_defCnt

int m_defCnt

Definition: memberlist.h:91

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

int MemberList::enumCount ( ) const

inline

Definition at line 45 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

MemberList::m_enumCnt

int m_enumCnt

Definition: memberlist.h:87

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

int MemberList::enumValueCount ( ) const

inline

Definition at line 46 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

MemberList::m_enumValCnt

int m_enumValCnt

Definition: memberlist.h:88

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

void MemberList::findSectionsInDocumentation ( )

Definition at line 818 of file memberlist.cpp.

 {
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     md->findSectionsInDocumentation();
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->findSectionsInDocumentation();
     }
   }
 }

int MemberList::friendCount ( ) const

inline

Definition at line 50 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

MemberList::m_friendCnt

int m_friendCnt

Definition: memberlist.h:92

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

int MemberList::funcCount ( ) const

inline

Definition at line 44 of file memberlist.h.

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

MemberList::m_funcCnt

int m_funcCnt

Definition: memberlist.h:86

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

MemberGroupList* MemberList::getMemberGroupList ( ) const

inline

Definition at line 78 of file memberlist.h.

78 { return memberGroupList; }

MemberList::memberGroupList

MemberGroupList * memberGroupList

Definition: memberlist.h:95

bool MemberList::insert	(	uint	index,
		const MemberDef *	md
	)

Definition at line 236 of file memberlist.cpp.

 {
   return QList<MemberDef>::insert(index,md);
 }

void MemberList::inSort ( const MemberDef * md )

Definition at line 241 of file memberlist.cpp.

 {
   QList<MemberDef>::inSort(md);
 }

MemberListType MemberList::listType ( ) const

inline

Definition at line 38 of file memberlist.h.

38 { return m_listType; }

MemberList::m_listType

MemberListType m_listType

Definition: memberlist.h:98

QCString MemberList::listTypeAsString ( MemberListType type )

static

Definition at line 907 of file memberlist.cpp.

 {
   switch(type)
   {
     case MemberListType_pubMethods: return "pub-methods";
     case MemberListType_proMethods: return "pro-methods";
     case MemberListType_pacMethods: return "pac-methods";
     case MemberListType_priMethods: return "pri-methods";
     case MemberListType_pubStaticMethods: return "pub-static-methods";
     case MemberListType_proStaticMethods: return "pro-static-methods";
     case MemberListType_pacStaticMethods: return "pac-static-methods";
     case MemberListType_priStaticMethods: return "pri-static-methods";
     case MemberListType_pubSlots: return "pub-slots";
     case MemberListType_proSlots: return "pro-slots";
     case MemberListType_priSlots: return "pri-slots";
     case MemberListType_pubAttribs: return "pub-attribs";
     case MemberListType_proAttribs: return "pro-attribs";
     case MemberListType_pacAttribs: return "pac-attribs";
     case MemberListType_priAttribs: return "pri-attribs";
     case MemberListType_pubStaticAttribs: return "pub-static-attribs";
     case MemberListType_proStaticAttribs: return "pro-static-attribs";
     case MemberListType_pacStaticAttribs: return "pac-static-attribs";
     case MemberListType_priStaticAttribs: return "pri-static-attribs";
     case MemberListType_pubTypes: return "pub-types";
     case MemberListType_proTypes: return "pro-types";
     case MemberListType_pacTypes: return "pac-types";
     case MemberListType_priTypes: return "pri-types";
     case MemberListType_related: return "related";
     case MemberListType_signals: return "signals";
     case MemberListType_friends: return "friends";
     case MemberListType_dcopMethods: return "dcop-methods";
     case MemberListType_properties: return "properties";
     case MemberListType_events: return "events";
     case MemberListType_interfaces: return "interfaces";
     case MemberListType_services: return "services";
     case MemberListType_decDefineMembers: return "define-members";
     case MemberListType_decProtoMembers: return "proto-members";
     case MemberListType_decTypedefMembers: return "typedef-members";
     case MemberListType_decEnumMembers: return "enum-members";
     case MemberListType_decFuncMembers: return "func-members";
     case MemberListType_decVarMembers: return "var-members";
     case MemberListType_decEnumValMembers: return "enumval-members";
     case MemberListType_decPubSlotMembers: return "pub-slot-members";
     case MemberListType_decProSlotMembers: return "pro-slot-members";
     case MemberListType_decPriSlotMembers: return "pri-slot-members";
     case MemberListType_decSignalMembers: return "signal-members";
     case MemberListType_decEventMembers: return "event-members";
     case MemberListType_decFriendMembers: return "friend-members";
     case MemberListType_decPropMembers: return "prop-members";
     case MemberListType_enumFields: return "enum-fields";
     case MemberListType_memberGroup: return "member-group";
     default: break;
   }
   return "";
 }

void MemberList::marshal ( StorageIntf * s )

Definition at line 837 of file memberlist.cpp.

 {
   marshalInt(s,(int)m_listType);
   marshalInt(s,m_varCnt);
   marshalInt(s,m_funcCnt);
   marshalInt(s,m_enumCnt);
   marshalInt(s,m_enumValCnt);
   marshalInt(s,m_typeCnt);
   marshalInt(s,m_protoCnt);
   marshalInt(s,m_defCnt);
   marshalInt(s,m_friendCnt); 
   marshalInt(s,m_numDecMembers);
   marshalInt(s,m_numDocMembers);
   marshalBool(s,m_inGroup);
   marshalBool(s,m_inFile);
   marshalBool(s,m_needsSorting);
   if (memberGroupList==0)
   {
     marshalUInt(s,NULL_LIST); // null pointer representation
   }
   else
   {
     marshalUInt(s,memberGroupList->count());
     QListIterator<MemberGroup> mgi(*memberGroupList);
     MemberGroup *mg=0;
     for (mgi.toFirst();(mg=mgi.current());++mgi)
     {
       mg->marshal(s);
     }
   }
 }

bool MemberList::needsSorting ( ) const

inline

Definition at line 53 of file memberlist.h.

53 { return m_needsSorting; }

MemberList::m_needsSorting

bool m_needsSorting

Definition: memberlist.h:99

int MemberList::numDecMembers ( ) const

inline

Definition at line 51 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

int MemberList::numDocMembers ( ) const

inline

Definition at line 52 of file memberlist.h.

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

MemberList::m_numDocMembers

int m_numDocMembers

Definition: memberlist.h:94

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

int MemberList::protoCount ( ) const

inline

Definition at line 48 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

MemberList::m_protoCnt

int m_protoCnt

Definition: memberlist.h:90

void MemberList::setInFile ( bool inFile )

inline

Definition at line 74 of file memberlist.h.

74 { m_inFile=inFile; }

MemberList::m_inFile

bool m_inFile

Definition: memberlist.h:97

inFile

TFile * inFile

Definition: makeDST.cxx:36

void MemberList::setInGroup ( bool inGroup )

inline

Definition at line 73 of file memberlist.h.

73 { m_inGroup=inGroup; }

MemberList::m_inGroup

bool m_inGroup

Definition: memberlist.h:96

void MemberList::setNeedsSorting ( bool b )

Definition at line 902 of file memberlist.cpp.

 {
   m_needsSorting = b;
 }

int MemberList::typedefCount ( ) const

inline

Definition at line 47 of file memberlist.h.

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

MemberList::m_typeCnt

int m_typeCnt

Definition: memberlist.h:89

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

void MemberList::unmarshal ( StorageIntf * s )

Definition at line 869 of file memberlist.cpp.

 {
   m_listType       = (MemberListType)unmarshalInt(s);
   m_varCnt         = unmarshalInt(s);
   m_funcCnt        = unmarshalInt(s);
   m_enumCnt        = unmarshalInt(s);
   m_enumValCnt     = unmarshalInt(s);
   m_typeCnt        = unmarshalInt(s);
   m_protoCnt       = unmarshalInt(s);
   m_defCnt         = unmarshalInt(s);
   m_friendCnt      = unmarshalInt(s); 
   m_numDecMembers  = unmarshalInt(s);
   m_numDocMembers  = unmarshalInt(s);
   m_inGroup        = unmarshalBool(s);
   m_inFile         = unmarshalBool(s);
   m_needsSorting   = unmarshalBool(s);
   uint i,count     = unmarshalUInt(s); 
   if (count==NULL_LIST) // empty list
   {
     memberGroupList = 0;
   }
   else // add member groups
   {
     memberGroupList = new MemberGroupList;
     for (i=0;i<count;i++)
     {
       MemberGroup *mg = new MemberGroup;
       mg->unmarshal(s);
       memberGroupList->append(mg);
     }
   }
 }

int MemberList::varCount ( ) const

inline

Definition at line 43 of file memberlist.h.

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

MemberList::m_numDecMembers

int m_numDecMembers

Definition: memberlist.h:93

ASSERT

#define ASSERT(x)

Definition: qglobal.h:590

MemberList::m_varCnt

int m_varCnt

Definition: memberlist.h:85

void MemberList::writeDeclarations	(	OutputList &	ol,
		ClassDef *	cd,
		NamespaceDef *	nd,
		FileDef *	fd,
		GroupDef *	gd,
		const char *	title,
		const char *	subtitle,
		bool	showEnumValues = `FALSE`,
		bool	showInline = `FALSE`,
		ClassDef *	inheritedFrom = `0`,
		MemberListType	lt = `MemberListType_pubMethods`
	)

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.
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.

Definition at line 519 of file memberlist.cpp.

 {
   (void)showEnumValues; // unused
 
   //printf("----- writeDeclaration() this=%p ---- inheritedFrom=%p\n",this,inheritedFrom);
   static bool optimizeVhdl = Config_getBool("OPTIMIZE_OUTPUT_VHDL");
   QCString inheritId;
 
   countDecMembers(/*showEnumValues*/FALSE,gd); // count members shown in this section
   Definition *ctx = cd;
   if (ctx==0 && nd) ctx = nd;
   if (ctx==0 && gd) ctx = gd;
   if (ctx==0 && fd) ctx = fd;
 
   //printf("%p: MemberList::writeDeclaration(title=`%s',subtitle=`%s')=%d inheritedFrom=%p\n",
   //       this,title,subtitle,numDecMembers(),inheritedFrom);
 
   int num = numDecMembers();
   if (inheritedFrom)
   {
     //if ( cd && !optimizeVhdl && countInheritableMembers(inheritedFrom)>0 )
     if ( cd && !optimizeVhdl && cd->countMembersIncludingGrouped(
                                       m_listType,inheritedFrom,TRUE)>0 )
     {
       ol.pushGeneratorState();
       ol.disableAllBut(OutputGenerator::Html);
       inheritId = substitute(listTypeAsString(lt),"-","_")+"_"+
                   stripPath(cd->getOutputFileBase());
       if (title)
       {
         ol.writeInheritedSectionTitle(inheritId,cd->getReference(),
                                       cd->getOutputFileBase(), 
                                       cd->anchor(),title,cd->displayName());
       }
       ol.popGeneratorState();
     }
   }
   else if (num>0)
   {
     if (title) 
     {
       if (showInline)
       {
         ol.startInlineHeader();
       }
       else
       {
         ol.startMemberHeader(listTypeAsString(m_listType));
       }
       ol.parseText(title);
       if (showInline)
       {
         ol.endInlineHeader();
       }
       else
       {
         ol.endMemberHeader();
       }
     }
     if (subtitle) 
     {
       QCString st=subtitle;
       st = st.stripWhiteSpace();
       if (!st.isEmpty())
       {
         ol.startMemberSubtitle();
         ol.generateDoc("[generated]",-1,ctx,0,subtitle,FALSE,FALSE,0,FALSE,FALSE);
         ol.endMemberSubtitle();
       }
     }
   }
   if (num>0)
   {
     // 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,0,cd,0,0);
     }
     else
     {
       writePlainDeclarations(ol,cd,nd,fd,gd,inheritedFrom,inheritId);
     }
 
     //printf("memberGroupList=%p\n",memberGroupList);
     if (memberGroupList)
     {
       MemberGroupListIterator mgli(*memberGroupList);
       MemberGroup *mg;
       while ((mg=mgli.current()))
       {
         bool hasHeader=!mg->header().isEmpty() && mg->header()!="[NOHEADER]";
         if (inheritId.isEmpty())
         {
           //printf("mg->header=%s hasHeader=%d\n",mg->header().data(),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(),ctx,0,mg->documentation()+"\n",FALSE,FALSE);
             ol.endMemberGroupDocs();
           }
           ol.startMemberGroup();
         }
         //printf("--- mg->writePlainDeclarations ---\n");
         mg->writePlainDeclarations(ol,cd,nd,fd,gd,inheritedFrom,inheritId);
         if (inheritId.isEmpty())
         {
           ol.endMemberGroup(hasHeader);
         }
         ++mgli;
       }
     }
   }
   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");
 }

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

Definition at line 655 of file memberlist.cpp.

 {
   //printf("MemberList::writeDocumentation()\n");
 
   countDocMembers(showEnumValues);
   if (numDocMembers()==0) return;
 
   if (title)
   {
     ol.pushGeneratorState();
       ol.disable(OutputGenerator::Html);
       ol.writeRuler();
     ol.popGeneratorState();
     ol.startGroupHeader(showInline ? 2 : 0);
     ol.parseText(title);
     ol.endGroupHeader(showInline ? 2 : 0);
   }
   ol.startMemberDocList();
   
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     md->writeDocumentation(this,ol,scopeName,container,
                            m_inGroup,showEnumValues,showInline);
   }
   if (memberGroupList)
   {
     printf("MemberList::writeDocumentation()  --  member groups %d\n",memberGroupList->count());
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->writeDocumentation(ol,scopeName,container,showEnumValues,showInline);
     }
   }
   ol.endMemberDocList();
 }

void MemberList::writeDocumentationPage	(	OutputList &	ol,
		const char *	scopeName,
		Definition *	container
	)

Definition at line 715 of file memberlist.cpp.

 {
   static bool generateTreeView = Config_getBool("GENERATE_TREEVIEW");
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     if (md->isDetailedSectionLinkable())
     {
       QCString diskName=md->getOutputFileBase();
       QCString title=md->qualifiedName();
       startFile(ol,diskName,md->name(),title,HLI_None,!generateTreeView,diskName);
       if (!generateTreeView)
       {
         container->writeNavigationPath(ol);
         ol.endQuickIndices();
       }
       ol.startContents();
 
       if (generateTreeView)
       {
         md->writeDocumentation(this,ol,scopeName,container,m_inGroup);
         ol.endContents();
         endFileWithNavPath(container,ol);
       }
       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,ol,scopeName,container,m_inGroup);
 
         ol.writeString("    </td>\n");
         ol.writeString("  </tr>\n");
         ol.writeString("</table>\n");
 
         endFile(ol);
       }
     }
     if (memberGroupList)
     {
       //printf("MemberList::writeDocumentation()  --  member groups\n");
       MemberGroupListIterator mgli(*memberGroupList);
       MemberGroup *mg;
       for (;(mg=mgli.current());++mgli)
       {
         mg->writeDocumentationPage(ol,scopeName,container);
       }
     }
   }
 }

void MemberList::writePlainDeclarations	(	OutputList &	ol,
		ClassDef *	cd,
		NamespaceDef *	nd,
		FileDef *	fd,
		GroupDef *	gd,
		ClassDef *	inheritedFrom,
		const char *	inheritId
	)

Definition at line 321 of file memberlist.cpp.

 {
   //printf("----- writePlainDeclaration() ----\n");
   static bool hideUndocMembers = Config_getBool("HIDE_UNDOC_MEMBERS");
   countDecMembers();
   if (numDecMembers()==0) 
   {
     //printf("  --> no members!\n");
     return; // no members in this list
   }
   //printf("  --> writePlainDeclaration() numDecMembers()=%d\n",
   //    numDecMembers());
   
   ol.pushGeneratorState();
 
   bool first=TRUE;
   MemberDef *md;
   MemberListIterator mli(*this);
   for ( ; (md=mli.current()); ++mli )
   {
     //printf(">>> Member `%s' type=%d visible=%d\n",
     //    md->name().data(),md->memberType(),md->isBriefSectionVisible());
     if ((inheritedFrom==0 || !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_Event:  
           {
             if (first) ol.startMemberList(),first=FALSE;
             md->writeDeclaration(ol,cd,nd,fd,gd,m_inGroup,inheritedFrom,inheritId);
             break;
           }
         case MemberType_Enumeration: 
           {
             int enumVars=0;
             MemberListIterator vmli(*this);
             MemberDef *vmd;
             QCString name(md->name());
             int i=name.findRev("::");
             if (i!=-1) name=name.right(name.length()-i-2); // strip scope (TODO: is this needed?)
             if (name[0]=='@') // anonymous enum => append variables
             {
               for ( ; (vmd=vmli.current()) ; ++vmli)
               {
                 QCString vtype=vmd->typeString();
                 if ((vtype.find(name))!=-1) 
                 {
                   enumVars++;
                   vmd->setAnonymousEnumType(md);
                 }
               }
             }
             // 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 (enumVars==0 && !hideUndocMembers) // show enum here
             {
               //printf("Enum!!\n");
               if (first)
               {
                 ol.startMemberList();
                 first=FALSE;
               }
               ol.startMemberDeclaration();
               ol.startMemberItem(md->anchor(),0,inheritId);
               bool detailsLinkable = md->isDetailedSectionLinkable();
               if (!detailsLinkable)
               {
                 ol.startDoxyAnchor(md->getOutputFileBase(),0,md->anchor(),md->name(),QCString());
               }
               ol.writeString("enum ");
               ol.insertMemberAlign();
               md->writeEnumDeclaration(ol,cd,nd,fd,gd);
               if (!detailsLinkable)
               {
                 ol.endDoxyAnchor(md->getOutputFileBase(),md->anchor());
               }
               if (!md->briefDescription().isEmpty() && Config_getBool("BRIEF_MEMBER_DESC"))
               {
                 DocRoot *rootNode = validatingParseDoc(
                     md->briefFile(),md->briefLine(),
                     cd,md,
                     md->briefDescription(),
                     TRUE,FALSE,0,TRUE,FALSE
                     );
                 if (rootNode && !rootNode->isEmpty())
                 {
                   ol.startMemberDescription(md->anchor());
                   ol.writeDoc(rootNode,cd,md);
                   if (md->isDetailedSectionLinkable())
                   {
                     ol.disableAllBut(OutputGenerator::Html);
                     ol.docify(" ");
                     ol.startTextLink(md->getOutputFileBase(),
                         md->anchor());
                     ol.parseText(theTranslator->trMore());
                     ol.endTextLink();
                     ol.enableAll();
                   }
                   ol.endMemberDescription();
                 }
                 delete rootNode;
               }
               ol.endMemberItem();
               ol.endMemberDeclaration(md->anchor(),inheritId);
             }
             md->warnIfUndocumented();
             break;
           }
         case MemberType_Friend:
           if (inheritedFrom==0)
           {
             if (first) 
             {
               ol.startMemberList();
               first=FALSE;
             }
             md->writeDeclaration(ol,cd,nd,fd,gd,m_inGroup,inheritedFrom,inheritId);
             break;
           }
         case MemberType_EnumValue: 
           {
             if (m_inGroup)
             {
               //printf("EnumValue!\n");
               if (first) ol.startMemberList(),first=FALSE;
               md->writeDeclaration(ol,cd,nd,fd,gd,m_inGroup,inheritedFrom,inheritId);
             }
           }
           break;
       }
     }
   }
 
   // handle members that are inside anonymous compounds and for which
   // no variables of the anonymous compound type exist.
   if (cd)
   {
     MemberListIterator mli(*this);
     for  ( ; (md=mli.current()) ; ++mli )
     {
       if (md->fromAnonymousScope() && !md->anonymousDeclShown())
       {
         md->setFromAnonymousScope(FALSE);
         //printf("anonymous compound members\n");
         if (md->isBriefSectionVisible())
         {
           if (first) 
           {
             ol.startMemberList();
             first=FALSE;
           }
           md->writeDeclaration(ol,cd,nd,fd,gd,m_inGroup);
         }
         md->setFromAnonymousScope(TRUE);
       }
     }
   }
  
   if (!first) 
   {
     ol.endMemberList(); 
   }
 
   ol.popGeneratorState();
   //printf("----- end writePlainDeclaration() ----\n");
 }

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

Definition at line 697 of file memberlist.cpp.

 {
   countDocMembers(FALSE);
   //printf("MemberList count=%d\n",numDocMembers());
   if (numDocMembers()==0) return;
 
   ol.startMemberDocSimple();
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     md->writeMemberDocSimple(ol,container);
   }
   ol.endMemberDocSimple();
 }

void MemberList::writeTagFile ( FTextStream & tagFile )

Definition at line 963 of file memberlist.cpp.

 {
   MemberListIterator mli(*this);
   MemberDef *md;
   for ( ; (md=mli.current()) ; ++mli)
   {
     if (md->getLanguage()!=SrcLangExt_VHDL)
     {
       md->writeTagFile(tagFile);
       if (md->memberType()==MemberType_Enumeration && md->enumFieldList() && !md->isStrong())
       {
         MemberListIterator vmli(*md->enumFieldList());
         MemberDef *vmd;
         for ( ; (vmd=vmli.current()) ; ++vmli)
         {
           vmd->writeTagFile(tagFile);
         }
       }
     }
     else
     {
       VhdlDocGen::writeTagFile(md,tagFile);
     }
   }
   if (memberGroupList)
   {
     MemberGroupListIterator mgli(*memberGroupList);
     MemberGroup *mg;
     for (;(mg=mgli.current());++mgli)
     {
       mg->writeTagFile(tagFile);
     }
   }
 }

Member Data Documentation

int MemberList::m_defCnt

private

Definition at line 91 of file memberlist.h.

int MemberList::m_enumCnt

private

Definition at line 87 of file memberlist.h.

int MemberList::m_enumValCnt

private

Definition at line 88 of file memberlist.h.

int MemberList::m_friendCnt

private

Definition at line 92 of file memberlist.h.

int MemberList::m_funcCnt

private

Definition at line 86 of file memberlist.h.

bool MemberList::m_inFile

private

Definition at line 97 of file memberlist.h.

bool MemberList::m_inGroup

private

Definition at line 96 of file memberlist.h.

MemberListType MemberList::m_listType

private

Definition at line 98 of file memberlist.h.

bool MemberList::m_needsSorting

private

Definition at line 99 of file memberlist.h.

int MemberList::m_numDecMembers

private

Definition at line 93 of file memberlist.h.

int MemberList::m_numDocMembers

private

Definition at line 94 of file memberlist.h.

int MemberList::m_protoCnt

private

Definition at line 90 of file memberlist.h.

int MemberList::m_typeCnt

private

Definition at line 89 of file memberlist.h.

int MemberList::m_varCnt

private

Definition at line 85 of file memberlist.h.

MemberGroupList* MemberList::memberGroupList

private

Definition at line 95 of file memberlist.h.

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

doxygen-1.8.11/src/memberlist.h
doxygen-1.8.11/src/memberlist.cpp

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation