auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/compiler/cpp/src/generate/t_generator.cc

@@ -1,173 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "t_generator.h"
-using namespace std;
-
-/**
- * Top level program generation function. Calls the generator subclass methods
- * for preparing file streams etc. then iterates over all the parts of the
- * program to perform the correct actions.
- *
- * @param program The thrift program to compile into C++ source
- */
-void t_generator::generate_program() {
-  // Initialize the generator
-  init_generator();
-
-  // Generate enums
-  vector<t_enum*> enums = program_->get_enums();
-  vector<t_enum*>::iterator en_iter;
-  for (en_iter = enums.begin(); en_iter != enums.end(); ++en_iter) {
-    generate_enum(*en_iter);
-  }
-
-  // Generate typedefs
-  vector<t_typedef*> typedefs = program_->get_typedefs();
-  vector<t_typedef*>::iterator td_iter;
-  for (td_iter = typedefs.begin(); td_iter != typedefs.end(); ++td_iter) {
-    generate_typedef(*td_iter);
-  }
-
-  // Generate constants
-  vector<t_const*> consts = program_->get_consts();
-  generate_consts(consts);
-
-  // Generate structs and exceptions in declared order
-  vector<t_struct*> objects = program_->get_objects();
-  vector<t_struct*>::iterator o_iter;
-  for (o_iter = objects.begin(); o_iter != objects.end(); ++o_iter) {
-    if ((*o_iter)->is_xception()) {
-      generate_xception(*o_iter);
-    } else {
-      generate_struct(*o_iter);
-    }
-  }
-
-  // Generate services
-  vector<t_service*> services = program_->get_services();
-  vector<t_service*>::iterator sv_iter;
-  for (sv_iter = services.begin(); sv_iter != services.end(); ++sv_iter) {
-    service_name_ = get_service_name(*sv_iter);
-    generate_service(*sv_iter);
-  }
-
-  // Close the generator
-  close_generator();
-}
-
-string t_generator::escape_string(const string &in) const {
-  string result = "";
-  for (string::const_iterator it = in.begin(); it < in.end(); it++) {
-    std::map<char, std::string>::const_iterator res = escape_.find(*it);
-    if (res != escape_.end()) {
-      result.append(res->second);
-    } else {
-      result.push_back(*it);
-    }
-  }
-  return result;
-}
-
-void t_generator::generate_consts(vector<t_const*> consts) {
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    generate_const(*c_iter);
-  }
-}
-
-void t_generator::generate_docstring_comment(ofstream& out,
-                                             const string& comment_start,
-                                             const string& line_prefix,
-                                             const string& contents,
-                                             const string& comment_end) {
-  if (comment_start != "") indent(out) << comment_start;
-  stringstream docs(contents, ios_base::in);
-  while (!docs.eof()) {
-    char line[1024];
-    docs.getline(line, 1024);
-    if (strlen(line) > 0 || !docs.eof()) {  // skip the empty last line
-      indent(out) << line_prefix << line << std::endl;
-    }
-  }
-  if (comment_end != "") indent(out) << comment_end;
-}
-
-
-void t_generator_registry::register_generator(t_generator_factory* factory) {
-  gen_map_t& the_map = get_generator_map();
-  if (the_map.find(factory->get_short_name()) != the_map.end()) {
-    failure("Duplicate generators for language \"%s\"!\n", factory->get_short_name().c_str());
-  }
-  the_map[factory->get_short_name()] = factory;
-}
-
-t_generator* t_generator_registry::get_generator(t_program* program,
-                                                 const string& options) {
-  string::size_type colon = options.find(':');
-  string language = options.substr(0, colon);
-
-  map<string, string> parsed_options;
-  if (colon != string::npos) {
-    string::size_type pos = colon+1;
-    while (pos != string::npos && pos < options.size()) {
-      string::size_type next_pos = options.find(',', pos);
-      string option = options.substr(pos, next_pos-pos);
-      pos = ((next_pos == string::npos) ? next_pos : next_pos+1);
-
-      string::size_type separator = option.find('=');
-      string key, value;
-      if (separator == string::npos) {
-        key = option;
-        value = "";
-      } else {
-        key = option.substr(0, separator);
-        value = option.substr(separator+1);
-      }
-
-      parsed_options[key] = value;
-    }
-  }
-
-  gen_map_t& the_map = get_generator_map();
-  gen_map_t::iterator iter = the_map.find(language);
-
-  if (iter == the_map.end()) {
-    return NULL;
-  }
-
-  return iter->second->get_generator(program, parsed_options, options);
-}
-
-t_generator_registry::gen_map_t& t_generator_registry::get_generator_map() {
-  // http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.12
-  static gen_map_t* the_map = new gen_map_t();
-  return *the_map;
-}
-
-t_generator_factory::t_generator_factory(
-    const std::string& short_name,
-    const std::string& long_name,
-    const std::string& documentation)
-  : short_name_(short_name)
-  , long_name_(long_name)
-  , documentation_(documentation)
-{
-  t_generator_registry::register_generator(this);
-}

