1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
|
/******************************************************************************
*
* Copyright (C) 1997-2020 by Dimitri van Heesch.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation under the terms of the GNU General Public License is hereby
* granted. No representations are made about the suitability of this software
* for any purpose. It is provided "as is" without express or implied warranty.
* See the GNU General Public License for more details.
*
* Documents produced by Doxygen are derivative works derived from the
* input used in their production; they are not affected by this license.
*
*/
#ifndef DIRDEF_H
#define DIRDEF_H
#include <vector>
#include <map>
#include "qcstring.h"
#include "linkedmap.h"
#include "definition.h"
class FileList;
class FileDef;
class OutputList;
class UsedDir;
class FilePair;
class FilePairDict;
class DirDef;
class DirList;
bool compareDirDefs(const DirDef *item1, const DirDef *item2);
// ------------------
/** Class representing a pair of FileDef objects */
class FilePair
{
public:
FilePair(const FileDef *src,const FileDef *dst) : m_src(src), m_dst(dst) {}
const FileDef *source() const { return m_src; }
const FileDef *destination() const { return m_dst; }
static QCString key(const FileDef *srcFd,const FileDef *dstFd);
private:
const FileDef *m_src;
const FileDef *m_dst;
};
// ------------------
/** A linked map of file pairs */
class FilePairLinkedMap : public LinkedMap<FilePair>
{
};
// ------------------
/** Usage information of a directory. */
class UsedDir
{
public:
UsedDir(const DirDef *dir);
virtual ~UsedDir();
/**
* Take up dependency between files.
* @param[in] srcFd dependent file which depends on dstFd
* @param[in] dstFd dependee file on which srcFd depends on
* @param[in] srcDirect true iff the source dependency was the direct (not inherited from a sub dir)
* @param[in] dstDirect true iff the destination dependency was direct (not inherited from a sub dir)
*/
void addFileDep(const FileDef *srcFd,const FileDef *dstFd, bool srcDirect, bool dstDirect);
FilePair *findFilePair(const QCString &name);
const FilePairLinkedMap &filePairs() const { return m_filePairs; }
const DirDef *dir() const { return m_dir; }
/** Returns true iff any of the dependencies between source and destination files are
* direct (i.e. not "inherited" from sub directories)
*/
bool hasDirectDeps() const { return m_hasDirectDeps; }
/** Returns true iff any of the dependencies from the source file to the destination file are
* directly coming from a file in the source directory (i.e. not inherited via sub directories)
*/
bool hasDirectSrcDeps() const { return m_hasDirectSrcDeps; }
/** Returns true iff any of the dependencies from the source file to the destination file are
* directly targeting a file in the destination directory (i.e. not inherited via sub directories)
*/
bool hasDirectDstDeps() const { return m_hasDirectDstDeps; }
void sort();
private:
const DirDef *m_dir;
FilePairLinkedMap m_filePairs;
bool m_hasDirectDeps = false;
bool m_hasDirectSrcDeps = false;
bool m_hasDirectDstDeps = false;
};
// ------------------
/** A model of a directory symbol. */
class DirDef : public DefinitionMutable, public Definition
{
public:
class UsedDirLinkedMap : public LinkedMap<UsedDir> {};
// accessors
virtual DefType definitionType() const = 0;
virtual QCString getOutputFileBase() const = 0;
virtual QCString anchor() const = 0;
virtual bool isLinkableInProject() const = 0;
virtual bool isLinkable() const = 0;
virtual QCString displayName(bool=TRUE) const = 0;
virtual const QCString shortName() const = 0;
virtual void addSubDir(DirDef *subdir) = 0;
virtual const FileList &getFiles() const = 0;
virtual void addFile(const FileDef *fd) = 0;
virtual const DirList &subDirs() const = 0;
virtual bool hasSubdirs() const = 0;
virtual int level() const = 0;
virtual DirDef *parent() const = 0;
virtual int dirCount() const = 0;
virtual const UsedDirLinkedMap &usedDirs() const = 0;
virtual bool isParentOf(const DirDef *dir) const = 0;
virtual bool depGraphIsTrivial() const = 0;
virtual QCString shortTitle() const = 0;
virtual bool hasDetailedDescription() const = 0;
// generate output
virtual void writeDocumentation(OutputList &ol) = 0;
virtual void writeTagFile(TextStream &t) = 0;
virtual void setDiskName(const QCString &name) = 0;
virtual void setDirCount(int count) = 0;
virtual void sort() = 0;
virtual void setParent(DirDef *parent) = 0;
virtual void setLevel() = 0;
virtual void addUsesDependency(const DirDef *usedDir,const FileDef *srcFd,
const FileDef *dstFd,bool srcDirect, bool dstDirect) = 0;
virtual void computeDependencies() = 0;
// directory graph related members
virtual bool hasDirectoryGraph() const = 0;
virtual void enableDirectoryGraph(bool e) = 0;
};
// --- Cast functions
DirDef *toDirDef(Definition *d);
const DirDef *toDirDef(const Definition *d);
/** A usage relation between two directories. */
class DirRelation
{
public:
DirRelation(const QCString &name,const DirDef *src,UsedDir *dst)
: m_name(name), m_src(src), m_dst(dst) {}
const DirDef *source() const { return m_src; }
UsedDir *destination() const { return m_dst; }
void writeDocumentation(OutputList &ol);
QCString getOutputFileBase() const { return m_name; }
private:
QCString m_name;
const DirDef *m_src;
UsedDir *m_dst;
};
/** A linked map of directories */
class DirLinkedMap : public LinkedMap<DirDef>
{
};
/** A list of directories. */
class DirList : public std::vector<const DirDef*>
{
};
class DirRelationLinkedMap : public LinkedMap<DirRelation>
{
};
// ------------------
void buildDirectories();
void generateDirDocs(OutputList &ol);
void computeDirDependencies();
#endif
|
