1 /*
2 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /*
7 * Copyright 1994 James Clark
8 * See the file COPYING for copying permission.
9 */
10
11 #pragma ident "%Z%%M% %I% %E% SMI"
12
13 #ifndef _ATTRIBUTE_H
14 #define _ATTRIBUTE_H
15
16 #ifndef Attribute_INCLUDED
17 #define Attribute_INCLUDED 1
18 #ifdef __GNUG__
19 #pragma interface
20 #endif
21
22 #include <stddef.h>
23 #include "Resource.h"
24 #include "Owner.h"
25 #include "StringC.h"
26 #include "Vector.h"
27 #include "CopyOwner.h"
28 #include "Boolean.h"
29 #include "Text.h"
30 #include "Ptr.h"
31 #include "Message.h"
32
33 #ifdef SP_NAMESPACE
34 namespace SP_NAMESPACE {
35 #endif
36
37 class Entity;
38 class Notation;
39 class DeclaredValue;
40 class AttributeValue;
41 class TokenizedAttributeValue;
42 class AttributeSemantics;
43 class AttributeContext;
44 class Syntax;
45
46 class SP_API AttributeValue : public Resource {
47 public:
48 enum Type {
49 implied,
50 cdata,
51 tokenized
52 };
53 AttributeValue();
54 virtual ~AttributeValue();
55 virtual AttributeSemantics *makeSemantics(const DeclaredValue *,
56 AttributeContext &,
57 const StringC &,
58 unsigned &,
59 unsigned &) const;
60 virtual Type info(const Text *&, const StringC *&) const = 0;
61 virtual const Text *text() const;
62 virtual Boolean recoverUnquoted(const StringC &, const Location &,
63 AttributeContext &, const StringC &);
64 static Boolean handleAsUnterminated(const Text &, AttributeContext &);
65 };
66
67 class SP_API AttributeDefinitionDesc {
68 public:
AttributeDefinitionDesc()69 AttributeDefinitionDesc() { }
70 enum DeclaredValue {
71 cdata,
72 name,
73 number,
74 nmtoken,
75 nutoken,
76 entity,
77 idref,
78 names,
79 numbers,
80 nmtokens,
81 nutokens,
82 entities,
83 idrefs,
84 id,
85 notation,
86 nameTokenGroup
87 };
88 DeclaredValue declaredValue;
89 enum DefaultValueType {
90 required,
91 current,
92 implied,
93 conref,
94 defaulted,
95 fixed
96 };
97 DefaultValueType defaultValueType;
98 ConstPtr < AttributeValue > defaultValue;
99 Vector < StringC > allowedValues;
100 // Attribute definitions whose default value type is current and
101 // which have the same currentIndex share current values.
102 size_t currentIndex;
103 private:
104 AttributeDefinitionDesc(const AttributeDefinitionDesc &); // undefined
105 void operator=(const AttributeDefinitionDesc &); // undefined
106 };
107
108 class DeclaredValue {
109 public:
110 DeclaredValue();
111 virtual ~DeclaredValue();
112 // This performs syntactic checking on the value.
113 virtual AttributeValue *makeValue(Text &, AttributeContext &,
114 const StringC &name,
115 unsigned &specLength) const = 0;
116 // This is used to avoid unnecessary syntactic checking in the
117 // case where the attribute name and vi have been omitted.
118 virtual AttributeValue *makeValueFromToken(Text &,
119 AttributeContext &,
120 const StringC &name,
121 unsigned &specLength) const;
122 // This performs semantic checking on the value.
123 virtual AttributeSemantics *makeSemantics(
124 const TokenizedAttributeValue &,
125 AttributeContext &,
126 const StringC &,
127 unsigned &nIdrefs,
128 unsigned &nEntityNames) const;
129 virtual Boolean containsToken(const StringC &) const;
130 virtual Boolean tokenized() const = 0;
131 virtual Boolean isNotation() const;
132 virtual Boolean isEntity() const;
133 virtual Boolean isId() const;
134 virtual Boolean isIdref() const;
135 virtual const Vector < StringC > *getTokens() const;
136 virtual void buildDesc(AttributeDefinitionDesc &) const = 0;
137 virtual DeclaredValue *copy() const = 0;
138 };
139
140 class CdataDeclaredValue : public DeclaredValue {
141 public:
142 CdataDeclaredValue();
143 Boolean tokenized() const;
144 AttributeValue *makeValue(Text &, AttributeContext &, const StringC &,
145 unsigned &) const;
146 void buildDesc(AttributeDefinitionDesc &) const;
147 DeclaredValue *copy() const;
148 };
149
150 class TokenizedDeclaredValue : public DeclaredValue {
151 public:
152 // must be in same order as AttributeDefinitionDesc
153 enum TokenType {
154 name,
155 number,
156 nameToken,
157 numberToken,
158 entityName
159 };
160 TokenizedDeclaredValue(TokenType type, Boolean isList);
161 AttributeValue *makeValue(Text &, AttributeContext &, const StringC &,
162 unsigned &) const;
163 TokenizedAttributeValue *makeTokenizedValue(Text &, AttributeContext &,
164 const StringC &, unsigned &) const;
165 Boolean tokenized() const;
166 void buildDesc(AttributeDefinitionDesc &) const;
167 DeclaredValue *copy() const;
168 private:
169 TokenType type_;
170 Boolean isList_;
171 unsigned initialCategories_;
172 unsigned subsequentCategories_;
173 };
174
175 class GroupDeclaredValue : public TokenizedDeclaredValue {
176 public:
177 GroupDeclaredValue(TokenType, Vector < StringC > &);
178 Boolean containsToken(const StringC &) const;
179 AttributeValue *makeValue(Text &, AttributeContext &, const StringC &,
180 unsigned &) const;
181 AttributeValue *makeValueFromToken(Text &,
182 AttributeContext &,
183 const StringC &name,
184 unsigned &) const;
185 const Vector < StringC > *getTokens() const;
186 void buildDesc(AttributeDefinitionDesc &) const;
187 DeclaredValue *copy() const;
188 private:
189 Vector < StringC > allowedValues_;
190 };
191
192 class NameTokenGroupDeclaredValue : public GroupDeclaredValue {
193 public:
194 NameTokenGroupDeclaredValue(Vector < StringC > &);
195 void buildDesc(AttributeDefinitionDesc &) const;
196 DeclaredValue *copy() const;
197 };
198
199 class NotationDeclaredValue : public GroupDeclaredValue {
200 public:
201 NotationDeclaredValue(Vector < StringC > &);
202 AttributeSemantics *makeSemantics(const TokenizedAttributeValue &,
203 AttributeContext &,
204 const StringC &,
205 unsigned &nIdrefs,
206 unsigned &nEntityNames) const;
207 Boolean isNotation() const;
208 void buildDesc(AttributeDefinitionDesc &) const;
209 DeclaredValue *copy() const;
210 };
211
212 class EntityDeclaredValue : public TokenizedDeclaredValue {
213 public:
214 EntityDeclaredValue(Boolean isList);
215 AttributeSemantics *makeSemantics(const TokenizedAttributeValue &,
216 AttributeContext &,
217 const StringC &,
218 unsigned &nIdrefs,
219 unsigned &nEntityNames) const;
220 Boolean isEntity() const;
221 DeclaredValue *copy() const;
222 };
223
224 class IdDeclaredValue : public TokenizedDeclaredValue {
225 public:
226 IdDeclaredValue();
227 AttributeSemantics *makeSemantics(const TokenizedAttributeValue &,
228 AttributeContext &,
229 const StringC &,
230 unsigned &nIdrefs,
231 unsigned &nEntityNames) const;
232 Boolean isId() const;
233 void buildDesc(AttributeDefinitionDesc &) const;
234 DeclaredValue *copy() const;
235 };
236
237 class IdrefDeclaredValue : public TokenizedDeclaredValue {
238 public:
239 IdrefDeclaredValue(Boolean isList);
240 AttributeSemantics *makeSemantics(const TokenizedAttributeValue &,
241 AttributeContext &,
242 const StringC &,
243 unsigned &nIdrefs,
244 unsigned &nEntityNames) const;
245 Boolean isIdref() const;
246 void buildDesc(AttributeDefinitionDesc &) const;
247 DeclaredValue *copy() const;
248 };
249
250 class SP_API AttributeDefinition {
251 public:
252 AttributeDefinition(const StringC &, DeclaredValue *);
253 virtual ~AttributeDefinition();
254 virtual ConstPtr < AttributeValue >
255 makeMissingValue(AttributeContext &) const = 0;
256 virtual Boolean missingValueWouldMatch(const Text &,
257 const AttributeContext &) const;
258 virtual const AttributeValue *
259 defaultValue(const AttributeValue *impliedValue) const;
260 AttributeValue *makeValue(Text &, AttributeContext &, unsigned &) const;
261 AttributeValue *makeValueFromToken(Text &,
262 AttributeContext &,
263 unsigned &) const;
264
265 virtual Boolean isConref() const;
266 virtual Boolean isCurrent() const;
267 virtual Boolean isFixed() const;
268 AttributeSemantics *makeSemantics(const AttributeValue *,
269 AttributeContext &,
270 unsigned &nIdrefs,
271 unsigned &nEntityNames) const;
272 Boolean tokenized() const;
273 const StringC &name() const;
274 Boolean containsToken(const StringC &) const;
275 Boolean isNotation() const;
276 Boolean isEntity() const;
277 Boolean isId() const;
278 Boolean isIdref() const;
279 void getDesc(AttributeDefinitionDesc &) const;
280 const Vector < StringC > *getTokens() const;
281 virtual AttributeDefinition *copy() const = 0;
282 void setDeclaredValue(DeclaredValue *);
283 private:
284 virtual void buildDesc(AttributeDefinitionDesc &) const = 0;
285 virtual AttributeValue *checkValue(AttributeValue *,
286 AttributeContext &) const;
287 StringC name_;
288 CopyOwner < DeclaredValue > declaredValue_;
289 };
290
291 class RequiredAttributeDefinition : public AttributeDefinition {
292 public:
293 RequiredAttributeDefinition(const StringC &, DeclaredValue *);
294 ConstPtr < AttributeValue > makeMissingValue(AttributeContext &) const;
295 void buildDesc(AttributeDefinitionDesc &) const;
296 AttributeDefinition *copy() const;
297 };
298
299 class CurrentAttributeDefinition : public AttributeDefinition {
300 public:
301 CurrentAttributeDefinition(const StringC &, DeclaredValue *,
302 size_t index);
303 ConstPtr < AttributeValue > makeMissingValue(AttributeContext &) const;
304 Boolean missingValueWouldMatch(const Text &,
305 const AttributeContext &) const;
306 AttributeValue *checkValue(AttributeValue *, AttributeContext &) const;
307 void buildDesc(AttributeDefinitionDesc &) const;
308 Boolean isCurrent() const;
309 AttributeDefinition *copy() const;
310 private:
311 size_t currentIndex_;
312 };
313
314 class ImpliedAttributeDefinition : public AttributeDefinition {
315 public:
316 ImpliedAttributeDefinition(const StringC &, DeclaredValue *);
317 ConstPtr < AttributeValue > makeMissingValue(AttributeContext &) const;
318 const AttributeValue *defaultValue(const AttributeValue *) const;
319 void buildDesc(AttributeDefinitionDesc &) const;
320 AttributeDefinition *copy() const;
321 };
322
323 class ConrefAttributeDefinition : public ImpliedAttributeDefinition {
324 public:
325 ConrefAttributeDefinition(const StringC &, DeclaredValue *);
326 Boolean isConref() const;
327 void buildDesc(AttributeDefinitionDesc &) const;
328 AttributeDefinition *copy() const;
329 };
330
331 class DefaultAttributeDefinition : public AttributeDefinition {
332 public:
333 DefaultAttributeDefinition(const StringC &, DeclaredValue *,
334 AttributeValue *);
335 ConstPtr < AttributeValue > makeMissingValue(AttributeContext &) const;
336 Boolean missingValueWouldMatch(const Text &,
337 const AttributeContext &) const;
338 void buildDesc(AttributeDefinitionDesc &) const;
339 AttributeDefinition *copy() const;
340 const AttributeValue *defaultValue(const AttributeValue *) const;
341 private:
342 ConstPtr < AttributeValue > value_;
343 };
344
345 class FixedAttributeDefinition : public DefaultAttributeDefinition {
346 public:
347 FixedAttributeDefinition(const StringC &, DeclaredValue *,
348 AttributeValue *);
349 // check that it's equal to the default
350 AttributeValue *checkValue(AttributeValue *, AttributeContext &) const;
351 void buildDesc(AttributeDefinitionDesc &) const;
352 Boolean isFixed() const;
353 AttributeDefinition *copy() const;
354 };
355
356 class SP_API AttributeDefinitionList : public Resource {
357 public:
358 AttributeDefinitionList(Vector < CopyOwner < AttributeDefinition > > &,
359 size_t listIndex,
360 Boolean anyCurrent = 0,
361 size_t idIndex = size_t(-1),
362 size_t notationIndex = size_t(-1));
363 AttributeDefinitionList(const ConstPtr < AttributeDefinitionList > &);
364 size_t size() const;
365 AttributeDefinition *def(size_t);
366 const AttributeDefinition *def(size_t)const;
367 Boolean tokenIndex(const StringC &, unsigned &) const;
368 Boolean tokenIndexUnique(const StringC &, unsigned) const;
369 Boolean attributeIndex(const StringC &, unsigned &) const;
370 size_t index() const;
371 size_t idIndex() const;
372 size_t notationIndex() const;
373 Boolean anyCurrent() const;
374 void setIndex(size_t);
375 void append(AttributeDefinition *);
376 private:
377 Vector < CopyOwner < AttributeDefinition > > defs_;
378 size_t index_;
379 size_t idIndex_; // -1 if no ID attribute
380 size_t notationIndex_; // -1 if no notation attribute
381 Boolean anyCurrent_;
382 ConstPtr < AttributeDefinitionList > prev_;
383 };
384
385 class AttributeSemantics {
386 public:
387 AttributeSemantics();
388 virtual ~AttributeSemantics();
389 virtual size_t nEntities() const;
390 virtual ConstPtr < Entity > entity(size_t)const;
391 virtual ConstPtr < Notation > notation() const;
392 virtual AttributeSemantics *copy() const = 0;
393 };
394
395 class EntityAttributeSemantics : public AttributeSemantics {
396 public:
397 EntityAttributeSemantics(Vector < ConstPtr < Entity > > &);
398 size_t nEntities() const;
399 ConstPtr < Entity > entity(size_t)const;
400 AttributeSemantics *copy() const;
401 private:
402 Vector < ConstPtr < Entity > > entity_;
403 };
404
405 class NotationAttributeSemantics : public AttributeSemantics {
406 public:
407 NotationAttributeSemantics(const ConstPtr < Notation > &);
408 ConstPtr < Notation > notation() const;
409 AttributeSemantics *copy() const;
410 private:
411 ConstPtr < Notation > notation_;
412 };
413
414 class SP_API ImpliedAttributeValue : public AttributeValue {
415 public:
416 ImpliedAttributeValue();
417 Type info(const Text *&, const StringC *&) const;
418 };
419
420 class CdataAttributeValue : public AttributeValue {
421 public:
422 CdataAttributeValue(Text &);
423 Type info(const Text *&, const StringC *&) const;
424 const Text *text() const;
425 Boolean recoverUnquoted(const StringC &, const Location &,
426 AttributeContext &, const StringC &);
427 private:
428 Text text_;
429 };
430
431 class TokenizedAttributeValue : public AttributeValue {
432 public:
433 TokenizedAttributeValue(Text &, const Vector < size_t > &);
434 size_t nTokens() const;
435 AttributeSemantics *makeSemantics(const DeclaredValue *,
436 AttributeContext &,
437 const StringC &,
438 unsigned &,
439 unsigned &) const;
440 Type info(const Text *&, const StringC *&) const;
441 const Text *text() const;
442 const StringC &string() const;
443 StringC token(size_t)const;
444 void token(size_t, const Char *&, size_t &) const;
445 Location tokenLocation(size_t)const;
446 Boolean tokenLocation(size_t,
447 const ConstPtr < Origin > *&, Index &) const;
448 Boolean recoverUnquoted(const StringC &, const Location &,
449 AttributeContext &, const StringC &);
450 private:
451 TokenizedAttributeValue(const TokenizedAttributeValue &); // undefined
452 void operator=(const TokenizedAttributeValue &); // undefined
453 Text text_;
454 // index into value of each space
455 // length is number of tokens - 1
456 Vector < size_t > spaceIndex_;
457 };
458
459 class SP_API Attribute {
460 public:
461 Attribute();
462 Boolean specified() const;
463 size_t specIndex() const;
464 const AttributeValue *value() const;
465 const ConstPtr < AttributeValue > &valuePointer() const;
466 const AttributeSemantics *semantics() const;
467 void setSpec(size_t);
468 void setValue(const ConstPtr < AttributeValue > &);
469 void setSemantics(AttributeSemantics *);
470 void clear();
471 private:
472 size_t specIndexPlus_;
473 ConstPtr < AttributeValue > value_;
474 CopyOwner < AttributeSemantics > semantics_;
475 };
476
477 class SP_API AttributeList {
478 public:
479 AttributeList();
480 AttributeList(const ConstPtr < AttributeDefinitionList > &);
481 void init(const ConstPtr < AttributeDefinitionList > &);
482 // was a conref attribute specified?
483 Boolean conref()const;
484 size_t size()const;
485 const StringC &name(unsigned)const;
486 const AttributeValue *value(unsigned)const;
487 size_t specIndex(size_t)const;
488 const ConstPtr < AttributeValue > &valuePointer(unsigned)const;
489 const AttributeSemantics *semantics(unsigned)const;
490 Boolean tokenized(unsigned index) const;
491 Boolean tokenIndex(const StringC &, unsigned &) const;
492 Boolean tokenIndexUnique(const StringC &, unsigned) const;
493 Boolean attributeIndex(const StringC &, unsigned &) const;
494 void finish(AttributeContext &);
495 Boolean setValue(unsigned index, Text &, AttributeContext &,
496 unsigned &specLength);
497 void setValueToken(unsigned index, Text &, AttributeContext &,
498 unsigned &specLength);
499 void setSpec(unsigned index, AttributeContext &);
500 Boolean recoverUnquoted(const StringC &, const Location &,
501 AttributeContext &);
502 Boolean handleAsUnterminated(AttributeContext &context);
503 void swap(AttributeList &);
504 size_t nSpec() const;
505 size_t defIndex() const;
506 // is the attribute #current
507 Boolean current(unsigned)const;
508 Boolean anyCurrent()const;
509 Boolean specified(unsigned)const;
510 Boolean id(unsigned)const;
511 Boolean idref(unsigned)const;
512 const Vector < StringC > *getAllowedTokens(unsigned)const;
513 const StringC *getId() const; // null if none
514 Boolean idIndex(unsigned &) const;
515 void noteInvalidSpec();
516 void changeDef(const ConstPtr < AttributeDefinitionList > &);
517 const ConstPtr < AttributeDefinitionList > &def() const;
518 private:
519 const AttributeDefinition *def(size_t)const;
520 PackedBoolean conref_;
521 unsigned nIdrefs_;
522 unsigned nEntityNames_;
523 size_t nSpec_;
524 Vector < Attribute > vec_;
525 ConstPtr < AttributeDefinitionList > def_;
526 };
527
528 class SP_API AttributeContext : public Messenger {
529 public:
530 AttributeContext();
531 virtual ~AttributeContext();
532 virtual Boolean defineId(const StringC &, const Location &, Location &);
533 virtual void noteIdref(const StringC &, const Location &);
534 virtual void noteCurrentAttribute(size_t, AttributeValue *);
535 virtual ConstPtr < AttributeValue > getCurrentAttribute(size_t)const;
536 virtual ConstPtr < Entity > getAttributeEntity(const StringC &,
537 const Location &);
538 virtual ConstPtr < Notation > getAttributeNotation(const StringC &,
539 const Location &);
540 virtual const Syntax &attributeSyntax() const = 0;
541
542 ConstPtr < AttributeValue > makeImpliedAttributeValue();
543 Boolean mayDefaultAttribute() const;
544 Boolean validate() const;
545 protected:
546 Boolean mayDefaultAttribute_;
547 Boolean validate_;
548 private:
549 ConstPtr < AttributeValue > impliedAttributeValue_;
550 };
551
552 inline
tokenized()553 Boolean AttributeDefinition::tokenized() const
554 {
555 return (declaredValue_->tokenized());
556 }
557
558 inline
isNotation()559 Boolean AttributeDefinition::isNotation() const
560 {
561 return (declaredValue_->isNotation());
562 }
563
564 inline
isEntity()565 Boolean AttributeDefinition::isEntity() const
566 {
567 return (declaredValue_->isEntity());
568 }
569
570 inline
isId()571 Boolean AttributeDefinition::isId() const
572 {
573 return (declaredValue_->isId());
574 }
575
576 inline
isIdref()577 Boolean AttributeDefinition::isIdref() const
578 {
579 return (declaredValue_->isIdref());
580 }
581
582 inline
getTokens()583 const Vector < StringC > *AttributeDefinition::getTokens() const
584 {
585 return (declaredValue_->getTokens());
586 }
587
588 inline
589 AttributeSemantics *
makeSemantics(const AttributeValue * value,AttributeContext & context,unsigned & nIdrefs,unsigned & nEntityNames)590 AttributeDefinition::makeSemantics(const AttributeValue *value,
591 AttributeContext &context, unsigned &nIdrefs,
592 unsigned &nEntityNames) const
593 {
594 return (value->makeSemantics(declaredValue_.pointer(),
595 context, name_, nIdrefs, nEntityNames));
596 }
597
598 inline
makeValue(Text & text,AttributeContext & context,unsigned & specLength)599 AttributeValue *AttributeDefinition::makeValue(Text &text,
600 AttributeContext &context, unsigned &specLength) const
601 {
602 return (checkValue(declaredValue_->makeValue(text,
603 context, name_, specLength), context));
604 }
605
606 inline
607 AttributeValue *
makeValueFromToken(Text & text,AttributeContext & context,unsigned & specLength)608 AttributeDefinition::makeValueFromToken(Text &text,
609 AttributeContext &context,
610 unsigned &specLength) const
611 {
612 return (checkValue(declaredValue_->makeValueFromToken(text,
613 context, name_, specLength), context));
614 }
615
616 inline
containsToken(const StringC & token)617 Boolean AttributeDefinition::containsToken(const StringC &token) const
618 {
619 return (declaredValue_->containsToken(token));
620 }
621
622 inline
name()623 const StringC &AttributeDefinition::name() const
624 {
625 return (name_);
626 }
627
628 inline
setDeclaredValue(DeclaredValue * declaredValue)629 void AttributeDefinition::setDeclaredValue(DeclaredValue *declaredValue)
630 {
631 declaredValue_ = declaredValue;
632 }
633
634 inline
size()635 size_t AttributeDefinitionList::size() const
636 {
637 return (defs_.size());
638 }
639
640 inline
index()641 size_t AttributeDefinitionList::index() const
642 {
643 return (index_);
644 }
645
646 inline
setIndex(size_t index)647 void AttributeDefinitionList::setIndex(size_t index)
648 {
649 index_ = index;
650 }
651
652 inline
idIndex()653 size_t AttributeDefinitionList::idIndex() const
654 {
655 return (idIndex_);
656 }
657
658 inline
notationIndex()659 size_t AttributeDefinitionList::notationIndex() const
660 {
661 return (notationIndex_);
662 }
663
664 inline
anyCurrent()665 Boolean AttributeDefinitionList::anyCurrent() const
666 {
667 return (anyCurrent_);
668 }
669
670 inline
def(size_t i)671 AttributeDefinition *AttributeDefinitionList::def(size_t i)
672 {
673 return (defs_[i].pointer());
674 }
675
676 inline
def(size_t i)677 const AttributeDefinition *AttributeDefinitionList::def(size_t i) const
678 {
679 return (defs_[i].pointer());
680 }
681
682 inline
nTokens()683 size_t TokenizedAttributeValue::nTokens() const
684 {
685 return (spaceIndex_.size() + 1);
686 }
687
688 inline
string()689 const StringC &TokenizedAttributeValue::string() const
690 {
691 return (text_.string());
692 }
693
694 inline
token(size_t i,const Char * & ptr,size_t & len)695 void TokenizedAttributeValue::token(size_t i,
696 const Char *&ptr, size_t &len) const
697 {
698 size_t startIndex = i == 0 ? 0 :
699 spaceIndex_[i - 1] + 1;
700 ptr = text_.string().data() + startIndex;
701 len = (i == spaceIndex_.size() ? text_.size() :
702 spaceIndex_[i]) - startIndex;
703 }
704
705 inline
token(size_t i)706 StringC TokenizedAttributeValue::token(size_t i) const
707 {
708 const Char *ptr;
709 size_t len;
710 token(i, ptr, len);
711 return (StringC(ptr, len));
712 }
713
714
715 inline
tokenLocation(size_t i)716 Location TokenizedAttributeValue::tokenLocation(size_t i) const
717 {
718 return (text_.charLocation(i == 0 ? 0 :
719 spaceIndex_[i - 1] + 1));
720 }
721
722 inline
tokenLocation(size_t i,const ConstPtr<Origin> * & origin,Index & index)723 Boolean TokenizedAttributeValue::tokenLocation(size_t i,
724 const ConstPtr < Origin > *&origin, Index &index) const
725 {
726 return (text_.charLocation(i == 0 ? 0 :
727 spaceIndex_[i - 1] + 1, origin, index));
728 }
729
730 inline
specIndex()731 size_t Attribute::specIndex() const
732 {
733 return (specIndexPlus_ - 1);
734 }
735
736 inline
specified()737 Boolean Attribute::specified() const
738 {
739 return (specIndexPlus_ != 0);
740 }
741
742 inline
value()743 const AttributeValue *Attribute::value() const
744 {
745 return (value_.pointer());
746 }
747
748 inline
valuePointer()749 const ConstPtr < AttributeValue > &Attribute::valuePointer() const
750 {
751 return (value_);
752 }
753
754 inline
semantics()755 const AttributeSemantics *Attribute::semantics() const
756 {
757 return (semantics_.pointer());
758 }
759
760 inline
setSpec(size_t index)761 void Attribute::setSpec(size_t index)
762 {
763 specIndexPlus_ = index + 1;
764 }
765
766 inline
setValue(const ConstPtr<AttributeValue> & value)767 void Attribute::setValue(const ConstPtr < AttributeValue > &value)
768 {
769 value_ = value;
770 }
771
772 inline
setSemantics(AttributeSemantics * semantics)773 void Attribute::setSemantics(AttributeSemantics *semantics)
774 {
775 semantics_ = semantics;
776 }
777
778 inline
size()779 size_t AttributeList::size() const
780 {
781 return (vec_.size());
782 }
783
784 inline
def(size_t i)785 const AttributeDefinition *AttributeList::def(size_t i) const
786 {
787 return (def_->def(i));
788 }
789
790 inline
def()791 const ConstPtr < AttributeDefinitionList > &AttributeList::def() const
792 {
793 return (def_);
794 }
795
796 inline
tokenized(unsigned i)797 Boolean AttributeList::tokenized(unsigned i) const
798 {
799 return (def(i)->tokenized());
800 }
801
802 inline
tokenIndex(const StringC & name,unsigned & index)803 Boolean AttributeList::tokenIndex(const StringC &name, unsigned &index) const
804 {
805 return (!def_.isNull() && def_->tokenIndex(name, index));
806 }
807
808 inline
tokenIndexUnique(const StringC & name,unsigned index)809 Boolean AttributeList::tokenIndexUnique(const StringC &name,
810 unsigned index) const
811 {
812 return (def_->tokenIndexUnique(name, index));
813 }
814
815 inline
attributeIndex(const StringC & name,unsigned & index)816 Boolean AttributeList::attributeIndex(const StringC &name,
817 unsigned &index) const
818 {
819 return (!def_.isNull() && def_->attributeIndex(name, index));
820 }
821
822 inline
name(unsigned i)823 const StringC &AttributeList::name(unsigned i) const
824 {
825 return (def(i)->name());
826 }
827
828 inline
getAllowedTokens(unsigned i)829 const Vector < StringC > *AttributeList::getAllowedTokens(unsigned i)
830 const
831 {
832 return (def(i)->getTokens());
833 }
834
835 inline
value(unsigned i)836 const AttributeValue *AttributeList::value(unsigned i) const
837 {
838 return (vec_[i].value());
839 }
840
841 inline
valuePointer(unsigned i)842 const ConstPtr < AttributeValue > &AttributeList::valuePointer(unsigned i)
843 const
844 {
845 return (vec_[i].valuePointer());
846 }
847
848 inline
semantics(unsigned i)849 const AttributeSemantics *AttributeList::semantics(unsigned i) const
850 {
851 return (vec_[i].semantics());
852 }
853
854 inline
specIndex(size_t i)855 size_t AttributeList::specIndex(size_t i) const
856 {
857 return (vec_[i].specIndex());
858 }
859
860 inline
nSpec()861 size_t AttributeList::nSpec() const
862 {
863 return (nSpec_);
864 }
865
866 inline
conref()867 Boolean AttributeList::conref() const
868 {
869 return (conref_);
870 }
871
872 inline
defIndex()873 size_t AttributeList::defIndex() const
874 {
875 return (def_.isNull() ? size_t(-1) : def_->index());
876 }
877
878 inline
current(unsigned i)879 Boolean AttributeList::current(unsigned i) const
880 {
881 return (def(i)->isCurrent());
882 }
883
884 inline
anyCurrent()885 Boolean AttributeList::anyCurrent() const
886 {
887 return (!def_.isNull() && def_->anyCurrent());
888 }
889
890 inline
891 const AttributeValue *
defaultValue(const AttributeValue *)892 DefaultAttributeDefinition::defaultValue(const AttributeValue *)
893 const
894 {
895 return (value_.pointer());
896 }
897
898 inline
idIndex(unsigned & ind)899 Boolean AttributeList::idIndex(unsigned &ind) const
900 {
901 if (def_.isNull() || def_->idIndex() == size_t(-1))
902 return (0);
903 else {
904 ind = def_->idIndex();
905 return (1);
906 }
907 }
908
909 inline
id(unsigned i)910 Boolean AttributeList::id(unsigned i) const
911 {
912 return (def(i)->isId());
913 }
914
915 inline
idref(unsigned i)916 Boolean AttributeList::idref(unsigned i) const
917 {
918 return (def(i)->isIdref());
919 }
920
921 inline
specified(unsigned i)922 Boolean AttributeList::specified(unsigned i) const
923 {
924 return (vec_[i].specified());
925 }
926
927 inline
mayDefaultAttribute()928 Boolean AttributeContext::mayDefaultAttribute() const
929 {
930 return (mayDefaultAttribute_);
931 }
932
933 inline
validate()934 Boolean AttributeContext::validate() const
935 {
936 return (validate_);
937 }
938
939 #ifdef SP_NAMESPACE
940 }
941 #endif
942
943 #endif /* not Attribute_INCLUDED */
944
945 #endif /* _ATTRIBUTE_H */
946