doxygen
entry.h
1 /******************************************************************************
2  *
3  *
4  *
5  * Copyright (C) 1997-2015 by Dimitri van Heesch.
6  *
7  * Permission to use, copy, modify, and distribute this software and its
8  * documentation under the terms of the GNU General Public License is hereby
9  * granted. No representations are made about the suitability of this software
10  * for any purpose. It is provided "as is" without express or implied warranty.
11  * See the GNU General Public License for more details.
12  *
13  * Documents produced by Doxygen are derivative works derived from the
14  * input used in their production; they are not affected by this license.
15  *
16  */
17 
18 #ifndef ENTRY_H
19 #define ENTRY_H
20 
21 #include <qgstring.h>
22 
23 #include <vector>
24 #include <memory>
25 
26 #include "types.h"
27 #include "arguments.h"
28 
29 struct SectionInfo;
30 class QFile;
31 class FileDef;
32 struct ListItemInfo;
33 
36 struct BaseInfo
37 {
39  BaseInfo(const char *n,Protection p,Specifier v) :
40  name(n),prot(p),virt(v) {}
44 };
45 
49 struct TagInfo
50 {
51  QCString tagName;
52  QCString fileName;
53  QCString anchor;
54 };
55 
62 class Entry
63 {
64  public:
65 
67  enum Sections {
68  CLASS_SEC = 0x00000001,
69  NAMESPACE_SEC = 0x00000010,
70  COMPOUND_MASK = CLASS_SEC,
71  SCOPE_MASK = COMPOUND_MASK | NAMESPACE_SEC,
72 
73  CLASSDOC_SEC = 0x00000800,
74  STRUCTDOC_SEC = 0x00001000,
75  UNIONDOC_SEC = 0x00002000,
76  EXCEPTIONDOC_SEC = 0x00004000,
77  NAMESPACEDOC_SEC = 0x00008000,
78  INTERFACEDOC_SEC = 0x00010000,
79  PROTOCOLDOC_SEC = 0x00020000,
80  CATEGORYDOC_SEC = 0x00040000,
81  SERVICEDOC_SEC = 0x00080000,
82  SINGLETONDOC_SEC = 0x00100000,
83  COMPOUNDDOC_MASK = CLASSDOC_SEC | STRUCTDOC_SEC | UNIONDOC_SEC |
84  INTERFACEDOC_SEC | EXCEPTIONDOC_SEC | PROTOCOLDOC_SEC |
85  CATEGORYDOC_SEC | SERVICEDOC_SEC | SINGLETONDOC_SEC,
86 
87  SOURCE_SEC = 0x00400000,
88  HEADER_SEC = 0x00800000,
89  FILE_MASK = SOURCE_SEC | HEADER_SEC,
90 
91  ENUMDOC_SEC = 0x01000000,
92  ENUM_SEC = 0x02000000,
93  EMPTY_SEC = 0x03000000,
94  PAGEDOC_SEC = 0x04000000,
95  VARIABLE_SEC = 0x05000000,
96  FUNCTION_SEC = 0x06000000,
97  TYPEDEF_SEC = 0x07000000,
98  MEMBERDOC_SEC = 0x08000000,
99  OVERLOADDOC_SEC = 0x09000000,
100  EXAMPLE_SEC = 0x0a000000,
101  VARIABLEDOC_SEC = 0x0b000000,
102  FILEDOC_SEC = 0x0c000000,
103  DEFINEDOC_SEC = 0x0d000000,
104  INCLUDE_SEC = 0x0e000000,
105  DEFINE_SEC = 0x0f000000,
106  GROUPDOC_SEC = 0x10000000,
107  USINGDIR_SEC = 0x11000000,
108  MAINPAGEDOC_SEC = 0x12000000,
109  MEMBERGRP_SEC = 0x13000000,
110  USINGDECL_SEC = 0x14000000,
111  PACKAGE_SEC = 0x15000000,
112  PACKAGEDOC_SEC = 0x16000000,
113  OBJCIMPL_SEC = 0x17000000,
114  DIRDOC_SEC = 0x18000000,
115  EXPORTED_INTERFACE_SEC = 0x19000000,
116  INCLUDED_SERVICE_SEC = 0x1A000000,
117  EXAMPLE_LINENO_SEC = 0x1B000000,
118  };
119 
120  // class specifiers (add new items to the end)
121  static const uint64 Template = (1ULL<<0);
122  static const uint64 Generic = (1ULL<<1);
123  static const uint64 Ref = (1ULL<<2);
124  static const uint64 Value = (1ULL<<3);
125  static const uint64 Interface = (1ULL<<4);
126  static const uint64 Struct = (1ULL<<5);
127  static const uint64 Union = (1ULL<<6);
128  static const uint64 Exception = (1ULL<<7);
129  static const uint64 Protocol = (1ULL<<8);
130  static const uint64 Category = (1ULL<<9);
131  static const uint64 SealedClass = (1ULL<<10);
132  static const uint64 AbstractClass = (1ULL<<11);
133  static const uint64 Enum = (1ULL<<12); // for Java-style enums
134  static const uint64 Service = (1ULL<<13); // UNO IDL
135  static const uint64 Singleton = (1ULL<<14); // UNO IDL
136  static const uint64 ForwardDecl = (1ULL<<15); // forward declared template classes
137  static const uint64 Local = (1ULL<<16); // for Slice types
138 
139  // member specifiers (add new items to the beginning)
140  static const uint64 ConstExpr = (1ULL<<19); // C++11 constexpr
141  static const uint64 PrivateGettable = (1ULL<<20); // C# private getter
142  static const uint64 ProtectedGettable = (1ULL<<21); // C# protected getter
143  static const uint64 PrivateSettable = (1ULL<<22); // C# private setter
144  static const uint64 ProtectedSettable = (1ULL<<23); // C# protected setter
145  static const uint64 Inline = (1ULL<<24);
146  static const uint64 Explicit = (1ULL<<25);
147  static const uint64 Mutable = (1ULL<<26);
148  static const uint64 Settable = (1ULL<<27);
149  static const uint64 Gettable = (1ULL<<28);
150  static const uint64 Readable = (1ULL<<29);
151  static const uint64 Writable = (1ULL<<30);
152  static const uint64 Final = (1ULL<<31);
153  static const uint64 Abstract = (1ULL<<32);
154  static const uint64 Addable = (1ULL<<33);
155  static const uint64 Removable = (1ULL<<34);
156  static const uint64 Raisable = (1ULL<<35);
157  static const uint64 Override = (1ULL<<36);
158  static const uint64 New = (1ULL<<37);
159  static const uint64 Sealed = (1ULL<<38);
160  static const uint64 Initonly = (1ULL<<39);
161  static const uint64 Optional = (1ULL<<40);
162  static const uint64 Required = (1ULL<<41);
163  static const uint64 NonAtomic = (1ULL<<42);
164  static const uint64 Copy = (1ULL<<43);
165  static const uint64 Retain = (1ULL<<44);
166  static const uint64 Assign = (1ULL<<45);
167  static const uint64 Strong = (1ULL<<46);
168  static const uint64 Weak = (1ULL<<47);
169  static const uint64 Unretained = (1ULL<<48);
170  static const uint64 Alias = (1ULL<<49);
171  static const uint64 ConstExp = (1ULL<<50);
172  static const uint64 Default = (1ULL<<51);
173  static const uint64 Delete = (1ULL<<52);
174  static const uint64 NoExcept = (1ULL<<53);
175  static const uint64 Attribute = (1ULL<<54); // UNO IDL attribute
176  static const uint64 Property = (1ULL<<55); // UNO IDL property
177  static const uint64 Readonly = (1ULL<<56); // on UNO IDL attribute or property
178  static const uint64 Bound = (1ULL<<57); // on UNO IDL attribute or property
179  static const uint64 Constrained = (1ULL<<58); // on UNO IDL property
180  static const uint64 Transient = (1ULL<<59); // on UNO IDL property
181  static const uint64 MaybeVoid = (1ULL<<60); // on UNO IDL property
182  static const uint64 MaybeDefault = (1ULL<<61); // on UNO IDL property
183  static const uint64 MaybeAmbiguous = (1ULL<<62); // on UNO IDL property
184  static const uint64 Published = (1ULL<<63); // UNO IDL keyword
185 
187  {
190  GROUPDOC_WEAK
191  };
192 
193  Entry();
194  Entry(const Entry &);
195  ~Entry();
196 
197  void addSpecialListItem(const char *listName,int index);
198 
200  Entry *parent() const { return m_parent; }
201 
205  const std::vector< std::shared_ptr<Entry> > &children() const { return m_sublist; }
206 
211  void moveToSubEntryAndKeep(Entry* e);
212  void moveToSubEntryAndKeep(std::shared_ptr<Entry> &e);
216  void moveToSubEntryAndRefresh(Entry* &e);
217  void moveToSubEntryAndRefresh(std::shared_ptr<Entry> &e);
218 
220  void copyToSubEntry (Entry* e);
221  void copyToSubEntry (const std::shared_ptr<Entry> &e);
222 
226  void removeSubEntry(const Entry *e);
227 
231  void reset();
232 
233  void markAsProcessed() const { ((Entry*)(this))->section = Entry::EMPTY_SEC; }
234  void setFileDef(FileDef *fd);
235  FileDef *fileDef() const { return m_fileDef; }
236 
237  // identification
238  int section;
241  bool hasTagInfo;
243  const TagInfo *tagInfo() const { return hasTagInfo ? &tagInfoData : 0; }
244 
245  // content
248  uint64 spec;
249  int initLines;
250  bool stat;
252  bool proto;
253  bool subGrouping;
254  bool callGraph;
255  bool callerGraph;
262  std::vector<ArgumentList> tArgLists;
268  int docLine;
271  int briefLine;
283  int bodyLine;
285  int mGrpId;
286  std::vector<BaseInfo> extends;
287  std::vector<Grouping> groups;
288  std::vector<const SectionInfo*> anchors;
290  int startLine;
292  std::vector<ListItemInfo> sli;
294  bool hidden;
295  bool artificial;
296  GroupDocType groupDocType;
298  LocalToc localToc;
300 
301 
302  static int num;
303 
305  const char *groupDocCmd() const
306  {
307  switch( groupDocType )
308  {
309  case GROUPDOC_NORMAL: return "\\defgroup";
310  case GROUPDOC_ADD: return "\\addtogroup";
311  case GROUPDOC_WEAK: return "\\weakgroup";
312  default: return "unknown group command";
313  }
314  }
315  Grouping::GroupPri_t groupingPri() const
316  {
317  if( section != GROUPDOC_SEC )
318  {
319  return Grouping::GROUPING_LOWEST;
320  }
321  switch( groupDocType )
322  {
323  case GROUPDOC_NORMAL: return Grouping::GROUPING_AUTO_DEF;
324  case GROUPDOC_ADD: return Grouping::GROUPING_AUTO_ADD;
325  case GROUPDOC_WEAK: return Grouping::GROUPING_AUTO_WEAK;
326  default: return Grouping::GROUPING_LOWEST;
327  }
328  }
329 
330  private:
331  Entry *m_parent;
332  std::vector< std::shared_ptr<Entry> > m_sublist;
333  Entry &operator=(const Entry &);
334  FileDef *m_fileDef;
335 };
336 
337 typedef std::vector< std::shared_ptr<Entry> > EntryList;
338 
339 #endif
bool callGraph
do we need to draw the call graph?
Definition: entry.h:254
QGString program
the program text
Definition: entry.h:263
QCString includeName
include name (3 arg of \class)
Definition: entry.h:266
std::vector< ArgumentList > tArgLists
template argument declarations
Definition: entry.h:262
This class represents an function or template argument list.
Definition: arguments.h:59
This file contains a number of basic enums and types.
bool proto
prototype ?
Definition: entry.h:252
uint64 spec
class/member specifiers
Definition: entry.h:248
Abstract interface for a template.
Definition: template.h:542
bool stat
static ?
Definition: entry.h:250
membership in group was defined via @weakgroup
Definition: types.h:70
Sections
Definition: entry.h:67
bool referencedByRelation
do we need to show the referenced by relation?
Definition: entry.h:256
Represents an unstructured piece of information, about an entity found in the sources.
Definition: entry.h:62
QCString read
property read accessor
Definition: entry.h:278
membership in group was defined via @defgroup
Definition: types.h:72
static int num
counts the total number of entries
Definition: entry.h:302
int briefLine
line number at which the brief desc. was found
Definition: entry.h:271
int docLine
line number at which the documentation was found
Definition: entry.h:268
QCString name
member name
Definition: entry.h:240
A model of a file symbol.
Definition: filedef.h:64
int initLines
define/variable initializer lines to show
Definition: entry.h:249
GroupPri_t
Grouping priority.
Definition: types.h:67
This struct is used to capture the tag file information for an Entry.
Definition: entry.h:49
Entry * parent() const
Definition: entry.h:200
bool referencesRelation
do we need to show the references relation?
Definition: entry.h:257
QCString id
libclang id
Definition: entry.h:297
SrcLangExt
Language as given by extension.
Definition: types.h:42
bool hidden
does this represent an entity that is hidden from the output
Definition: entry.h:294
int mGrpId
member group id
Definition: entry.h:285
BaseInfo(const char *n, Protection p, Specifier v)
Definition: entry.h:39
int startColumn
start column of entry in the source
Definition: entry.h:291
Definition: types.h:229
QCString includeFile
include file (2 arg of \class, must be unique)
Definition: entry.h:265
bool subGrouping
automatically group class members?
Definition: entry.h:253
bool callerGraph
do we need to draw the caller graph?
Definition: entry.h:255
QGString initializer
initial value (for variables)
Definition: entry.h:264
QCString inbodyFile
file in which the body doc was found
Definition: entry.h:275
QCString brief
brief description (doc block)
Definition: entry.h:270
int endBodyLine
line number where the definition ends
Definition: entry.h:284
const std::vector< std::shared_ptr< Entry > > & children() const
Definition: entry.h:205
std::vector< BaseInfo > extends
list of base classes
Definition: entry.h:286
addtogroup
Definition: entry.h:189
ArgumentList typeConstr
where clause (C#) for type constraints
Definition: entry.h:282
QCString name
the name of the base class
Definition: entry.h:41
Specifier virt
virtualness
Definition: entry.h:43
Specifier
Virtualness of a member.
Definition: types.h:30
QCString exception
throw specification
Definition: entry.h:281
int startLine
start line of entry in the source
Definition: entry.h:290
QCString args
member argument string
Definition: entry.h:259
QCString write
property write accessor
Definition: entry.h:279
std::vector< ListItemInfo > sli
special lists (test/todo/bug/deprecated/..) this entry is in
Definition: entry.h:292
Class representing a section in a page.
Definition: section.h:27
Protection protection
class protection
Definition: entry.h:246
QCString metaData
Slice metadata.
Definition: entry.h:299
Protection prot
inheritance type
Definition: entry.h:42
std::vector< Grouping > groups
list of groups this entry belongs to
Definition: entry.h:287
const char * groupDocCmd() const
return the command name used to define GROUPDOC_SEC
Definition: entry.h:305
RelatesType relatesType
how relates is handled
Definition: entry.h:277
The QFile class is an I/O device that operates on files.
Definition: qfile.h:50
QCString inbodyDocs
documentation inside the body of a function
Definition: entry.h:273
QCString doc
documentation block (partly parsed)
Definition: entry.h:267
Specifier virt
virtualness of the entry
Definition: entry.h:258
Definition: types.h:100
bool artificial
Artificially introduced item.
Definition: entry.h:295
This is an alternative implementation of QCString.
Definition: qgstring.h:19
ArgumentList argList
member arguments as a list
Definition: entry.h:261
defgroup
Definition: entry.h:188
QCString fileName
file this entry was extracted from
Definition: entry.h:289
bool explicitExternal
explicitly defined as external?
Definition: entry.h:251
QCString bitfields
member&#39;s bit fields
Definition: entry.h:260
QCString inside
name of the class in which documents are found
Definition: entry.h:280
MethodTypes
Kind of method.
Definition: types.h:33
Protection
Protection level of members.
Definition: types.h:27
QCString docFile
file in which the documentation was found
Definition: entry.h:269
MethodTypes mtype
signal, slot, (dcop) method, or property?
Definition: entry.h:247
RelatesType
Type of member relation.
Definition: types.h:36
std::vector< const SectionInfo * > anchors
list of anchors defined in this entry
Definition: entry.h:288
TagInfo tagInfoData
tag file info data
Definition: entry.h:242
bool hasTagInfo
is tag info valid
Definition: entry.h:241
QCString relates
related class (doc block)
Definition: entry.h:276
SrcLangExt lang
programming language in which this entry was found
Definition: entry.h:293
This is an alternative implementation of QCString.
Definition: qcstring.h:131
int inbodyLine
line number at which the body doc was found
Definition: entry.h:274
This class stores information about an inheritance relation.
Definition: entry.h:36
GroupDocType
Definition: entry.h:186
membership in group was defined via @add[to]group
Definition: types.h:71
QCString type
member type
Definition: entry.h:239
int section
entry type (see Sections);
Definition: entry.h:238
int bodyLine
line number of the definition in the source
Definition: entry.h:283
QCString briefFile
file in which the brief desc. was found
Definition: entry.h:272