autodoc/source/parser_i/inc/s2_luidl/tk_keyw.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef ADC_UIDL_TK_KEYW_HXX
  21 #define ADC_UIDL_TK_KEYW_HXX
  22
  23 // USED SERVICES
  24     // BASE CLASSES
  25 #include <s2_luidl/uidl_tok.hxx>
  26     // COMPONENTS
  27 #include <luxenum.hxx>
  28     // PARAMETERS
  29
  30
  31 namespace csi
  32 {
  33 namespace uidl
  34 {
  35
  36
  37 class TokKeyword : public Token
  38 {
  39 };
  40
  41
  42 class TokBuiltInType : public TokKeyword
  43 {
  44   public:
  45     enum E_TokenId
  46     {
  47         e_none = 0,
  48         bty_any = 1,
  49         bty_boolean = 2,
  50         bty_byte = 3,
  51         bty_char = 4,
  52         bty_double = 5,
  53         bty_hyper = 6,
  54         bty_long = 7,
  55         bty_short = 8,
  56         bty_string = 9,
  57         bty_void = 10,
  58         bty_ellipse = 11
  59     };
  60     typedef lux::Enum<E_TokenId> EV_TokenId;
  61
  62                         TokBuiltInType(
  63                             EV_TokenId          i_eTag )
  64                                                 :   eTag(i_eTag) {}
  65
  66     virtual void        Trigger(
  67                             TokenInterpreter &  io_rInterpreter ) const;
  68     virtual const char *
  69                         Text() const;
  70     E_TokenId           Id() const              { return eTag; }
  71
  72   private:
  73     // DATA
  74     EV_TokenId          eTag;
  75 };
  76
  77
  78 class TokTypeModifier : public TokKeyword
  79 {
  80   public:
  81     enum E_TokenId
  82     {
  83         e_none = 0,
  84         tmod_unsigned = 1,
  85         tmod_sequence
  86     };
  87     typedef lux::Enum<E_TokenId> EV_TokenId;
  88
  89                         TokTypeModifier(
  90                             EV_TokenId          i_eTag )
  91                                                 :   eTag(i_eTag) {}
  92     virtual void        Trigger(
  93                             TokenInterpreter &  io_rInterpreter ) const;
  94     virtual const char *
  95                         Text() const;
  96     E_TokenId           Id() const              { return eTag; }
  97
  98   private:
  99     // DATA
 100     EV_TokenId          eTag;
 101 };
 102
 103 class TokMetaType : public TokKeyword
 104 {
 105   public:
 106     enum E_TokenId
 107     {
 108         e_none = 0,
 109         mt_attribute = 1,
 110         mt_constants,
 111         mt_enum,
 112         mt_exception,
 113         mt_ident,
 114         mt_interface,
 115         mt_module,
 116         mt_property,
 117         mt_service,
 118         mt_singleton,
 119         mt_struct,
 120         mt_typedef,
 121         mt_uik
 122     };
 123     typedef lux::Enum<E_TokenId> EV_TokenId;
 124
 125                         TokMetaType(
 126                             EV_TokenId          i_eTag )
 127                                                 :   eTag(i_eTag) {}
 128
 129     virtual void        Trigger(
 130                             TokenInterpreter &  io_rInterpreter ) const;
 131     virtual const char *
 132                         Text() const;
 133     E_TokenId           Id() const              { return eTag; }
 134
 135
 136   private:
 137     // DATA
 138     EV_TokenId          eTag;
 139 };
 140
 141 class TokStereotype : public TokKeyword
 142 {
 143   public:
 144     // TYPES
 145     enum E_TokenId
 146     {
 147         e_none = 0,
 148         ste_bound = 1,
 149         ste_const,
 150         ste_constrained,
 151         ste_maybeambiguous,
 152         ste_maybedefault,
 153         ste_maybevoid,
 154         ste_oneway,
 155         ste_optional,
 156         ste_readonly,
 157         ste_removable,
 158         ste_virtual,
 159         ste_transient,
 160         ste_published
 161     };
 162
 163     typedef lux::Enum<E_TokenId> EV_TokenId;
 164
 165                         TokStereotype(
 166                             EV_TokenId          i_eTag )
 167                                                 :   eTag(i_eTag) {}
 168     // OPERATIONS
 169     virtual void        Trigger(
 170                             TokenInterpreter &  io_rInterpreter ) const;
 171     // INQUIRY
 172     virtual const char *
 173                         Text() const;
 174     E_TokenId           Id() const              { return eTag; }
 175
 176   private:
 177     // DATA
 178     EV_TokenId          eTag;
 179 };
 180
 181 class TokParameterHandling : public TokKeyword
 182 {
 183   public:
 184     // TYPES
 185     enum E_TokenId
 186     {
 187         e_none = 0,
 188         ph_in,
 189         ph_out,
 190         ph_inout
 191     };
 192     typedef lux::Enum<E_TokenId> EV_TokenId;
 193
 194                         TokParameterHandling(
 195                             EV_TokenId          i_eTag )
 196                                                 :   eTag(i_eTag) {}
 197     // OPERATIONS
 198     virtual void        Trigger(
 199                             TokenInterpreter &  io_rInterpreter ) const;
 200     // INQUIRY
 201     virtual const char *
 202                         Text() const;
 203     E_TokenId           Id() const              { return eTag; }
 204
 205   private:
 206     // DATA
 207     EV_TokenId          eTag;
 208 };
 209
 210 class TokRaises : public TokKeyword
 211 {
 212   public:
 213     virtual void        Trigger(
 214                             TokenInterpreter &  io_rInterpreter ) const;
 215     virtual const char *
 216                         Text() const;
 217 };
 218
 219 class TokNeeds : public TokKeyword
 220 {
 221   public:
 222     virtual void        Trigger(
 223                             TokenInterpreter &  io_rInterpreter ) const;
 224     virtual const char *
 225                         Text() const;
 226 };
 227
 228 class TokObserves : public TokKeyword
 229 {
 230   public:
 231     virtual void        Trigger(
 232                             TokenInterpreter &  io_rInterpreter ) const;
 233     virtual const char *
 234                         Text() const;
 235 };
 236
 237
 238 }   // namespace uidl
 239 }   // namespace csi
 240
 241 #endif
 242
 243
 244 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */