auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/compiler/cpp/src/parse/t_map.h

@@ -1,64 +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_MAP_H
-#define T_MAP_H
-
-#include "t_container.h"
-
-/**
- * A map is a lightweight container type that just wraps another two data
- * types.
- *
- */
-class t_map : public t_container {
- public:
-  t_map(t_type* key_type, t_type* val_type) :
-    key_type_(key_type),
-    val_type_(val_type) {}
-
-  t_type* get_key_type() const {
-    return key_type_;
-  }
-
-  t_type* get_val_type() const {
-    return val_type_;
-  }
-
-  bool is_map() const {
-    return true;
-  }
-
-  virtual std::string get_fingerprint_material() const {
-    return "map<" + key_type_->get_fingerprint_material() +
-      "," + val_type_->get_fingerprint_material() + ">";
-  }
-
-  virtual void generate_fingerprint() {
-    t_type::generate_fingerprint();
-    key_type_->generate_fingerprint();
-    val_type_->generate_fingerprint();
-  }
-
- private:
-  t_type* key_type_;
-  t_type* val_type_;
-};
-
-#endif

data/vendor/gems/thrift/compiler/cpp/src/parse/t_program.h

@@ -1,223 +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_PROGRAM_H
-#define T_PROGRAM_H
-
-#include <map>
-#include <string>
-#include <vector>
-
-// For program_name()
-#include "main.h"
-
-#include "t_doc.h"
-#include "t_scope.h"
-#include "t_base_type.h"
-#include "t_typedef.h"
-#include "t_enum.h"
-#include "t_const.h"
-#include "t_struct.h"
-#include "t_service.h"
-#include "t_list.h"
-#include "t_map.h"
-#include "t_set.h"
-//#include "t_doc.h"
-
-/**
- * Top level class representing an entire thrift program. A program consists
- * fundamentally of the following:
- *
- *   Typedefs
- *   Enumerations
- *   Constants
- *   Structs
- *   Exceptions
- *   Services
- *
- * The program module also contains the definitions of the base types.
- *
- */
-class t_program : public t_doc {
- public:
-  t_program(std::string path, std::string name) :
-    path_(path),
-    name_(name),
-    out_path_("./") {
-    scope_ = new t_scope();
-  }
-
-  t_program(std::string path) :
-    path_(path),
-    out_path_("./") {
-    name_ = program_name(path);
-    scope_ = new t_scope();
-  }
-
-  // Path accessor
-  const std::string& get_path() const { return path_; }
-
-  // Output path accessor
-  const std::string& get_out_path() const { return out_path_; }
-
-  // Name accessor
-  const std::string& get_name() const { return name_; }
-
-  // Namespace
-  const std::string& get_namespace() const { return namespace_; }
-
-  // Include prefix accessor
-  const std::string& get_include_prefix() const { return include_prefix_; }
-
-  // Accessors for program elements
-  const std::vector<t_typedef*>& get_typedefs()  const { return typedefs_;  }
-  const std::vector<t_enum*>&    get_enums()     const { return enums_;     }
-  const std::vector<t_const*>&   get_consts()    const { return consts_;    }
-  const std::vector<t_struct*>&  get_structs()   const { return structs_;   }
-  const std::vector<t_struct*>&  get_xceptions() const { return xceptions_; }
-  const std::vector<t_struct*>&  get_objects()   const { return objects_;   }
-  const std::vector<t_service*>& get_services()  const { return services_;  }
-
-  // Program elements
-  void add_typedef  (t_typedef* td) { typedefs_.push_back(td);  }
-  void add_enum     (t_enum*    te) { enums_.push_back(te);     }
-  void add_const    (t_const*   tc) { consts_.push_back(tc);    }
-  void add_struct   (t_struct*  ts) { objects_.push_back(ts);
-                                      structs_.push_back(ts);   }
-  void add_xception (t_struct*  tx) { objects_.push_back(tx);
-                                      xceptions_.push_back(tx); }
-  void add_service  (t_service* ts) { services_.push_back(ts);  }
-
-  // Programs to include
-  const std::vector<t_program*>& get_includes() const { return includes_; }
-
-  void set_out_path(std::string out_path) {
-    out_path_ = out_path;
-    // Ensure that it ends with a trailing '/' (or '\' for windows machines)
-    char c = out_path_.at(out_path_.size() - 1);
-    if (!(c == '/' || c == '\\')) {
-      out_path_.push_back('/');
-    }
-  }
-
-  // Scoping and namespacing
-  void set_namespace(std::string name) {
-    namespace_ = name;
-  }
-
-  // Scope accessor
-  t_scope* scope() {
-    return scope_;
-  }
-
-  // Includes
-
-  void add_include(std::string path, std::string include_site) {
-    t_program* program = new t_program(path);
-
-    // include prefix for this program is the site at which it was included
-    // (minus the filename)
-    std::string include_prefix;
-    std::string::size_type last_slash = std::string::npos;
-    if ((last_slash = include_site.rfind("/")) != std::string::npos) {
-      include_prefix = include_site.substr(0, last_slash);
-    }
-
-    program->set_include_prefix(include_prefix);
-    includes_.push_back(program);
-  }
-
-  std::vector<t_program*>& get_includes() {
-    return includes_;
-  }
-
-  void set_include_prefix(std::string include_prefix) {
-    include_prefix_ = include_prefix;
-
-    // this is intended to be a directory; add a trailing slash if necessary
-    int len = include_prefix_.size();
-    if (len > 0 && include_prefix_[len - 1] != '/') {
-      include_prefix_ += '/';
-    }
-  }
-
-  // Language neutral namespace / packaging
-  void set_namespace(std::string language, std::string name_space) {
-    namespaces_[language] = name_space;
-  }
-
-  std::string get_namespace(std::string language) const {
-    std::map<std::string, std::string>::const_iterator iter = namespaces_.find(language);
-    if (iter == namespaces_.end()) {
-      return std::string();
-    }
-    return iter->second;
-  }
-
-  // Language specific namespace / packaging
-
-  void add_cpp_include(std::string path) {
-    cpp_includes_.push_back(path);
-  }
-
-  const std::vector<std::string>& get_cpp_includes() {
-    return cpp_includes_;
-  }
-
- private:
-
-  // File path
-  std::string path_;
-
-  // Name
-  std::string name_;
-
-  // Output directory
-  std::string out_path_;
-
-  // Namespace
-  std::string namespace_;
-
-  // Included programs
-  std::vector<t_program*> includes_;
-
-  // Include prefix for this program, if any
-  std::string include_prefix_;
-
-  // Identifier lookup scope
-  t_scope* scope_;
-
-  // Components to generate code for
-  std::vector<t_typedef*> typedefs_;
-  std::vector<t_enum*>    enums_;
-  std::vector<t_const*>   consts_;
-  std::vector<t_struct*>  objects_;
-  std::vector<t_struct*>  structs_;
-  std::vector<t_struct*>  xceptions_;
-  std::vector<t_service*> services_;
-
-  // Dynamic namespaces
-  std::map<std::string, std::string> namespaces_;
-
-  // C++ extra includes
-  std::vector<std::string> cpp_includes_;
-
-};
-
-#endif

