cde/programs/nsgmls/Group.h

   1 /* $XConsortium: Group.h /main/1 1996/07/29 16:52:34 cde-hp $ */
   2 // Copyright (c) 1994 James Clark
   3 // See the file COPYING for copying permission.
   4
   5 #ifndef Group_INCLUDED
   6 #define Group_INCLUDED 1
   7 #ifdef __GNUG__
   8 #pragma interface
   9 #endif
  10
  11 #include "Boolean.h"
  12 #include "ContentToken.h"
  13 #include "StringC.h"
  14 #include "MessageArg.h"
  15 #include "Owner.h"
  16 #include "Syntax.h"
  17 #include "Text.h"
  18
  19 #ifdef SP_NAMESPACE
  20 namespace SP_NAMESPACE {
  21 #endif
  22
  23 class GroupToken {
  24 public:
  25   GroupToken() { }
  26   enum Type {
  27     invalid,
  28     nameToken,
  29     name,
  30     dataTagLiteral,             // data tag (padding) template
  31     dataTagGroup,
  32     elementToken,
  33     modelGroup,
  34     pcdata,
  35     dataTagTemplateGroup
  36     };
  37   Type type;
  38   StringC token;                // name nameToken; with substitution
  39   Owner<ModelGroup> model;
  40   Owner<ContentToken> contentToken; // elementToken pcdata dataTagGroup
  41   Text text;
  42   Vector<Text> textVector;
  43 private:
  44   GroupToken(const GroupToken &); // undefined
  45   void operator=(const GroupToken &); // undefined
  46 };
  47
  48 class AllowedGroupTokens {
  49 public:
  50   AllowedGroupTokens(GroupToken::Type,
  51                      GroupToken::Type = GroupToken::invalid,
  52                      GroupToken::Type = GroupToken::invalid,
  53                      GroupToken::Type = GroupToken::invalid);
  54   Boolean groupToken(GroupToken::Type) const;
  55   // modelGroup, dataTagTemplateGroup
  56   GroupToken::Type group() const;
  57   GroupToken::Type nameStart() const;
  58 private:
  59   void allow(GroupToken::Type);
  60   unsigned flags_;
  61 };
  62
  63 struct GroupConnector {
  64   enum Type {
  65     andGC,
  66     orGC,
  67     seqGC,
  68     grpcGC,
  69     dtgcGC
  70   };
  71   Type type;
  72 };
  73
  74 class AllowedGroupConnectors {
  75 public:
  76   AllowedGroupConnectors(GroupConnector::Type);
  77   AllowedGroupConnectors(GroupConnector::Type, GroupConnector::Type);
  78   AllowedGroupConnectors(GroupConnector::Type, GroupConnector::Type,
  79                          GroupConnector::Type);
  80   AllowedGroupConnectors(GroupConnector::Type, GroupConnector::Type,
  81                          GroupConnector::Type, GroupConnector::Type);
  82   Boolean groupConnector(GroupConnector::Type) const;
  83 private:
  84   void allow(GroupConnector::Type);
  85   unsigned flags_;
  86 };
  87
  88 class AllowedGroupTokensMessageArg : public MessageArg {
  89 public:
  90   AllowedGroupTokensMessageArg(const AllowedGroupTokens &allow,
  91                                const ConstPtr<Syntax> &syntax);
  92   MessageArg *copy() const;
  93   void append(MessageBuilder &) const;
  94 private:
  95   AllowedGroupTokens allow_;
  96   ConstPtr<Syntax> syntax_;
  97 };
  98
  99 class AllowedGroupConnectorsMessageArg : public MessageArg {
 100 public:
 101   AllowedGroupConnectorsMessageArg(const AllowedGroupConnectors &allow,
 102                                    const ConstPtr<Syntax> &syntax);
 103   MessageArg *copy() const;
 104   void append(MessageBuilder &) const;
 105 private:
 106   AllowedGroupConnectors allow_;
 107   ConstPtr<Syntax> syntax_;
 108 };
 109
 110 inline
 111 Boolean AllowedGroupTokens::groupToken(GroupToken::Type i) const
 112 {
 113   return ((1 << i) & flags_) != 0;
 114 }
 115
 116 inline
 117 GroupToken::Type AllowedGroupTokens::group() const
 118 {
 119   if (groupToken(GroupToken::modelGroup))
 120     return GroupToken::modelGroup;
 121   else if (groupToken(GroupToken::dataTagTemplateGroup))
 122     return GroupToken::dataTagTemplateGroup;
 123   else
 124     return GroupToken::invalid;
 125 }
 126
 127 inline
 128 GroupToken::Type AllowedGroupTokens::nameStart() const
 129 {
 130   if (groupToken(GroupToken::elementToken))
 131     return GroupToken::elementToken;
 132   else if (groupToken(GroupToken::nameToken))
 133     return GroupToken::nameToken;
 134   else if (groupToken(GroupToken::name))
 135     return GroupToken::name;
 136   else
 137     return GroupToken::invalid;
 138 }
 139
 140 inline
 141 void AllowedGroupTokens::allow(GroupToken::Type t)
 142 {
 143   flags_ |= (1 << t);
 144 }
 145
 146
 147 inline
 148 Boolean AllowedGroupConnectors::groupConnector(GroupConnector::Type c) const
 149 {
 150   return (flags_ & (1 << c)) != 0;
 151 }
 152
 153 inline
 154 void AllowedGroupConnectors::allow(GroupConnector::Type c)
 155 {
 156   flags_ |= (1 << c);
 157 }
 158
 159
 160 #ifdef SP_NAMESPACE
 161 }
 162 #endif
 163
 164 #endif /* not Group_INCLUDED */