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
|
/******************************************************************************
*
* 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 "linkedmap.h"
#include "sortdict.h"
#include "definition.h"
#include <vector>
#include <map>
#include <qglobal.h>
#include <qcstring.h>
class FileList;
class QStrList;
class FileDef;
class OutputList;
class UsedDir;
class FTextStream;
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(FileDef *src,FileDef *dst) : m_src(src), m_dst(dst) {}
const FileDef *source() const { return m_src; }
const FileDef *destination() const { return m_dst; }
private:
FileDef *m_src;
FileDef *m_dst;
};
// ------------------
/** A sorted dictionary of FilePair objects. */
class FilePairDict : public SDict<FilePair>
{
public:
FilePairDict(uint size) : SDict<FilePair>(size) {}
private:
int compareValues(const FilePair *item1,const FilePair *item2) const;
};
// ------------------
/** Usage information of a directory. */
class UsedDir
{
public:
UsedDir(const DirDef *dir,bool inherited);
virtual ~UsedDir();
void addFileDep(FileDef *srcFd,FileDef *dstFd);
FilePair *findFilePair(const char *name);
const FilePairDict &filePairs() const { return m_filePairs; }
const DirDef *dir() const { return m_dir; }
bool inherited() const { return m_inherited; }
void sort();
private:
const DirDef *m_dir;
FilePairDict m_filePairs;
bool m_inherited;
};
// ------------------
/** A model of a directory symbol. */
class DirDef : public DefinitionMutable, public Definition
{
public:
virtual ~DirDef() {}
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 FileList * getFiles() const = 0;
virtual void addFile(FileDef *fd) = 0;
virtual const DirList &subDirs() const = 0;
virtual bool isCluster() 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(FTextStream &t) = 0;
virtual void setDiskName(const QCString &name) = 0;
virtual void sort() = 0;
virtual void setParent(DirDef *parent) = 0;
virtual void setLevel() = 0;
virtual void addUsesDependency(DirDef *usedDir,FileDef *srcFd,
FileDef *dstFd,bool inherited) = 0;
virtual void computeDependencies() = 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();
void writeDirDependencyGraph(const char *file);
#endif
|
