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