data/vendor/gems/thrift/compiler/cpp/src/parse/t_scope.h

@@ -1,86 +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_SCOPE_H
-#define T_SCOPE_H
-
-#include <map>
-#include <string>
-
-#include "t_type.h"
-#include "t_service.h"
-
-/**
- * This represents a variable scope used for looking up predefined types and
- * services. Typically, a scope is associated with a t_program. Scopes are not
- * used to determine code generation, but rather to resolve identifiers at
- * parse time.
- *
- */
-class t_scope {
- public:
-  t_scope() {}
-
-  void add_type(std::string name, t_type* type) {
-    types_[name] = type;
-  }
-
-  t_type* get_type(std::string name) {
-    return types_[name];
-  }
-
-  void add_service(std::string name, t_service* service) {
-    services_[name] = service;
-  }
-
-  t_service* get_service(std::string name) {
-    return services_[name];
-  }
-
-  void add_constant(std::string name, t_const* constant) {
-    constants_[name] = constant;
-  }
-
-  t_const* get_constant(std::string name) {
-    return constants_[name];
-  }
-
-  void print() {
-    std::map<std::string, t_type*>::iterator iter;
-    for (iter = types_.begin(); iter != types_.end(); ++iter) {
-      printf("%s => %s\n",
-             iter->first.c_str(),
-             iter->second->get_name().c_str());
-    }
-  }
-
- private:
-
-  // Map of names to types
-  std::map<std::string, t_type*> types_;
-
-  // Map of names to constants
-  std::map<std::string, t_const*> constants_;
-
-  // Map of names to services
-  std::map<std::string, t_service*> services_;
-
-};
-
-#endif

data/vendor/gems/thrift/compiler/cpp/src/parse/t_service.h

