cde/programs/nsgmls/Attribute.h

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