issue doxygen#11624 Classes always ordered alphabetically

doxygen · doxygen · commit 9cb220d11457 · 2025-07-09T21:35:02.000+02:00
diff --git a/src/classdef.cpp b/src/classdef.cpp
@@ -4611,14 +4611,17 @@ void ClassDefImpl::sortMemberLists()
   {
     if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
   }
-  std::stable_sort(m_innerClasses.begin(),
-            m_innerClasses.end(),
-            [](const auto &c1,const auto &c2)
-            {
-               return Config_getBool(SORT_BY_SCOPE_NAME)                ?
-                      qstricmp_sort(c1->name(),      c2->name()     )<0 :
-                      qstricmp_sort(c1->className(), c2->className())<0 ;
-            });
+  if (Config_getBool(SORT_BRIEF_DOCS))
+  {
+    std::stable_sort(m_innerClasses.begin(),
+              m_innerClasses.end(),
+              [](const auto &c1,const auto &c2)
+              {
+                 return Config_getBool(SORT_BY_SCOPE_NAME)                ?
+                        qstricmp_sort(c1->name(),      c2->name()     )<0 :
+                        qstricmp_sort(c1->className(), c2->className())<0 ;
+              });
+  }
 }
 
 int ClassDefImpl::countMemberDeclarations(MemberListType lt,const ClassDef *inheritedFrom,
diff --git a/src/filedef.cpp b/src/filedef.cpp
@@ -1774,6 +1774,13 @@ void FileDefImpl::sortMemberLists()
     std::stable_sort(m_structs.begin(),   m_structs.end(),   classComp);
     std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);
 
+    auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
+    {
+      return qstricmp_sort(c1->name(),c2->name())<0;
+    };
+
+    std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
+
     auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
     {
       return qstricmp_sort(n1->name(),n2->name())<0;
diff --git a/src/groupdef.cpp b/src/groupdef.cpp
@@ -1867,6 +1867,24 @@ void GroupDefImpl::sortMemberLists()
     };
 
     std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);
+
+    auto moduleComp = [](const ModuleLinkedRefMap::Ptr &m1,const ModuleLinkedRefMap::Ptr &m2)
+    {
+      return qstricmp_sort(m1->name(),m2->name())<0;
+    };
+
+    std::stable_sort(m_modules.begin(), m_modules.end(), moduleComp);
+
+    auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
+    {
+      return qstricmp_sort(c1->name(),c2->name())<0;
+    };
+
+    std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
+
+    std::stable_sort(m_dirList.begin(), m_dirList.end(), compareDirDefs);
+    std::stable_sort(m_fileList.begin(), m_fileList.end(), compareFileDefs);
+
   }
   else
   {
@@ -1917,10 +1935,13 @@ void GroupDefImpl::removeMemberFromList(MemberListType lt,MemberDef *md)
 
 void GroupDefImpl::sortSubGroups()
 {
-  std::stable_sort(m_groups.begin(),
-            m_groups.end(),
-            [](const auto &g1,const auto &g2)
-            { return g1->groupTitle() < g2->groupTitle(); });
+  if (Config_getBool(SORT_BRIEF_DOCS))
+  {
+    std::stable_sort(m_groups.begin(),
+              m_groups.end(),
+              [](const auto &g1,const auto &g2)
+              { return g1->groupTitle() < g2->groupTitle(); });
+  }
 }
 
 static bool hasNonReferenceNestedGroupRec(const GroupDef *gd,int level)
diff --git a/src/namespacedef.cpp b/src/namespacedef.cpp
@@ -108,11 +108,11 @@ class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>
     const MemberLists &getMemberLists() const override { return m_memberLists; }
     const MemberDef *getMemberByName(const QCString &) const override;
     const MemberGroupList &getMemberGroups() const override { return m_memberGroups; }
-    ClassLinkedRefMap getClasses() const override { return classes; }
-    ClassLinkedRefMap getInterfaces() const override { return interfaces; }
-    ClassLinkedRefMap getStructs() const override { return structs; }
-    ClassLinkedRefMap getExceptions() const override { return exceptions; }
-    NamespaceLinkedRefMap getNamespaces() const override { return namespaces; }
+    ClassLinkedRefMap getClasses() const override { return m_classes; }
+    ClassLinkedRefMap getInterfaces() const override { return m_interfaces; }
+    ClassLinkedRefMap getStructs() const override { return m_structs; }
+    ClassLinkedRefMap getExceptions() const override { return m_exceptions; }
+    NamespaceLinkedRefMap getNamespaces() const override { return m_namespaces; }
     ConceptLinkedRefMap getConcepts() const override { return m_concepts; }
     void setName(const QCString &name) override;
 
@@ -158,12 +158,12 @@ class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>
     MemberLinkedRefMap    m_allMembers;
     MemberLists           m_memberLists;
     MemberGroupList       m_memberGroups;
-    ClassLinkedRefMap     classes;
-    ClassLinkedRefMap     interfaces;
-    ClassLinkedRefMap     structs;
-    ClassLinkedRefMap     exceptions;
+    ClassLinkedRefMap     m_classes;
+    ClassLinkedRefMap     m_interfaces;
+    ClassLinkedRefMap     m_structs;
+    ClassLinkedRefMap     m_exceptions;
     ConceptLinkedRefMap   m_concepts;
-    NamespaceLinkedRefMap namespaces;
+    NamespaceLinkedRefMap m_namespaces;
     bool                  m_subGrouping = false;
     enum { NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY } m_type;
     bool m_isPublished = false;
@@ -409,21 +409,21 @@ void NamespaceDefImpl::addInnerCompound(Definition *d)
 
 void NamespaceDefImpl::insertClass(ClassDef *cd)
 {
-  ClassLinkedRefMap *d = &classes;
+  ClassLinkedRefMap *d = &m_classes;
 
   if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))
   {
     if (cd->compoundType()==ClassDef::Interface)
     {
-      d = &interfaces;
+      d = &m_interfaces;
     }
     else if (cd->compoundType()==ClassDef::Struct)
     {
-      d = &structs;
+      d = &m_structs;
     }
     else if (cd->compoundType()==ClassDef::Exception)
     {
-      d = &exceptions;
+      d = &m_exceptions;
     }
   }
 