data/vendor/gems/thrift/compiler/cpp/src/generate/t_generator.h

@@ -1,321 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef T_GENERATOR_H
-#define T_GENERATOR_H
-
-#include <string>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include "parse/t_program.h"
-#include "globals.h"
-
-/**
- * Base class for a thrift code generator. This class defines the basic
- * routines for code generation and contains the top level method that
- * dispatches code generation across various components.
- *
- */
-class t_generator {
- public:
-  t_generator(t_program* program) {
-    tmp_ = 0;
-    indent_ = 0;
-    program_ = program;
-    program_name_ = get_program_name(program);
-    escape_['\n'] = "\\n";
-    escape_['\r'] = "\\r";
-    escape_['\t'] = "\\t";
-    escape_['"']  = "\\\"";
-    escape_['\\'] = "\\\\";
-  }
-
-  virtual ~t_generator() {}
-
-  /**
-   * Framework generator method that iterates over all the parts of a program
-   * and performs general actions. This is implemented by the base class and
-   * should not normally be overwritten in the subclasses.
-   */
-  virtual void generate_program();
-
-  const t_program* get_program() const { return program_; }
-
-  void generate_docstring_comment(std::ofstream& out,
-                                  const std::string& comment_start,
-                                  const std::string& line_prefix,
-                                  const std::string& contents,
-                                  const std::string& comment_end);
-
-  /**
-   * Escape string to use one in generated sources.
-   */
-  virtual std::string escape_string(const std::string &in) const;
-
-  std::string get_escaped_string(t_const_value* constval) {
-    return escape_string(constval->get_string());
-  }
-
- protected:
-
-  /**
-   * Optional methods that may be imlemented by subclasses to take necessary
-   * steps at the beginning or end of code generation.
-   */
-
-  virtual void init_generator() {}
-  virtual void close_generator() {}
-
-  virtual void generate_consts(std::vector<t_const*> consts);
-
-  /**
-   * Pure virtual methods implemented by the generator subclasses.
-   */
-
-  virtual void generate_typedef  (t_typedef*  ttypedef)  = 0;
-  virtual void generate_enum     (t_enum*     tenum)     = 0;
-  virtual void generate_const    (t_const*    tconst) {}
-  virtual void generate_struct   (t_struct*   tstruct)   = 0;
-  virtual void generate_service  (t_service*  tservice)  = 0;
-  virtual void generate_xception (t_struct*   txception) {
-    // By default exceptions are the same as structs
-    generate_struct(txception);
-  }
-
-  /**
-   * Method to get the program name, may be overridden
-   */
-  virtual std::string get_program_name(t_program* tprogram) {
-    return tprogram->get_name();
-  }
-
-  /**
-   * Method to get the service name, may be overridden
-   */
-  virtual std::string get_service_name(t_service* tservice) {
-    return tservice->get_name();
-  }
-
-  /**
-   * Get the current output directory
-   */
-  virtual std::string get_out_dir() const {
-    return program_->get_out_path() + out_dir_base_ + "/";
-  }
-
-  /**
-   * Creates a unique temporary variable name, which is just "name" with a
-   * number appended to it (i.e. name35)
-   */
-  std::string tmp(std::string name) {
-    std::ostringstream out;
-    out << name << tmp_++;
-    return out.str();
-  }
-
-  /**
-   * Indentation level modifiers
-   */
-
-  void indent_up(){
-    ++indent_;
-  }
-
-  void indent_down() {
-    --indent_;
-  }
-
-  /**
-   * Indentation print function
-   */
-  std::string indent() {
-    std::string ind = "";
-    int i;
-    for (i = 0; i < indent_; ++i) {
-      ind += "  ";
-    }
-    return ind;
-  }
-
-  /**
-   * Indentation utility wrapper
-   */
-  std::ostream& indent(std::ostream &os) {
-    return os << indent();
-  }
-
-  /**
-   * Capitalization helpers
-   */
-  std::string capitalize(std::string in) {
-    in[0] = toupper(in[0]);
-    return in;
-  }
-  std::string decapitalize(std::string in) {
-    in[0] = tolower(in[0]);
-    return in;
-  }
-  std::string lowercase(std::string in) {
-    for (size_t i = 0; i < in.size(); ++i) {
-      in[i] = tolower(in[i]);
-    }
-    return in;
-  }
-  std::string underscore(std::string in) {
-    in[0] = tolower(in[0]);
-    for (size_t i = 1; i < in.size(); ++i) {
-      if (isupper(in[i])) {
-        in[i] = tolower(in[i]);
-        in.insert(i, "_");
-      }
-    }
-    return in;
-  }
-
-  /**
-   * Get the true type behind a series of typedefs.
-   */
-  static t_type* get_true_type(t_type* type) {
-    while (type->is_typedef()) {
-      type = ((t_typedef*)type)->get_type();
-    }
-    return type;
-  }
-
- protected:
-  /**
-   * The program being generated
-   */
-  t_program* program_;
-
-  /**
-   * Quick accessor for formatted program name that is currently being
-   * generated.
-   */
-  std::string program_name_;
-
-  /**
-   * Quick accessor for formatted service name that is currently being
-   * generated.
-   */
-  std::string service_name_;
-
-  /**
-   * Output type-specifc directory name ("gen-*")
-   */
-  std::string out_dir_base_;
-
-  /**
-   * Map of characters to escape in string literals.
-   */
-  std::map<char, std::string> escape_;
-
- private:
-  /**
-   * Current code indentation level
-   */
-  int indent_;
-
-  /**
-   * Temporary variable counter, for making unique variable names
-   */
-  int tmp_;
-};
-
-
-/**
- * A factory for producing generator classes of a particular language.
- *
- * This class is also responsible for:
- *  - Registering itself with the generator registry.
- *  - Providing documentation for the generators it produces.
- */
-class t_generator_factory {
- public:
-  t_generator_factory(const std::string& short_name,
-                      const std::string& long_name,
-                      const std::string& documentation);
-
-  virtual ~t_generator_factory() {}
-
-  virtual t_generator* get_generator(
-      // The program to generate.
-      t_program* program,
-      // Note: parsed_options will not exist beyond the call to get_generator.
-      const std::map<std::string, std::string>& parsed_options,
-      // Note: option_string might not exist beyond the call to get_generator.
-      const std::string& option_string)
-    = 0;
-
-  std::string get_short_name() { return short_name_; }
-  std::string get_long_name() { return long_name_; }
-  std::string get_documentation() { return documentation_; }
-
- private:
-  std::string short_name_;
-  std::string long_name_;
-  std::string documentation_;
-};
-
-template <typename generator>
-class t_generator_factory_impl : public t_generator_factory {
- public:
-  t_generator_factory_impl(const std::string& short_name,
-                           const std::string& long_name,
-                           const std::string& documentation)
-    : t_generator_factory(short_name, long_name, documentation)
-  {}
-
-  virtual t_generator* get_generator(
-      t_program* program,
-      const std::map<std::string, std::string>& parsed_options,
-      const std::string& option_string) {
-    return new generator(program, parsed_options, option_string);
-  }
-};
-
-class t_generator_registry {
- public:
-  static void register_generator(t_generator_factory* factory);
-
-  static t_generator* get_generator(t_program* program,
-                                    const std::string& options);
-
-  typedef std::map<std::string, t_generator_factory*> gen_map_t;
-  static gen_map_t& get_generator_map();
-
- private:
-  t_generator_registry();
-  t_generator_registry(const t_generator_registry&);
-};
-
-#define THRIFT_REGISTER_GENERATOR(language, long_name, doc)        \
-  class t_##language##_generator_factory_impl                      \
-    : public t_generator_factory_impl<t_##language##_generator>    \
-  {                                                                \
-   public:                                                         \
-    t_##language##_generator_factory_impl()                        \
-      : t_generator_factory_impl<t_##language##_generator>(        \
-          #language, long_name, doc)                               \
-    {}                                                             \
-  };                                                               \
-  static t_##language##_generator_factory_impl _registerer;
-
-#endif