1 // Copyright (c) 1994 James Clark
2 // See the file COPYING for copying permission.
3 #pragma ident "%Z%%M% %I% %E% SMI"
4
5 #ifndef ElementType_INCLUDED
6 #define ElementType_INCLUDED 1
7 #ifdef __GNUG__
8 #pragma interface
9 #endif
10
11 #include <stddef.h>
12 #include "Boolean.h"
13 #include "Vector.h"
14 #include "Owner.h"
15 #include "Location.h"
16 #include "Ptr.h"
17 #include "Named.h"
18 #include "Vector.h"
19 #include "Attributed.h"
20 #include "Mode.h"
21 #include "ContentToken.h"
22
23 #ifdef SP_NAMESPACE
24 namespace SP_NAMESPACE {
25 #endif
26
27 class ElementType;
28 class ShortReferenceMap;
29 class RankStem;
30
31 class SP_API ElementDefinition : public Resource {
32 public:
33 enum DeclaredContent { modelGroup, any, cdata, rcdata, empty };
34 enum OmitFlags { omitStart = 01, omitEnd = 02, omitSpec = 04 };
35 enum { undefinedIndex = -1 };
36 ElementDefinition(const Location &location,
37 size_t index,
38 unsigned char omitFlags,
39 DeclaredContent declaredContent);
40 ElementDefinition(const Location &location,
41 size_t index,
42 unsigned char omitFlags,
43 DeclaredContent declaredContent,
44 Owner<CompiledModelGroup> &modelGroup);
45 const CompiledModelGroup *compiledModelGroup() const;
46 DeclaredContent declaredContent() const;
47 // Was the omitted tag minimization specified?
48 Boolean omittedTagSpec() const;
49 Boolean canOmitStartTag() const;
50 Boolean canOmitEndTag() const;
51 size_t nRankStems() const;
52 const RankStem *rankStem(size_t i) const;
53 const StringC &rankSuffix() const;
54 size_t nInclusions() const;
55 const ElementType *inclusion(size_t) const;
56 size_t nExclusions() const;
57 const ElementType *exclusion(size_t) const;
58 Boolean undefined() const;
59 void setInclusions(Vector<const ElementType *> &inclusions);
60 void setExclusions(Vector<const ElementType *> &exclusions);
61 void setRank(StringC &suffix, Vector<const RankStem *> &rankStems);
62 Mode mode(Boolean netEnabled) const;
63 const Location &location() const;
64 private:
65 ElementDefinition(const ElementDefinition &); // undefined
66 void operator=(const ElementDefinition &); // undefined
67 void computeMode();
68
69 Location location_;
70 size_t index_;
71 unsigned char omitFlags_;
72 DeclaredContent declaredContent_;
73 Owner<CompiledModelGroup> modelGroup_;
74 Vector<const ElementType *> inclusions_;
75 Vector<const ElementType *> exclusions_;
76 // rankStems_ contains all the rank stems in the ranked group in this
77 // definition.
78 Vector<const RankStem *> rankStems_;
79 StringC rankSuffix_;
80 Mode mode_;
81 Mode netMode_;
82 };
83
84 class SP_API RankStem : public Named {
85 public:
86 RankStem(const StringC &, size_t);
87 size_t index() const;
88 void addDefinition(const ConstPtr<ElementDefinition> &);
89 size_t nDefinitions() const;
90 const ElementDefinition *definition(size_t) const;
91 private:
92 RankStem(const RankStem &); // undefined
93 void operator=(const RankStem &); // undefined
94 size_t index_;
95 Vector<ConstPtr<ElementDefinition> > def_;
96 };
97
98 class SP_API ElementType : public Named, public Attributed {
99 public:
100 ElementType(const StringC &, size_t);
101 void setElementDefinition(const ConstPtr<ElementDefinition> &,
102 size_t defIndex);
103 void setMap(const ShortReferenceMap *);
104 void setRankStem(RankStem *);
105 Boolean undefined() const;
106 const ElementDefinition *definition() const;
107 Boolean isRankedElement() const;
108 const RankStem *rankedElementRankStem() const;
109 size_t index() const;
110 const ShortReferenceMap *map() const;
111 void swap(ElementType &);
112 private:
113 ElementType(const ElementType &); // undefined
114 void operator=(const ElementType &); // undefined
115 size_t index_;
116 size_t defIndex_; // index in the group having same definition
117 ConstPtr<ElementDefinition> def_;
118 const ShortReferenceMap *map_;
119 };
120
121 inline
compiledModelGroup()122 const CompiledModelGroup *ElementDefinition::compiledModelGroup() const
123 {
124 return modelGroup_.pointer();
125 }
126
127 inline
declaredContent()128 ElementDefinition::DeclaredContent ElementDefinition::declaredContent() const
129 {
130 return declaredContent_;
131 }
132
133 inline
canOmitStartTag()134 Boolean ElementDefinition::canOmitStartTag() const
135 {
136 return (omitFlags_ & omitStart) != 0;
137 }
138
139 inline
canOmitEndTag()140 Boolean ElementDefinition::canOmitEndTag() const
141 {
142 return (omitFlags_ & omitEnd) != 0;
143 }
144
145 inline
omittedTagSpec()146 Boolean ElementDefinition::omittedTagSpec() const
147 {
148 return (omitFlags_ & omitSpec) != 0;
149 }
150
151 inline
nRankStems()152 size_t ElementDefinition::nRankStems() const
153 {
154 return rankStems_.size();
155 }
156
157 inline
rankSuffix()158 const StringC &ElementDefinition::rankSuffix() const
159 {
160 return rankSuffix_;
161 }
162
163 inline
rankStem(size_t i)164 const RankStem *ElementDefinition::rankStem(size_t i) const
165 {
166 return rankStems_[i];
167 }
168
169 inline
inclusion(size_t i)170 const ElementType *ElementDefinition::inclusion(size_t i) const
171 {
172 return inclusions_[i];
173 }
174
175 inline
nInclusions()176 size_t ElementDefinition::nInclusions() const
177 {
178 return inclusions_.size();
179 }
180
181 inline
exclusion(size_t i)182 const ElementType *ElementDefinition::exclusion(size_t i) const
183 {
184 return exclusions_[i];
185 }
186
187 inline
nExclusions()188 size_t ElementDefinition::nExclusions() const
189 {
190 return exclusions_.size();
191 }
192
193 inline
undefined()194 Boolean ElementDefinition::undefined() const
195 {
196 return index_ == size_t(undefinedIndex);
197 }
198
199 inline
location()200 const Location &ElementDefinition::location() const
201 {
202 return location_;
203 }
204
205 inline
setInclusions(Vector<const ElementType * > & inclusions)206 void ElementDefinition::setInclusions(Vector<const ElementType *> &inclusions)
207 {
208 inclusions.swap(inclusions_);
209 }
210
211 inline
setExclusions(Vector<const ElementType * > & exclusions)212 void ElementDefinition::setExclusions(Vector<const ElementType *> &exclusions)
213 {
214 exclusions.swap(exclusions_);
215 }
216
217 inline
setRank(StringC & rankSuffix,Vector<const RankStem * > & rankStems)218 void ElementDefinition::setRank(StringC &rankSuffix,
219 Vector<const RankStem *> &rankStems)
220 {
221 rankStems.swap(rankStems_);
222 rankSuffix.swap(rankSuffix_);
223 }
224
225 inline
undefined()226 Boolean ElementType::undefined() const
227 {
228 return def_->undefined();
229 }
230
231 inline
isRankedElement()232 Boolean ElementType::isRankedElement() const
233 {
234 return def_->nRankStems() > 0;
235 }
236
237 inline
definition()238 const ElementDefinition *ElementType::definition() const
239 {
240 return def_.pointer();
241 }
242
243 inline
setElementDefinition(const ConstPtr<ElementDefinition> & def,size_t defIndex)244 void ElementType::setElementDefinition(const ConstPtr<ElementDefinition> &def,
245 size_t defIndex)
246 {
247 def_ = def;
248 defIndex_ = defIndex;
249 }
250
251 inline
index()252 size_t ElementType::index() const
253 {
254 return index_;
255 }
256
257 inline
rankedElementRankStem()258 const RankStem *ElementType::rankedElementRankStem() const
259 {
260 return def_->rankStem(defIndex_);
261 }
262
263 inline
setMap(const ShortReferenceMap * map)264 void ElementType::setMap(const ShortReferenceMap *map)
265 {
266 map_ = map;
267 }
268
269 inline
map()270 const ShortReferenceMap *ElementType::map() const
271 {
272 return map_;
273 }
274
275 inline
index()276 size_t RankStem::index() const
277 {
278 return index_;
279 }
280
281 inline
nDefinitions()282 size_t RankStem::nDefinitions() const
283 {
284 return def_.size();
285 }
286
287 inline
definition(size_t i)288 const ElementDefinition *RankStem::definition(size_t i) const
289 {
290 return def_[i].pointer();
291 }
292
293 inline
mode(Boolean netEnabled)294 Mode ElementDefinition::mode(Boolean netEnabled) const
295 {
296 return netEnabled ? netMode_ : mode_;
297 }
298
299 #ifdef SP_NAMESPACE
300 }
301 #endif
302
303 #endif /* not ElementType_INCLUDED */
304