compiler/cpp/src/parse/t_program.h

   1 // Copyright (c) 2006- Facebook
   2 // Distributed under the Thrift Software License
   3 //
   4 // See accompanying file LICENSE or visit the Thrift site at:
   5 // http://developers.facebook.com/thrift/
   6
   7 #ifndef T_PROGRAM_H
   8 #define T_PROGRAM_H
   9
  10 #include <map>
  11 #include <string>
  12 #include <vector>
  13
  14 // For program_name()
  15 #include "main.h"
  16
  17 #include "t_doc.h"
  18 #include "t_scope.h"
  19 #include "t_base_type.h"
  20 #include "t_typedef.h"
  21 #include "t_enum.h"
  22 #include "t_const.h"
  23 #include "t_struct.h"
  24 #include "t_service.h"
  25 #include "t_list.h"
  26 #include "t_map.h"
  27 #include "t_set.h"
  28 //#include "t_doc.h"
  29
  30 /**
  31  * Top level class representing an entire thrift program. A program consists
  32  * fundamentally of the following:
  33  *
  34  *   Typedefs
  35  *   Enumerations
  36  *   Constants
  37  *   Structs
  38  *   Exceptions
  39  *   Services
  40  *
  41  * The program module also contains the definitions of the base types.
  42  *
  43  * @author Mark Slee <mcslee@facebook.com>
  44  */
  45 class t_program : public t_doc {
  46  public:
  47   t_program(std::string path, std::string name) :
  48     path_(path),
  49     name_(name),
  50     out_path_("./") {
  51     scope_ = new t_scope();
  52   }
  53
  54   t_program(std::string path) :
  55     path_(path),
  56     out_path_("./") {
  57     name_ = program_name(path);
  58     scope_ = new t_scope();
  59   }
  60
  61   // Path accessor
  62   const std::string& get_path() const { return path_; }
  63
  64   // Output path accessor
  65   const std::string& get_out_path() const { return out_path_; }
  66
  67   // Name accessor
  68   const std::string& get_name() const { return name_; }
  69
  70   // Namespace
  71   const std::string& get_namespace() const { return namespace_; }
  72
  73   // Accessors for program elements
  74   const std::vector<t_typedef*>& get_typedefs()  const { return typedefs_;  }
  75   const std::vector<t_enum*>&    get_enums()     const { return enums_;     }
  76   const std::vector<t_const*>&   get_consts()    const { return consts_;    }
  77   const std::vector<t_struct*>&  get_structs()   const { return structs_;   }
  78   const std::vector<t_struct*>&  get_xceptions() const { return xceptions_; }
  79   const std::vector<t_service*>& get_services()  const { return services_;  }
  80
  81   // Program elements
  82   void add_typedef  (t_typedef* td) { typedefs_.push_back(td);  }
  83   void add_enum     (t_enum*    te) { enums_.push_back(te);     }
  84   void add_const    (t_const*   tc) { consts_.push_back(tc);    }
  85   void add_struct   (t_struct*  ts) { structs_.push_back(ts);   }
  86   void add_xception (t_struct*  tx) { xceptions_.push_back(tx); }
  87   void add_service  (t_service* ts) { services_.push_back(ts);  }
  88
  89   // Programs to include
  90   const std::vector<t_program*>& get_includes() const { return includes_; }
  91
  92   void set_out_path(std::string out_path) {
  93     out_path_ = out_path;
  94     // Ensure that it ends with a trailing '/' (or '\' for windows machines)
  95     char c = out_path_.at(out_path_.size() - 1);
  96     if (!(c == '/' || c == '\\')) {
  97       out_path_.push_back('/');
  98     }
  99   }
 100
 101   // Scoping and namespacing
 102   void set_namespace(std::string name) {
 103     namespace_ = name;
 104   }
 105
 106   // Scope accessor
 107   t_scope* scope() {
 108     return scope_;
 109   }
 110
 111   // Includes
 112
 113   void add_include(std::string path) {
 114     includes_.push_back(new t_program(path));
 115   }
 116
 117   std::vector<t_program*>& get_includes() {
 118     return includes_;
 119   }
 120
 121   // Language specific namespace / packaging
 122
 123   void set_cpp_namespace(std::string cpp_namespace) {
 124     cpp_namespace_ = cpp_namespace;
 125   }
 126
 127   const std::string& get_cpp_namespace() const {
 128     return cpp_namespace_;
 129   }
 130
 131   void add_cpp_include(std::string path) {
 132     cpp_includes_.push_back(path);
 133   }
 134
 135   const std::vector<std::string>& get_cpp_includes() {
 136     return cpp_includes_;
 137   }
 138
 139   void set_php_namespace(std::string php_namespace) {
 140     php_namespace_ = php_namespace;
 141   }
 142
 143   const std::string& get_php_namespace() const {
 144     return php_namespace_;
 145   }
 146
 147   void set_java_package(std::string java_package) {
 148     java_package_ = java_package;
 149   }
 150
 151   const std::string& get_java_package() const {
 152     return java_package_;
 153   }
 154
 155   void set_csharp_namespace(std::string csharp_namespace) {
 156     csharp_namespace_ = csharp_namespace;
 157   }
 158
 159   const std::string& get_csharp_namespace() const {
 160     return csharp_namespace_;
 161   }
 162
 163   void set_xsd_namespace(std::string xsd_namespace) {
 164     xsd_namespace_ = xsd_namespace;
 165   }
 166
 167   const std::string& get_xsd_namespace() const {
 168     return xsd_namespace_;
 169   }
 170
 171   void set_ruby_namespace(std::string ruby_namespace) {
 172     ruby_namespace_ = ruby_namespace;
 173   }
 174
 175   const std::string& get_ruby_namespace() const {
 176     return ruby_namespace_;
 177   }
 178
 179   void set_py_module(std::string py_module) {
 180     py_module_ = py_module;
 181   }
 182
 183   const std::string& get_py_module() const {
 184     return py_module_;
 185   }
 186
 187   void set_perl_package(std::string perl_package) {
 188     perl_package_ = perl_package;
 189   }
 190
 191   const std::string& get_perl_package() const {
 192     return perl_package_;
 193   }
 194
 195   void set_cocoa_prefix(std::string cocoa_prefix) {
 196     cocoa_prefix_ = cocoa_prefix;
 197   }
 198
 199   const std::string& get_cocoa_prefix() const {
 200     return cocoa_prefix_;
 201   }
 202
 203   void set_smalltalk_category(std::string smalltalk_category) {
 204     smalltalk_category_ = smalltalk_category;
 205   }
 206
 207   const std::string& get_smalltalk_category() const {
 208     return smalltalk_category_;
 209   }
 210
 211   void set_smalltalk_prefix(std::string smalltalk_prefix) {
 212     smalltalk_prefix_ = smalltalk_prefix;
 213   }
 214
 215   const std::string& get_smalltalk_prefix() const {
 216     return smalltalk_prefix_;
 217   }
 218
 219  private:
 220
 221   // File path
 222   std::string path_;
 223
 224   // Name
 225   std::string name_;
 226
 227   // Output directory
 228   std::string out_path_;
 229
 230   // Namespace
 231   std::string namespace_;
 232
 233   // Included programs
 234   std::vector<t_program*> includes_;
 235
 236   // Identifier lookup scope
 237   t_scope* scope_;
 238
 239   // Components to generate code for
 240   std::vector<t_typedef*> typedefs_;
 241   std::vector<t_enum*>    enums_;
 242   std::vector<t_const*>   consts_;
 243   std::vector<t_struct*>  structs_;
 244   std::vector<t_struct*>  xceptions_;
 245   std::vector<t_service*> services_;
 246
 247   // C++ namespace
 248   std::string cpp_namespace_;
 249
 250   // C++ extra includes
 251   std::vector<std::string> cpp_includes_;
 252
 253   // PHP namespace
 254   std::string php_namespace_;
 255
 256   // Java package
 257   std::string java_package_;
 258
 259   // XSD namespace
 260   std::string xsd_namespace_;
 261
 262   // Ruby namespace
 263   std::string ruby_namespace_;
 264
 265   // Python namespace
 266   std::string py_module_;
 267
 268   // Perl namespace
 269   std::string perl_package_;
 270
 271   // Cocoa/Objective-C naming prefix
 272   std::string cocoa_prefix_;
 273
 274   // Smalltalk category
 275   std::string smalltalk_category_;
 276   // Smalltalk prefix
 277   std::string smalltalk_prefix_;
 278
 279   // C# namespace
 280   std::string csharp_namespace_;
 281 };
 282
 283 #endif