@@ -437,7 +437,7 @@ void NamespaceDefImpl::insertConcept(ConceptDef *cd)
 
 void NamespaceDefImpl::insertNamespace(NamespaceDef *nd)
 {
-  namespaces.add(nd->name(),nd);
+  m_namespaces.add(nd->name(),nd);
 }
 
 
@@ -617,7 +617,7 @@ void NamespaceDefImpl::writeTagFile(TextStream &tagFile)
     {
       case LayoutDocEntry::NamespaceNestedNamespaces:
         {
-          for (const auto &nd : namespaces)
+          for (const auto &nd : m_namespaces)
           {
             if (nd->isLinkableInProject())
             {
@@ -628,22 +628,22 @@ void NamespaceDefImpl::writeTagFile(TextStream &tagFile)
         break;
       case LayoutDocEntry::NamespaceClasses:
         {
-          writeClassesToTagFile(tagFile, classes);
+          writeClassesToTagFile(tagFile, m_classes);
         }
         break;
       case LayoutDocEntry::NamespaceInterfaces:
         {
-          writeClassesToTagFile(tagFile, interfaces);
+          writeClassesToTagFile(tagFile, m_interfaces);
         }
         break;
       case LayoutDocEntry::NamespaceStructs:
         {
-          writeClassesToTagFile(tagFile, structs);
+          writeClassesToTagFile(tagFile, m_structs);
         }
         break;
       case LayoutDocEntry::NamespaceExceptions:
         {
-          writeClassesToTagFile(tagFile, exceptions);
+          writeClassesToTagFile(tagFile, m_exceptions);
         }
         break;
       case LayoutDocEntry::NamespaceConcepts:
@@ -817,13 +817,13 @@ void NamespaceDefImpl::writeConcepts(OutputList &ol,const QCString &title)
 
 void NamespaceDefImpl::writeInlineClasses(OutputList &ol)
 {
-  classes.writeDocumentation(ol,this);
+  m_classes.writeDocumentation(ol,this);
 }
 
 void NamespaceDefImpl::writeNamespaceDeclarations(OutputList &ol,const QCString &title,
             bool const isConstantGroup)
 {
-  namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);
+  m_namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);
 }
 
 void NamespaceDefImpl::writeMemberGroups(OutputList &ol)
@@ -859,37 +859,37 @@ void NamespaceDefImpl::writeSummaryLinks(OutputList &ol) const
   for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))
   {
     const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
-    if (lde->kind()==LayoutDocEntry::NamespaceClasses && classes.declVisible() && ls)
+    if (lde->kind()==LayoutDocEntry::NamespaceClasses && m_classes.declVisible() && ls)
     {
       QCString label = "nested-classes";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
       first=FALSE;
     }
-    else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && interfaces.declVisible() && ls)
+    else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && m_interfaces.declVisible() && ls)
     {
       QCString label = "interfaces";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
       first=FALSE;
     }
-    else if (lde->kind()==LayoutDocEntry::NamespaceStructs && structs.declVisible() && ls)
+    else if (lde->kind()==LayoutDocEntry::NamespaceStructs && m_structs.declVisible() && ls)
     {
       QCString label = "structs";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
       first=FALSE;
     }
-    else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && exceptions.declVisible() && ls)
+    else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && m_exceptions.declVisible() && ls)
     {
       QCString label = "exceptions";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
       first=FALSE;
     }
-    else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && namespaces.declVisible(false) && ls)
+    else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && m_namespaces.declVisible(false) && ls)
     {
       QCString label = "namespaces";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
       first=FALSE;
     }
-    else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && namespaces.declVisible(true) && ls)
+    else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && m_namespaces.declVisible(true) && ls)
     {
       QCString label = "constantgroups";
       ol.writeSummaryLink(QCString(),label,ls->title(lang),first);
@@ -1014,22 +1014,22 @@ void NamespaceDefImpl::writeDocumentation(OutputList &ol)
         break;
       case LayoutDocEntry::NamespaceClasses:
         {
-          if (ls) writeClassDeclarations(ol,ls->title(lang),classes);
+          if (ls) writeClassDeclarations(ol,ls->title(lang),m_classes);
         }
         break;
       case LayoutDocEntry::NamespaceInterfaces:
         {
-          if (ls) writeClassDeclarations(ol,ls->title(lang),interfaces);
+          if (ls) writeClassDeclarations(ol,ls->title(lang),m_interfaces);
         }
         break;
       case LayoutDocEntry::NamespaceStructs:
         {
-          if (ls) writeClassDeclarations(ol,ls->title(lang),structs);
+          if (ls) writeClassDeclarations(ol,ls->title(lang),m_structs);
         }
         break;
       case LayoutDocEntry::NamespaceExceptions:
         {
-          if (ls) writeClassDeclarations(ol,ls->title(lang),exceptions);
+          if (ls) writeClassDeclarations(ol,ls->title(lang),m_exceptions);
         }
         break;
       case LayoutDocEntry::NamespaceConcepts:
@@ -1453,25 +1453,35 @@ void NamespaceDefImpl::sortMemberLists()
     if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
   }
 
-  auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
+  if (Config_getBool(SORT_BRIEF_DOCS))
   {
-    return Config_getBool(SORT_BY_SCOPE_NAME)          ?
-      qstricmp_sort(c1->name(), c2->name())<0          :
-      qstricmp_sort(c1->className(), c2->className())<0;
-  };
+    auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)
+    {
+      return Config_getBool(SORT_BY_SCOPE_NAME)          ?
+        qstricmp_sort(c1->name(), c2->name())<0          :
+        qstricmp_sort(c1->className(), c2->className())<0;
+    };
 
-  std::stable_sort(classes.begin(),   classes.end(),   classComp);
-  std::stable_sort(interfaces.begin(),interfaces.end(),classComp);
-  std::stable_sort(structs.begin(),   structs.end(),   classComp);
-  std::stable_sort(exceptions.begin(),exceptions.end(),classComp);
+    std::stable_sort(m_classes.begin(),   m_classes.end(),   classComp);
+    std::stable_sort(m_interfaces.begin(),m_interfaces.end(),classComp);
+    std::stable_sort(m_structs.begin(),   m_structs.end(),   classComp);
+    std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);
 
+    auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)
+    {
+      return qstricmp_sort(c1->name(),c2->name())<0;
+    };
 
-  auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
-  {
-    return qstricmp_sort(n1->name(),n2->name())<0;
-  };
+    std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);
+
+    auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)
+    {
+      return qstricmp_sort(n1->name(),n2->name())<0;
+    };
+
+    std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);
+  }
 
