include/flatbuffers/code_generators.h

   1 /*
   2  * Copyright 2014 Google Inc. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef FLATBUFFERS_CODE_GENERATORS_H_
  18 #define FLATBUFFERS_CODE_GENERATORS_H_
  19
  20 #include <map>
  21 #include <sstream>
  22
  23 #include "flatbuffers/idl.h"
  24
  25 namespace flatbuffers {
  26
  27 // Utility class to assist in generating code through use of text templates.
  28 //
  29 // Example code:
  30 //   CodeWriter code("\t");
  31 //   code.SetValue("NAME", "Foo");
  32 //   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
  33 //   code.SetValue("NAME", "Bar");
  34 //   code += "void {{NAME}}() { printf("%s", "{{NAME}}"); }";
  35 //   std::cout << code.ToString() << std::endl;
  36 //
  37 // Output:
  38 //  void Foo() { printf("%s", "Foo"); }
  39 //  void Bar() { printf("%s", "Bar"); }
  40 class CodeWriter {
  41  public:
  42   CodeWriter(std::string pad = std::string())
  43       : pad_(pad), cur_ident_lvl_(0), ignore_ident_(false) {}
  44
  45   // Clears the current "written" code.
  46   void Clear() {
  47     stream_.str("");
  48     stream_.clear();
  49   }
  50
  51   // Associates a key with a value.  All subsequent calls to operator+=, where
  52   // the specified key is contained in {{ and }} delimiters will be replaced by
  53   // the given value.
  54   void SetValue(const std::string &key, const std::string &value) {
  55     value_map_[key] = value;
  56   }
  57
  58   std::string GetValue(const std::string &key) const {
  59     const auto it = value_map_.find(key);
  60     return it == value_map_.end() ? "" : it->second;
  61   }
  62
  63   // Appends the given text to the generated code as well as a newline
  64   // character.  Any text within {{ and }} delimeters is replaced by values
  65   // previously stored in the CodeWriter by calling SetValue above.  The newline
  66   // will be suppressed if the text ends with the \\ character.
  67   void operator+=(std::string text);
  68
  69   // Returns the current contents of the CodeWriter as a std::string.
  70   std::string ToString() const { return stream_.str(); }
  71
  72   // Increase ident level for writing code
  73   void IncrementIdentLevel() { cur_ident_lvl_++; }
  74   // Decrease ident level for writing code
  75   void DecrementIdentLevel() {
  76     if (cur_ident_lvl_) cur_ident_lvl_--;
  77   }
  78
  79  private:
  80   std::map<std::string, std::string> value_map_;
  81   std::stringstream stream_;
  82   std::string pad_;
  83   int cur_ident_lvl_;
  84   bool ignore_ident_;
  85
  86   // Add ident padding (tab or space) based on ident level
  87   void AppendIdent(std::stringstream &stream);
  88 };
  89
  90 class BaseGenerator {
  91  public:
  92   virtual bool generate() = 0;
  93
  94   static std::string NamespaceDir(const Parser &parser, const std::string &path,
  95                                   const Namespace &ns);
  96
  97  protected:
  98   BaseGenerator(const Parser &parser, const std::string &path,
  99                 const std::string &file_name, std::string qualifying_start,
 100                 std::string qualifying_separator)
 101       : parser_(parser),
 102         path_(path),
 103         file_name_(file_name),
 104         qualifying_start_(qualifying_start),
 105         qualifying_separator_(qualifying_separator) {}
 106   virtual ~BaseGenerator() {}
 107
 108   // No copy/assign.
 109   BaseGenerator &operator=(const BaseGenerator &);
 110   BaseGenerator(const BaseGenerator &);
 111
 112   std::string NamespaceDir(const Namespace &ns) const;
 113
 114   static const char *FlatBuffersGeneratedWarning();
 115
 116   static std::string FullNamespace(const char *separator, const Namespace &ns);
 117
 118   static std::string LastNamespacePart(const Namespace &ns);
 119
 120   // tracks the current namespace for early exit in WrapInNameSpace
 121   // c++, java and csharp returns a different namespace from
 122   // the following default (no early exit, always fully qualify),
 123   // which works for js and php
 124   virtual const Namespace *CurrentNameSpace() const { return nullptr; }
 125
 126   // Ensure that a type is prefixed with its namespace even within
 127   // its own namespace to avoid conflict between generated method
 128   // names and similarly named classes or structs
 129   std::string WrapInNameSpace(const Namespace *ns,
 130                               const std::string &name) const;
 131
 132   std::string WrapInNameSpace(const Definition &def) const;
 133
 134   std::string GetNameSpace(const Definition &def) const;
 135
 136   const Parser &parser_;
 137   const std::string &path_;
 138   const std::string &file_name_;
 139   const std::string qualifying_start_;
 140   const std::string qualifying_separator_;
 141 };
 142
 143 struct CommentConfig {
 144   const char *first_line;
 145   const char *content_line_prefix;
 146   const char *last_line;
 147 };
 148
 149 extern void GenComment(const std::vector<std::string> &dc,
 150                        std::string *code_ptr, const CommentConfig *config,
 151                        const char *prefix = "");
 152
 153 class FloatConstantGenerator {
 154  public:
 155   virtual ~FloatConstantGenerator() {}
 156   std::string GenFloatConstant(const FieldDef &field) const;
 157
 158  private:
 159   virtual std::string Value(double v, const std::string &src) const = 0;
 160   virtual std::string Inf(double v) const = 0;
 161   virtual std::string NaN(double v) const = 0;
 162
 163   virtual std::string Value(float v, const std::string &src) const = 0;
 164   virtual std::string Inf(float v) const = 0;
 165   virtual std::string NaN(float v) const = 0;
 166
 167   template<typename T>
 168   std::string GenFloatConstantImpl(const FieldDef &field) const;
 169 };
 170
 171 class SimpleFloatConstantGenerator : public FloatConstantGenerator {
 172  public:
 173   SimpleFloatConstantGenerator(const char *nan_number,
 174                                const char *pos_inf_number,
 175                                const char *neg_inf_number);
 176
 177  private:
 178   std::string Value(double v,
 179                     const std::string &src) const FLATBUFFERS_OVERRIDE;
 180   std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
 181   std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
 182
 183   std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
 184   std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
 185   std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
 186
 187   const std::string nan_number_;
 188   const std::string pos_inf_number_;
 189   const std::string neg_inf_number_;
 190 };
 191
 192 // C++, C#, Java like generator.
 193 class TypedFloatConstantGenerator : public FloatConstantGenerator {
 194  public:
 195   TypedFloatConstantGenerator(const char *double_prefix,
 196                               const char *single_prefix, const char *nan_number,
 197                               const char *pos_inf_number,
 198                               const char *neg_inf_number = "");
 199
 200  private:
 201   std::string Value(double v,
 202                     const std::string &src) const FLATBUFFERS_OVERRIDE;
 203   std::string Inf(double v) const FLATBUFFERS_OVERRIDE;
 204
 205   std::string NaN(double v) const FLATBUFFERS_OVERRIDE;
 206
 207   std::string Value(float v, const std::string &src) const FLATBUFFERS_OVERRIDE;
 208   std::string Inf(float v) const FLATBUFFERS_OVERRIDE;
 209   std::string NaN(float v) const FLATBUFFERS_OVERRIDE;
 210
 211   std::string MakeNaN(const std::string &prefix) const;
 212   std::string MakeInf(bool neg, const std::string &prefix) const;
 213
 214   const std::string double_prefix_;
 215   const std::string single_prefix_;
 216   const std::string nan_number_;
 217   const std::string pos_inf_number_;
 218   const std::string neg_inf_number_;
 219 };
 220
 221 }  // namespace flatbuffers
 222
 223 #endif  // FLATBUFFERS_CODE_GENERATORS_H_