compiler/cpp/src/generate/t_cpp_generator.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_CPP_GENERATOR_H
   8 #define T_CPP_GENERATOR_H
   9
  10 #include <string>
  11 #include <fstream>
  12 #include <iostream>
  13 #include <vector>
  14
  15 #include "t_oop_generator.h"
  16
  17 /**
  18  * C++ code generator. This is legitimacy incarnate.
  19  *
  20  * @author Mark Slee <mcslee@facebook.com>
  21  */
  22 class t_cpp_generator : public t_oop_generator {
  23  public:
  24   t_cpp_generator(t_program* program, bool gen_dense) :
  25     t_oop_generator(program),
  26     gen_dense_(gen_dense),
  27     use_include_prefix_(false) {
  28
  29     out_dir_base_ = "gen-cpp";
  30   }
  31
  32   /**
  33    * Init and close methods
  34    */
  35
  36   void init_generator();
  37   void close_generator();
  38
  39   void generate_consts(std::vector<t_const*> consts);
  40
  41   /**
  42    * Program-level generation functions
  43    */
  44
  45   void generate_typedef(t_typedef* ttypedef);
  46   void generate_enum(t_enum* tenum);
  47   void generate_struct(t_struct* tstruct) {
  48     generate_cpp_struct(tstruct, false);
  49   }
  50   void generate_xception(t_struct* txception) {
  51     generate_cpp_struct(txception, true);
  52   }
  53   void generate_cpp_struct(t_struct* tstruct, bool is_exception);
  54
  55   void generate_service(t_service* tservice);
  56
  57   void print_const_value(std::ofstream& out, std::string name, t_type* type, t_const_value* value);
  58   std::string render_const_value(std::ofstream& out, std::string name, t_type* type, t_const_value* value);
  59
  60   void generate_struct_definition    (std::ofstream& out, t_struct* tstruct, bool is_exception=false, bool pointers=false, bool read=true, bool write=true);
  61   void generate_struct_fingerprint   (std::ofstream& out, t_struct* tstruct, bool is_definition);
  62   void generate_struct_reader        (std::ofstream& out, t_struct* tstruct, bool pointers=false);
  63   void generate_struct_writer        (std::ofstream& out, t_struct* tstruct, bool pointers=false);
  64   void generate_struct_result_writer (std::ofstream& out, t_struct* tstruct, bool pointers=false);
  65
  66   /**
  67    * Service-level generation functions
  68    */
  69
  70   void generate_service_interface (t_service* tservice);
  71   void generate_service_null      (t_service* tservice);
  72   void generate_service_multiface (t_service* tservice);
  73   void generate_service_helpers   (t_service* tservice);
  74   void generate_service_client    (t_service* tservice);
  75   void generate_service_processor (t_service* tservice);
  76   void generate_service_skeleton  (t_service* tservice);
  77   void generate_process_function  (t_service* tservice, t_function* tfunction);
  78   void generate_function_helpers  (t_service* tservice, t_function* tfunction);
  79
  80   void generate_service_limited_reflector(t_service* tservice);
  81   bool generate_type_limited_reflection(t_type* ttype, std::string target);
  82   bool generate_simple_type_limited_reflection(std::ostream& out, t_type* ttype, std::string target);
  83
  84   /**
  85    * Serialization constructs
  86    */
  87
  88   void generate_deserialize_field        (std::ofstream& out,
  89                                           t_field*    tfield,
  90                                           std::string prefix="",
  91                                           std::string suffix="");
  92
  93   void generate_deserialize_struct       (std::ofstream& out,
  94                                           t_struct*   tstruct,
  95                                           std::string prefix="");
  96
  97   void generate_deserialize_container    (std::ofstream& out,
  98                                           t_type*     ttype,
  99                                           std::string prefix="");
 100
 101   void generate_deserialize_set_element  (std::ofstream& out,
 102                                           t_set*      tset,
 103                                           std::string prefix="");
 104
 105   void generate_deserialize_map_element  (std::ofstream& out,
 106                                           t_map*      tmap,
 107                                           std::string prefix="");
 108
 109   void generate_deserialize_list_element (std::ofstream& out,
 110                                           t_list*     tlist,
 111                                           std::string prefix,
 112                                           std::string index);
 113
 114   void generate_serialize_field          (std::ofstream& out,
 115                                           t_field*    tfield,
 116                                           std::string prefix="",
 117                                           std::string suffix="");
 118
 119   void generate_serialize_struct         (std::ofstream& out,
 120                                           t_struct*   tstruct,
 121                                           std::string prefix="");
 122
 123   void generate_serialize_container      (std::ofstream& out,
 124                                           t_type*     ttype,
 125                                           std::string prefix="");
 126
 127   void generate_serialize_map_element    (std::ofstream& out,
 128                                           t_map*      tmap,
 129                                           std::string iter);
 130
 131   void generate_serialize_set_element    (std::ofstream& out,
 132                                           t_set*      tmap,
 133                                           std::string iter);
 134
 135   void generate_serialize_list_element   (std::ofstream& out,
 136                                           t_list*     tlist,
 137                                           std::string iter);
 138
 139   /**
 140    * Helper rendering functions
 141    */
 142
 143   std::string namespace_prefix(std::string ns);
 144   std::string namespace_open(std::string ns);
 145   std::string namespace_close(std::string ns);
 146   std::string type_name(t_type* ttype, bool in_typedef=false, bool arg=false);
 147   std::string base_type_name(t_base_type::t_base tbase);
 148   std::string declare_field(t_field* tfield, bool init=false, bool pointer=false, bool constant=false, bool reference=false);
 149   std::string function_signature(t_function* tfunction, std::string prefix="");
 150   std::string argument_list(t_struct* tstruct);
 151   std::string type_to_enum(t_type* ttype);
 152   std::string local_reflection_name(const char*, t_type* ttype);
 153
 154   // These handles checking gen_dense_ and checking for duplicates.
 155   void generate_local_reflection(std::ofstream& out, t_type* ttype, bool is_definition);
 156   void generate_local_reflection_pointer(std::ofstream& out, t_type* ttype);
 157
 158   bool is_complex_type(t_type* ttype) {
 159     ttype = get_true_type(ttype);
 160
 161     return
 162       ttype->is_container() ||
 163       ttype->is_struct() ||
 164       ttype->is_xception() ||
 165       (ttype->is_base_type() && (((t_base_type*)ttype)->get_base() == t_base_type::TYPE_STRING));
 166   }
 167
 168   void set_use_include_prefix(bool use_include_prefix) {
 169     use_include_prefix_ = use_include_prefix;
 170   }
 171
 172  private:
 173   /**
 174    * Returns the include prefix to use for a file generated by program, or the
 175    * empty string if no include prefix should be used.
 176    */
 177   std::string get_include_prefix(const t_program& program) const;
 178
 179   /**
 180    * True iff we should generate local reflection metadata for TDenseProtocol.
 181    */
 182   bool gen_dense_;
 183
 184   /**
 185    * True iff we should use a path prefix in our #include statements for other
 186    * thrift-generated header files.
 187    */
 188   bool use_include_prefix_;
 189
 190   /**
 191    * Strings for namespace, computed once up front then used directly
 192    */
 193
 194   std::string ns_open_;
 195   std::string ns_close_;
 196
 197   /**
 198    * File streams, stored here to avoid passing them as parameters to every
 199    * function.
 200    */
 201
 202   std::ofstream f_types_;
 203   std::ofstream f_types_impl_;
 204   std::ofstream f_header_;
 205   std::ofstream f_service_;
 206
 207   /**
 208    * When generating local reflections, make sure we don't generate duplicates.
 209    */
 210   std::set<std::string> reflected_fingerprints_;
 211 };
 212
 213 #endif