-  std::stable_sort(namespaces.begin(),namespaces.end(),namespaceComp);
 }
 
 MemberList *NamespaceDefImpl::getMemberList(MemberListType lt) const
diff --git a/testing/057/namespacelibrary.xml b/testing/057/namespacelibrary.xml
@@ -3,9 +3,9 @@
   <compounddef id="namespacelibrary" kind="namespace" language="C++">
     <compoundname>library</compoundname>
     <innerclass refid="classlibrary_1_1v2_1_1foo" prot="public">library::foo</innerclass>
-    <innernamespace refid="namespacelibrary_1_1v2_1_1_n_s">library::NS</innernamespace>
     <innernamespace refid="namespacelibrary_1_1v1">library::v1</innernamespace>
     <innernamespace refid="namespacelibrary_1_1v2" inline="yes">library::v2</innernamespace>
+    <innernamespace refid="namespacelibrary_1_1v2_1_1_n_s">library::NS</innernamespace>
     <sectiondef kind="func">
       <memberdef kind="function" id="namespacelibrary_1_1v2_1aba9375172f5b36e1f4fda9b1dec39d90" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
         <type>void</type>
diff --git a/testing/090/namespacemymodule.xml b/testing/090/namespacemymodule.xml
@@ -2,9 +2,9 @@
 <doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="" xml:lang="en-US">
   <compounddef id="namespacemymodule" kind="namespace" language="Fortran">
     <compoundname>mymodule</compoundname>
-    <innerclass refid="interfacemymodule_1_1abstractproc" prot="public">mymodule::abstractproc</innerclass>
     <innerclass refid="interfacemymodule_1_1externalproc" prot="public">mymodule::externalproc</innerclass>
     <innerclass refid="interfacemymodule_1_1genericproc" prot="public">mymodule::genericproc</innerclass>
