cde/programs/nsgmls/Dtd.h

   1 /* $XConsortium: Dtd.h /main/1 1996/07/29 16:49:16 cde-hp $ */
   2 // Copyright (c) 1994 James Clark
   3 // See the file COPYING for copying permission.
   4
   5 #ifndef Dtd_INCLUDED
   6 #define Dtd_INCLUDED 1
   7 #ifdef __GNUG__
   8 #pragma interface
   9 #endif
  10
  11 #include "NamedTable.h"
  12 #include "NamedResourceTable.h"
  13 #include "ElementType.h"
  14 #include "Notation.h"
  15 #include "Entity.h"
  16 #include "ShortReferenceMap.h"
  17 #include "Resource.h"
  18 #include "StringC.h"
  19 #include "StringResource.h"
  20 #include "Boolean.h"
  21 #include "Vector.h"
  22 #include "HashTable.h"
  23
  24 #ifdef SP_NAMESPACE
  25 namespace SP_NAMESPACE {
  26 #endif
  27
  28 class Syntax;
  29 class ParserState;
  30
  31 class SP_API Dtd : public Resource {
  32 public:
  33   typedef NamedTableIter<ElementType> ElementTypeIter;
  34   typedef ConstNamedTableIter<ElementType> ConstElementTypeIter;
  35   typedef NamedTableIter<ShortReferenceMap> ShortReferenceMapIter;
  36   typedef ConstNamedResourceTableIter<Notation> ConstNotationIter;
  37   typedef NamedResourceTableIter<Notation> NotationIter;
  38   typedef ConstNamedResourceTableIter<Entity> ConstEntityIter;
  39   typedef NamedResourceTableIter<Entity> EntityIter;
  40   Dtd(const StringC &name, Boolean isBase);
  41   ConstPtr<Entity> lookupEntity(Boolean isParameter, const StringC &) const;
  42   const Entity *lookupEntityTemp(Boolean isParameter, const StringC &) const;
  43   Ptr<Entity> lookupEntity(Boolean isParameter, const StringC &);
  44   Ptr<Entity> insertEntity(const Ptr<Entity> &, Boolean replace = 0);
  45   Ptr<Entity> removeEntity(Boolean isParameter, const StringC &);
  46   ConstEntityIter generalEntityIter() const;
  47   EntityIter generalEntityIter();
  48   ConstEntityIter parameterEntityIter() const;
  49   EntityIter parameterEntityIter();
  50
  51   ConstPtr<Entity> defaultEntity() const;
  52   const Entity *defaultEntityTemp() const;
  53   void setDefaultEntity(const Ptr<Entity> &, ParserState &);
  54   const ConstPtr<StringResource<Char> > &namePointer() const;
  55   const StringC &name() const;
  56
  57   const ElementType *lookupElementType(const StringC &) const;
  58   ElementType *lookupElementType(const StringC &);
  59   ElementType *removeElementType(const StringC &);
  60   ElementType *insertElementType(ElementType *);
  61   size_t nElementTypeIndex() const;
  62   ConstElementTypeIter elementTypeIter() const;
  63   ElementTypeIter elementTypeIter();
  64
  65   const RankStem *lookupRankStem(const StringC &) const;
  66   RankStem *lookupRankStem(const StringC &);
  67   RankStem *insertRankStem(RankStem *);
  68   size_t nRankStem() const;
  69
  70   const ShortReferenceMap *lookupShortReferenceMap(const StringC &) const;
  71   ShortReferenceMap *lookupShortReferenceMap(const StringC &);
  72   ShortReferenceMap *insertShortReferenceMap(ShortReferenceMap *);
  73   ShortReferenceMapIter shortReferenceMapIter();
  74
  75   Boolean shortrefIndex(const StringC &, const Syntax &, size_t &index);
  76   size_t nShortref() const;
  77   const StringC &shortref(size_t i) const;
  78   void addNeededShortref(const StringC &);
  79
  80   ConstPtr<Notation> lookupNotation(const StringC &) const;
  81   const Notation *lookupNotationTemp(const StringC &) const;
  82   Ptr<Notation> lookupNotation(const StringC &);
  83   Ptr<Notation> insertNotation(const Ptr<Notation> &);
  84   Ptr<Notation> removeNotation(const StringC &);
  85   ConstNotationIter notationIter() const;
  86   NotationIter notationIter();
  87
  88   size_t allocCurrentAttributeIndex();
  89   size_t nCurrentAttribute() const;
  90   size_t allocElementDefinitionIndex();
  91   size_t nElementDefinition() const;
  92   size_t allocAttributeDefinitionListIndex();
  93   size_t nAttributeDefinitionList() const;
  94   const ElementType *documentElementType() const;
  95   Boolean isBase() const;
  96 private:
  97   Dtd(const Dtd &);             // undefined
  98   void operator=(const Dtd &);  // undefined
  99   NamedResourceTable<Entity> generalEntityTable_;
 100   NamedResourceTable<Entity> parameterEntityTable_;
 101   ConstPtr<Entity> defaultEntity_;
 102   ConstPtr<StringResource<Char> > name_;
 103   NamedTable<ElementType> elementTypeTable_;
 104   NamedTable<RankStem> rankStemTable_;
 105   NamedTable<ShortReferenceMap> shortReferenceMapTable_;
 106   NamedResourceTable<Notation> notationTable_;
 107   size_t nCurrentAttribute_;
 108   size_t nElementDefinition_;
 109   size_t nAttributeDefinitionList_;
 110   ElementType *documentElementType_;
 111   Vector<StringC> shortrefs_;
 112   HashTable<StringC,int> shortrefTable_;
 113   Boolean isBase_;
 114 };
 115
 116 inline
 117 ConstPtr<Entity> Dtd::lookupEntity(Boolean isParameter, const StringC &name)
 118   const
 119 {
 120   return (isParameter
 121           ? &parameterEntityTable_
 122           : &generalEntityTable_)->lookupConst(name);
 123 }
 124
 125 inline
 126 const Entity *Dtd::lookupEntityTemp(Boolean isParameter, const StringC &name)
 127   const
 128 {
 129   return (isParameter
 130           ? &parameterEntityTable_
 131           : &generalEntityTable_)->lookupTemp(name);
 132 }
 133
 134 inline
 135 Ptr<Entity> Dtd::lookupEntity(Boolean isParameter, const StringC &name)
 136 {
 137   return (isParameter
 138           ? &parameterEntityTable_
 139           : &generalEntityTable_)->lookup(name);
 140 }
 141
 142 inline
 143 Ptr<Entity>
 144 Dtd::insertEntity(const Ptr<Entity> &entity, Boolean replace)
 145 {
 146   return (entity->declType() == Entity::parameterEntity
 147           ? &parameterEntityTable_
 148           : &generalEntityTable_)->insert(entity, replace);
 149 }
 150
 151 inline
 152 Ptr<Entity> Dtd::removeEntity(Boolean isParameter, const StringC &name)
 153 {
 154   return (isParameter
 155           ? &parameterEntityTable_
 156           : &generalEntityTable_)->remove(name);
 157 }
 158
 159 inline
 160 Dtd::ConstEntityIter Dtd::generalEntityIter() const
 161 {
 162   // Avoid use of typedef to work around MSVC 2.0 bug.
 163   return ConstNamedResourceTableIter<Entity>(generalEntityTable_);
 164 }
 165
 166 inline
 167 Dtd::EntityIter Dtd::generalEntityIter()
 168 {
 169   // Avoid use of typedef to work around MSVC 2.0 bug.
 170   return NamedResourceTableIter<Entity>(generalEntityTable_);
 171 }
 172
 173 inline
 174 Dtd::ConstEntityIter Dtd::parameterEntityIter() const
 175 {
 176   // Avoid use of typedef to work around MSVC 2.0 bug.
 177   return ConstNamedResourceTableIter<Entity>(parameterEntityTable_);
 178 }
 179
 180 inline
 181 Dtd::EntityIter Dtd::parameterEntityIter()
 182 {
 183   // Avoid use of typedef to work around MSVC 2.0 bug.
 184   return NamedResourceTableIter<Entity>(parameterEntityTable_);
 185 }
 186
 187 inline
 188 ConstPtr<Entity> Dtd::defaultEntity() const
 189 {
 190   return defaultEntity_;
 191 }
 192
 193 inline
 194 const Entity *Dtd::defaultEntityTemp() const
 195 {
 196   return defaultEntity_.pointer();
 197 }
 198
 199 inline
 200 const ConstPtr<StringResource<Char> > &Dtd::namePointer() const
 201 {
 202   return name_;
 203 }
 204
 205 inline
 206 const StringC &Dtd::name() const
 207 {
 208   return *name_;
 209 }
 210
 211 inline
 212 size_t Dtd::allocCurrentAttributeIndex()
 213 {
 214   return nCurrentAttribute_++;
 215 }
 216
 217 inline
 218 size_t Dtd::nCurrentAttribute() const
 219 {
 220   return nCurrentAttribute_;
 221 }
 222
 223 inline
 224 size_t Dtd::allocElementDefinitionIndex()
 225 {
 226   return nElementDefinition_++;
 227 }
 228
 229 inline
 230 size_t Dtd::nElementDefinition() const
 231 {
 232   return nElementDefinition_;
 233 }
 234
 235 inline
 236 size_t Dtd::allocAttributeDefinitionListIndex()
 237 {
 238   return nAttributeDefinitionList_++;
 239 }
 240
 241 inline
 242 size_t Dtd::nAttributeDefinitionList() const
 243 {
 244   return nAttributeDefinitionList_;
 245 }
 246
 247 inline
 248 const ElementType *Dtd::lookupElementType(const StringC &name) const
 249 {
 250   return elementTypeTable_.lookup(name);
 251 }
 252
 253 inline
 254 ElementType *Dtd::lookupElementType(const StringC &name)
 255 {
 256   return elementTypeTable_.lookup(name);
 257 }
 258
 259 inline
 260 ElementType *Dtd::insertElementType(ElementType *e)
 261 {
 262   return elementTypeTable_.insert(e);
 263 }
 264
 265 inline
 266 Dtd::ElementTypeIter Dtd::elementTypeIter()
 267 {
 268   // Avoid use of typedef to work around MSVC 2.0 bug.
 269   return NamedTableIter<ElementType>(elementTypeTable_);
 270 }
 271
 272 inline
 273 Dtd::ConstElementTypeIter Dtd::elementTypeIter() const
 274 {
 275   // Avoid use of typedef to work around MSVC 2.0 bug.
 276   return ConstNamedTableIter<ElementType>(elementTypeTable_);
 277 }
 278
 279 inline
 280 ElementType *Dtd::removeElementType(const StringC &name)
 281 {
 282   return elementTypeTable_.remove(name);
 283 }
 284
 285 inline
 286 size_t Dtd::nElementTypeIndex() const
 287 {
 288   // index 0 is reserved for #pcdata
 289   return 1 + elementTypeTable_.count();
 290 }
 291
 292 inline
 293 const RankStem *Dtd::lookupRankStem(const StringC &name) const
 294 {
 295   return rankStemTable_.lookup(name);
 296 }
 297
 298 inline
 299 RankStem *Dtd::lookupRankStem(const StringC &name)
 300 {
 301   return rankStemTable_.lookup(name);
 302 }
 303
 304 inline
 305 RankStem *Dtd::insertRankStem(RankStem *e)
 306 {
 307   return rankStemTable_.insert(e);
 308 }
 309
 310 inline
 311 size_t Dtd::nRankStem() const
 312 {
 313   return rankStemTable_.count();
 314 }
 315
 316 inline
 317 ConstPtr<Notation> Dtd::lookupNotation(const StringC &name) const
 318 {
 319   return notationTable_.lookupConst(name);
 320 }
 321
 322 inline
 323 const Notation *Dtd::lookupNotationTemp(const StringC &name) const
 324 {
 325   return notationTable_.lookupTemp(name);
 326 }
 327
 328 inline
 329 Ptr<Notation> Dtd::lookupNotation(const StringC &name)
 330 {
 331   return notationTable_.lookup(name);
 332 }
 333
 334 inline
 335 Ptr<Notation> Dtd::insertNotation(const Ptr<Notation> &nt)
 336 {
 337   return notationTable_.insert(nt);
 338 }
 339
 340 inline
 341 Dtd::ConstNotationIter Dtd::notationIter() const
 342 {
 343   // Avoid use of typedef to work around MSVC 2.0 bug.
 344   return ConstNamedResourceTableIter<Notation>(notationTable_);
 345 }
 346
 347 inline
 348 Dtd::NotationIter Dtd::notationIter()
 349 {
 350   // Avoid use of typedef to work around MSVC 2.0 bug.
 351   return NamedResourceTableIter<Notation>(notationTable_);
 352 }
 353
 354 inline
 355 Ptr<Notation> Dtd::removeNotation(const StringC &name)
 356 {
 357   return notationTable_.remove(name);
 358 }
 359
 360 inline
 361 const ElementType *Dtd::documentElementType() const
 362 {
 363   return documentElementType_;
 364 }
 365
 366 inline
 367 const ShortReferenceMap *Dtd::lookupShortReferenceMap(const StringC &name) const
 368 {
 369   return shortReferenceMapTable_.lookup(name);
 370 }
 371
 372 inline
 373 ShortReferenceMap *Dtd::lookupShortReferenceMap(const StringC &name)
 374 {
 375   return shortReferenceMapTable_.lookup(name);
 376 }
 377
 378 inline
 379 ShortReferenceMap *Dtd::insertShortReferenceMap(ShortReferenceMap *map)
 380 {
 381   return shortReferenceMapTable_.insert(map);
 382 }
 383
 384 inline
 385 Dtd::ShortReferenceMapIter Dtd::shortReferenceMapIter()
 386 {
 387   // Avoid use of typedef to work around MSVC 2.0 bug.
 388   return NamedTableIter<ShortReferenceMap>(shortReferenceMapTable_);
 389 }
 390
 391 inline
 392 Boolean Dtd::isBase() const
 393 {
 394   return isBase_;
 395 }
 396
 397 inline
 398 size_t Dtd::nShortref() const
 399 {
 400   return shortrefs_.size();
 401 }
 402
 403 inline
 404 const StringC &Dtd::shortref(size_t i) const
 405 {
 406   return shortrefs_[i];
 407 }
 408
 409 #ifdef SP_NAMESPACE
 410 }
 411 #endif
 412
 413 #endif /* not Dtd_INCLUDED */