@@ -1,68 +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_SERVICE_H
-#define T_SERVICE_H
-
-#include "t_function.h"
-#include <vector>
-
-class t_program;
-
-/**
- * A service consists of a set of functions.
- *
- */
-class t_service : public t_type {
- public:
-  t_service(t_program* program) :
-    t_type(program),
-    extends_(NULL) {}
-
-  bool is_service() const {
-    return true;
-  }
-
-  void set_extends(t_service* extends) {
-    extends_ = extends;
-  }
-
-  void add_function(t_function* func) {
-    functions_.push_back(func);
-  }
-
-  const std::vector<t_function*>& get_functions() const {
-    return functions_;
-  }
-
-  t_service* get_extends() {
-    return extends_;
-  }
-
-  virtual std::string get_fingerprint_material() const {
-    // Services should never be used in fingerprints.
-    throw "BUG: Can't get fingerprint material for service.";
-  }
-
- private:
-  std::vector<t_function*> functions_;
-  t_service* extends_;
-};
-
-#endif

data/vendor/gems/thrift/compiler/cpp/src/parse/t_set.h

@@ -1,55 +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_SET_H
-#define T_SET_H
-
-#include "t_container.h"
-
-/**
- * A set is a lightweight container type that just wraps another data type.
- *
- */
-class t_set : public t_container {
- public:
-  t_set(t_type* elem_type) :
-    elem_type_(elem_type) {}
-
-  t_type* get_elem_type() const {
-    return elem_type_;
-  }
-
-  bool is_set() const {
-    return true;
-  }
-
-  virtual std::string get_fingerprint_material() const {
-    return "set<" + elem_type_->get_fingerprint_material() + ">";
-  }
-
-  virtual void generate_fingerprint() {
-    t_type::generate_fingerprint();
-    elem_type_->generate_fingerprint();
-  }
-
- private:
-  t_type* elem_type_;
-};
-
-#endif

data/vendor/gems/thrift/compiler/cpp/src/parse/t_struct.h

@@ -1,127 +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_STRUCT_H
-#define T_STRUCT_H
-
-#include <algorithm>
-#include <vector>
-#include <utility>
-#include <string>
-
-#include "t_type.h"
-#include "t_field.h"
-
-// Forward declare that puppy
-class t_program;
-
-/**
- * A struct is a container for a set of member fields that has a name. Structs
- * are also used to implement exception types.
- *
- */
-class t_struct : public t_type {
- public:
-  typedef std::vector<t_field*> members_type;
-
-  t_struct(t_program* program) :
-    t_type(program),
-    is_xception_(false),
-    xsd_all_(false) {}
-
-  t_struct(t_program* program, const std::string& name) :
-    t_type(program, name),
-    is_xception_(false),
-    xsd_all_(false) {}
-
-  void set_name(const std::string& name) {
-    name_ = name;
-  }
-
-  void set_xception(bool is_xception) {
-    is_xception_ = is_xception;
-  }
-
-  void set_xsd_all(bool xsd_all) {
-    xsd_all_ = xsd_all;
-  }
-
-  bool get_xsd_all() const {
-    return xsd_all_;
-  }
-
-  bool append(t_field* elem) {
-    members_.push_back(elem);
-
-    typedef members_type::iterator iter_type;
-    std::pair<iter_type, iter_type> bounds = std::equal_range(
-            members_in_id_order_.begin(), members_in_id_order_.end(), elem, t_field::key_compare()
-        );
-    if (bounds.first != bounds.second) {
-      return false;
-    }
-    members_in_id_order_.insert(bounds.second, elem);
-    return true;
-  }
-
-  const members_type& get_members() {
-    return members_;
-  }
-
-  const members_type& get_sorted_members() {
-    return members_in_id_order_;
-  }
-
-  bool is_struct() const {
-    return !is_xception_;
-  }
-
-  bool is_xception() const {
-    return is_xception_;
-  }
-
-  virtual std::string get_fingerprint_material() const {
-    std::string rv = "{";
-    members_type::const_iterator m_iter;
-    for (m_iter = members_in_id_order_.begin(); m_iter != members_in_id_order_.end(); ++m_iter) {
-      rv += (*m_iter)->get_fingerprint_material();
-      rv += ";";
-    }
-    rv += "}";
-    return rv;
-  }
-
-  virtual void generate_fingerprint() {
-    t_type::generate_fingerprint();
-    members_type::const_iterator m_iter;
-    for (m_iter = members_in_id_order_.begin(); m_iter != members_in_id_order_.end(); ++m_iter) {
-      (*m_iter)->get_type()->generate_fingerprint();
-    }
-  }
-
- private:
-
-  members_type members_;
-  members_type members_in_id_order_;
-  bool is_xception_;
-
-  bool xsd_all_;
-};
-
-#endif