+    <innerclass refid="interfacemymodule_1_1abstractproc" prot="public">mymodule::abstractproc</innerclass>
     <innerclass refid="interfacemymodule_1_1operator_07_8cross_8_08" prot="private">mymodule::operator(.cross.)</innerclass>
     <innerclass refid="interfacemymodule_1_1operator_07_2_2_08" prot="private">mymodule::operator(//)</innerclass>
     <sectiondef kind="func">
diff --git a/testing/092/namespacestrings.xml b/testing/092/namespacestrings.xml
@@ -2,18 +2,18 @@
 <doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="" xml:lang="en-US">
   <compounddef id="namespacestrings" kind="namespace" language="Fortran">
     <compoundname>strings</compoundname>
+    <innerclass refid="structstrings_1_1string" prot="public">strings::string</innerclass>
     <innerclass refid="interfacestrings_1_1append" prot="public">strings::append</innerclass>
     <innerclass refid="interfacestrings_1_1appendifunique" prot="public">strings::appendifunique</innerclass>
     <innerclass refid="interfacestrings_1_1find" prot="public">strings::find</innerclass>
+    <innerclass refid="interfacestrings_1_1operator_07_0a_0a_08" prot="public">strings::operator(==)</innerclass>
     <innerclass refid="interfacestrings_1_1grow" prot="public">strings::grow</innerclass>
     <innerclass refid="interfacestrings_1_1join" prot="public">strings::join</innerclass>
-    <innerclass refid="interfacestrings_1_1len" prot="public">strings::len</innerclass>
-    <innerclass refid="interfacestrings_1_1operator_07_0a_0a_08" prot="public">strings::operator(==)</innerclass>
     <innerclass refid="interfacestrings_1_1pack" prot="public">strings::pack</innerclass>
-    <innerclass refid="interfacestrings_1_1push" prot="private">strings::push</innerclass>
     <innerclass refid="interfacestrings_1_1replace" prot="public">strings::replace</innerclass>
     <innerclass refid="interfacestrings_1_1shrink" prot="public">strings::shrink</innerclass>
-    <innerclass refid="structstrings_1_1string" prot="public">strings::string</innerclass>
+    <innerclass refid="interfacestrings_1_1push" prot="private">strings::push</innerclass>
+    <innerclass refid="interfacestrings_1_1len" prot="public">strings::len</innerclass>
     <sectiondef kind="var">
       <memberdef kind="variable" id="namespacestrings_1a45584f6a9f6f13e5370bd883d744f0a6" prot="private" static="no" mutable="no">
         <type>integer, parameter</type>
diff --git a/testing/096/namespacem3.xml b/testing/096/namespacem3.xml
@@ -2,8 +2,8 @@
 <doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="" xml:lang="en-US">
   <compounddef id="namespacem3" kind="namespace" language="C++">
     <compoundname>m3</compoundname>
-    <innerclass refid="structm3_1_1t1" prot="public">m3::t1</innerclass>
     <innerclass refid="structm3_1_1t4" prot="public">m3::t4</innerclass>
+    <innerclass refid="structm3_1_1t1" prot="public">m3::t1</innerclass>
     <briefdescription>
     </briefdescription>
     <detaileddescription>
diff --git a/testing/105/namespaceitpp.xml b/testing/105/namespaceitpp.xml
@@ -2,8 +2,8 @@
 <doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="" xml:lang="en-US">
   <compounddef id="namespaceitpp" kind="namespace" language="C++">
     <compoundname>itpp</compoundname>
-    <innerclass refid="classitpp_1_1_c_fix" prot="public">itpp::CFix</innerclass>
     <innerclass refid="classitpp_1_1_vec" prot="public">itpp::Vec</innerclass>
+    <innerclass refid="classitpp_1_1_c_fix" prot="public">itpp::CFix</innerclass>
     <sectiondef kind="typedef">
       <memberdef kind="typedef" id="namespaceitpp_1a057e78df9719352a7a2ae36c0e190982" prot="public" static="no">
         <type><ref refid="classitpp_1_1_vec" kindref="compound">Vec</ref>&lt; <ref refid="classitpp_1_1_c_fix" kindref="compound">CFix</ref> &gt;</type>

Original file line number	Diff line number	Diff line change
`@@ -108,11 +108,11 @@ class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>`
`108`	`108`	`const MemberLists &getMemberLists() const override { return m_memberLists; }`
`109`	`109`	`const MemberDef *getMemberByName(const QCString &) const override;`
`110`	`110`	`const MemberGroupList &getMemberGroups() const override { return m_memberGroups; }`
`111`		`- ClassLinkedRefMap getClasses() const override { return classes; }`
`112`		`- ClassLinkedRefMap getInterfaces() const override { return interfaces; }`
`113`		`- ClassLinkedRefMap getStructs() const override { return structs; }`
`114`		`- ClassLinkedRefMap getExceptions() const override { return exceptions; }`
`115`		`- NamespaceLinkedRefMap getNamespaces() const override { return namespaces; }`
	`111`	`+ ClassLinkedRefMap getClasses() const override { return m_classes; }`
	`112`	`+ ClassLinkedRefMap getInterfaces() const override { return m_interfaces; }`
	`113`	`+ ClassLinkedRefMap getStructs() const override { return m_structs; }`
	`114`	`+ ClassLinkedRefMap getExceptions() const override { return m_exceptions; }`
	`115`	`+ NamespaceLinkedRefMap getNamespaces() const override { return m_namespaces; }`
`116`	`116`	`ConceptLinkedRefMap getConcepts() const override { return m_concepts; }`
`117`	`117`	`void setName(const QCString &name) override;`
`118`	`118`
`@@ -158,12 +158,12 @@ class NamespaceDefImpl : public DefinitionMixin<NamespaceDefMutable>`
`158`	`158`	`MemberLinkedRefMap m_allMembers;`
`159`	`159`	`MemberLists m_memberLists;`
`160`	`160`	`MemberGroupList m_memberGroups;`
`161`		`- ClassLinkedRefMap classes;`
`162`		`- ClassLinkedRefMap interfaces;`
`163`		`- ClassLinkedRefMap structs;`
`164`		`- ClassLinkedRefMap exceptions;`
	`161`	`+ ClassLinkedRefMap m_classes;`
	`162`	`+ ClassLinkedRefMap m_interfaces;`
	`163`	`+ ClassLinkedRefMap m_structs;`
	`164`	`+ ClassLinkedRefMap m_exceptions;`
`165`	`165`	`ConceptLinkedRefMap m_concepts;`
`166`		`- NamespaceLinkedRefMap namespaces;`
	`166`	`+ NamespaceLinkedRefMap m_namespaces;`
`167`	`167`	`bool m_subGrouping = false;`
`168`	`168`	`enum { NAMESPACE, MODULE, CONSTANT_GROUP, LIBRARY } m_type;`
`169`	`169`	`bool m_isPublished = false;`
`@@ -409,21 +409,21 @@ void NamespaceDefImpl::addInnerCompound(Definition *d)`
`409`	`409`
`410`	`410`	`void NamespaceDefImpl::insertClass(ClassDef *cd)`
`411`	`411`	`{`
`412`		`- ClassLinkedRefMap *d = &classes;`
	`412`	`+ ClassLinkedRefMap *d = &m_classes;`
`413`	`413`
`414`	`414`	`if (Config_getBool(OPTIMIZE_OUTPUT_SLICE))`
`415`	`415`	`{`
`416`	`416`	`if (cd->compoundType()==ClassDef::Interface)`
`417`	`417`	`{`
`418`		`- d = &interfaces;`
	`418`	`+ d = &m_interfaces;`
`419`	`419`	`}`
`420`	`420`	`else if (cd->compoundType()==ClassDef::Struct)`
`421`	`421`	`{`
`422`		`- d = &structs;`
	`422`	`+ d = &m_structs;`
`423`	`423`	`}`
`424`	`424`	`else if (cd->compoundType()==ClassDef::Exception)`
`425`	`425`	`{`
`426`		`- d = &exceptions;`
	`426`	`+ d = &m_exceptions;`
`427`	`427`	`}`
`428`	`428`	`}`
`429`	`429`
`@@ -437,7 +437,7 @@ void NamespaceDefImpl::insertConcept(ConceptDef *cd)`
`437`	`437`
`438`	`438`	`void NamespaceDefImpl::insertNamespace(NamespaceDef *nd)`
`439`	`439`	`{`
`440`		`- namespaces.add(nd->name(),nd);`
	`440`	`+ m_namespaces.add(nd->name(),nd);`
`441`	`441`	`}`
`442`	`442`
`443`	`443`
`@@ -617,7 +617,7 @@ void NamespaceDefImpl::writeTagFile(TextStream &tagFile)`
`617`	`617`	`{`
`618`	`618`	`case LayoutDocEntry::NamespaceNestedNamespaces:`
`619`	`619`	`{`
`620`		`- for (const auto &nd : namespaces)`
	`620`	`+ for (const auto &nd : m_namespaces)`
`621`	`621`	`{`
`622`	`622`	`if (nd->isLinkableInProject())`
`623`	`623`	`{`
`@@ -628,22 +628,22 @@ void NamespaceDefImpl::writeTagFile(TextStream &tagFile)`
`628`	`628`	`break;`
`629`	`629`	`case LayoutDocEntry::NamespaceClasses:`
`630`	`630`	`{`
`631`		`- writeClassesToTagFile(tagFile, classes);`
	`631`	`+ writeClassesToTagFile(tagFile, m_classes);`
`632`	`632`	`}`
`633`	`633`	`break;`
`634`	`634`	`case LayoutDocEntry::NamespaceInterfaces:`
`635`	`635`	`{`
`636`		`- writeClassesToTagFile(tagFile, interfaces);`
	`636`	`+ writeClassesToTagFile(tagFile, m_interfaces);`
`637`	`637`	`}`
`638`	`638`	`break;`
`639`	`639`	`case LayoutDocEntry::NamespaceStructs:`
`640`	`640`	`{`
`641`		`- writeClassesToTagFile(tagFile, structs);`
	`641`	`+ writeClassesToTagFile(tagFile, m_structs);`
`642`	`642`	`}`
`643`	`643`	`break;`
`644`	`644`	`case LayoutDocEntry::NamespaceExceptions:`
`645`	`645`	`{`
`646`		`- writeClassesToTagFile(tagFile, exceptions);`
	`646`	`+ writeClassesToTagFile(tagFile, m_exceptions);`
`647`	`647`	`}`
`648`	`648`	`break;`
`649`	`649`	`case LayoutDocEntry::NamespaceConcepts:`
`@@ -817,13 +817,13 @@ void NamespaceDefImpl::writeConcepts(OutputList &ol,const QCString &title)`
`817`	`817`
`818`	`818`	`void NamespaceDefImpl::writeInlineClasses(OutputList &ol)`
`819`	`819`	`{`
`820`		`- classes.writeDocumentation(ol,this);`
	`820`	`+ m_classes.writeDocumentation(ol,this);`
`821`	`821`	`}`
`822`	`822`
`823`	`823`	`void NamespaceDefImpl::writeNamespaceDeclarations(OutputList &ol,const QCString &title,`
`824`	`824`	`bool const isConstantGroup)`
`825`	`825`	`{`
`826`		`- namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);`
	`826`	`+ m_namespaces.writeDeclaration(ol,title,isConstantGroup,TRUE);`
`827`	`827`	`}`
`828`	`828`
`829`	`829`	`void NamespaceDefImpl::writeMemberGroups(OutputList &ol)`
`@@ -859,37 +859,37 @@ void NamespaceDefImpl::writeSummaryLinks(OutputList &ol) const`
`859`	`859`	`for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Namespace))`
`860`	`860`	`{`
`861`	`861`	`const LayoutDocEntrySection ls = dynamic_cast<const LayoutDocEntrySection>(lde.get());`
`862`		`- if (lde->kind()==LayoutDocEntry::NamespaceClasses && classes.declVisible() && ls)`
	`862`	`+ if (lde->kind()==LayoutDocEntry::NamespaceClasses && m_classes.declVisible() && ls)`
`863`	`863`	`{`
`864`	`864`	`QCString label = "nested-classes";`
`865`	`865`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`866`	`866`	`first=FALSE;`
`867`	`867`	`}`
`868`		`- else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && interfaces.declVisible() && ls)`
	`868`	`+ else if (lde->kind()==LayoutDocEntry::NamespaceInterfaces && m_interfaces.declVisible() && ls)`
`869`	`869`	`{`
`870`	`870`	`QCString label = "interfaces";`
`871`	`871`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`872`	`872`	`first=FALSE;`
`873`	`873`	`}`
`874`		`- else if (lde->kind()==LayoutDocEntry::NamespaceStructs && structs.declVisible() && ls)`
	`874`	`+ else if (lde->kind()==LayoutDocEntry::NamespaceStructs && m_structs.declVisible() && ls)`
`875`	`875`	`{`
`876`	`876`	`QCString label = "structs";`
`877`	`877`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`878`	`878`	`first=FALSE;`
`879`	`879`	`}`
`880`		`- else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && exceptions.declVisible() && ls)`
	`880`	`+ else if (lde->kind()==LayoutDocEntry::NamespaceExceptions && m_exceptions.declVisible() && ls)`
`881`	`881`	`{`
`882`	`882`	`QCString label = "exceptions";`
`883`	`883`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`884`	`884`	`first=FALSE;`
`885`	`885`	`}`
`886`		`- else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && namespaces.declVisible(false) && ls)`
	`886`	`+ else if (lde->kind()==LayoutDocEntry::NamespaceNestedNamespaces && m_namespaces.declVisible(false) && ls)`
`887`	`887`	`{`
`888`	`888`	`QCString label = "namespaces";`
`889`	`889`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`890`	`890`	`first=FALSE;`
`891`	`891`	`}`
`892`		`- else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && namespaces.declVisible(true) && ls)`
	`892`	`+ else if (lde->kind()==LayoutDocEntry::NamespaceNestedConstantGroups && m_namespaces.declVisible(true) && ls)`
`893`	`893`	`{`
`894`	`894`	`QCString label = "constantgroups";`
`895`	`895`	`ol.writeSummaryLink(QCString(),label,ls->title(lang),first);`
`@@ -1014,22 +1014,22 @@ void NamespaceDefImpl::writeDocumentation(OutputList &ol)`
`1014`	`1014`	`break;`
`1015`	`1015`	`case LayoutDocEntry::NamespaceClasses:`
`1016`	`1016`	`{`
`1017`		`- if (ls) writeClassDeclarations(ol,ls->title(lang),classes);`
	`1017`	`+ if (ls) writeClassDeclarations(ol,ls->title(lang),m_classes);`
`1018`	`1018`	`}`
`1019`	`1019`	`break;`
`1020`	`1020`	`case LayoutDocEntry::NamespaceInterfaces:`
`1021`	`1021`	`{`
`1022`		`- if (ls) writeClassDeclarations(ol,ls->title(lang),interfaces);`
	`1022`	`+ if (ls) writeClassDeclarations(ol,ls->title(lang),m_interfaces);`
`1023`	`1023`	`}`
`1024`	`1024`	`break;`
`1025`	`1025`	`case LayoutDocEntry::NamespaceStructs:`
`1026`	`1026`	`{`
`1027`		`- if (ls) writeClassDeclarations(ol,ls->title(lang),structs);`
	`1027`	`+ if (ls) writeClassDeclarations(ol,ls->title(lang),m_structs);`
`1028`	`1028`	`}`
`1029`	`1029`	`break;`
`1030`	`1030`	`case LayoutDocEntry::NamespaceExceptions:`
`1031`	`1031`	`{`
`1032`		`- if (ls) writeClassDeclarations(ol,ls->title(lang),exceptions);`
	`1032`	`+ if (ls) writeClassDeclarations(ol,ls->title(lang),m_exceptions);`
`1033`	`1033`	`}`
`1034`	`1034`	`break;`
`1035`	`1035`	`case LayoutDocEntry::NamespaceConcepts:`
`@@ -1453,25 +1453,35 @@ void NamespaceDefImpl::sortMemberLists()`
`1453`	`1453`	`if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }`
`1454`	`1454`	`}`
`1455`	`1455`
`1456`		`- auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)`
	`1456`	`+ if (Config_getBool(SORT_BRIEF_DOCS))`
`1457`	`1457`	`{`
`1458`		`- return Config_getBool(SORT_BY_SCOPE_NAME) ?`
`1459`		`- qstricmp_sort(c1->name(), c2->name())<0 :`
`1460`		`- qstricmp_sort(c1->className(), c2->className())<0;`
`1461`		`- };`
	`1458`	`+ auto classComp = [](const ClassLinkedRefMap::Ptr &c1,const ClassLinkedRefMap::Ptr &c2)`
	`1459`	`+ {`
	`1460`	`+ return Config_getBool(SORT_BY_SCOPE_NAME) ?`
	`1461`	`+ qstricmp_sort(c1->name(), c2->name())<0 :`
	`1462`	`+ qstricmp_sort(c1->className(), c2->className())<0;`
	`1463`	`+ };`
`1462`	`1464`
`1463`		`- std::stable_sort(classes.begin(), classes.end(), classComp);`
`1464`		`- std::stable_sort(interfaces.begin(),interfaces.end(),classComp);`
`1465`		`- std::stable_sort(structs.begin(), structs.end(), classComp);`
`1466`		`- std::stable_sort(exceptions.begin(),exceptions.end(),classComp);`
	`1465`	`+ std::stable_sort(m_classes.begin(), m_classes.end(), classComp);`
	`1466`	`+ std::stable_sort(m_interfaces.begin(),m_interfaces.end(),classComp);`
	`1467`	`+ std::stable_sort(m_structs.begin(), m_structs.end(), classComp);`
	`1468`	`+ std::stable_sort(m_exceptions.begin(),m_exceptions.end(),classComp);`
`1467`	`1469`
	`1470`	`+ auto conceptComp = [](const ConceptLinkedRefMap::Ptr &c1,const ConceptLinkedRefMap::Ptr &c2)`
	`1471`	`+ {`
	`1472`	`+ return qstricmp_sort(c1->name(),c2->name())<0;`
	`1473`	`+ };`
`1468`	`1474`
`1469`		`- auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)`
`1470`		`- {`
`1471`		`- return qstricmp_sort(n1->name(),n2->name())<0;`
`1472`		`- };`
	`1475`	`+ std::stable_sort(m_concepts.begin(), m_concepts.end(), conceptComp);`
	`1476`	`+`
	`1477`	`+ auto namespaceComp = [](const NamespaceLinkedRefMap::Ptr &n1,const NamespaceLinkedRefMap::Ptr &n2)`
	`1478`	`+ {`
	`1479`	`+ return qstricmp_sort(n1->name(),n2->name())<0;`
	`1480`	`+ };`
	`1481`	`+`
	`1482`	`+ std::stable_sort(m_namespaces.begin(),m_namespaces.end(),namespaceComp);`
	`1483`	`+ }`
`1473`	`1484`
`1474`		`- std::stable_sort(namespaces.begin(),namespaces.end(),namespaceComp);`
`1475`	`1485`	`}`
`1476`	`1486`
`1477`	`1487`	`MemberList *NamespaceDefImpl::getMemberList(MemberListType lt) const`