template_cpp.h

Go to the documentation of this file.

#ifndef ISL_INTERFACE_TEMPLATE_CPP_H
#define ISL_INTERFACE_TEMPLATE_CPP_H
 
#include <initializer_list>
#include <iostream>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
 
#include "cpp.h"
 
struct Fixed;
 
struct TupleKind;
 
/* A shared pointer to a TupleKind.
 */
struct TupleKindPtr : public std::shared_ptr<const TupleKind> {
  using Base = std::shared_ptr<const TupleKind>;
  TupleKindPtr() = default;
  TupleKindPtr(Fixed);
  TupleKindPtr(Base base) : Base(base) {}
  TupleKindPtr(const std::string &name);
  TupleKindPtr(const TupleKindPtr &left, const TupleKindPtr &right);
};
 
/* A substitution mapping leaf tuple kind names to tuple kinds.
 */
using Substitution = std::unordered_map<std::string, TupleKindPtr>;
 
/* A representation of a (possibly improper) tuple kind.
 * That is, this also includes tuple kinds for types
 * that do not have any tuples.
 *
 * The kind could be a name (the base case) or
 * a (currently) unnamed nested pair of tuple kinds.
 */
struct TupleKind {
  TupleKind(const std::string &name) : name(name) {}
 
  virtual std::string to_string() const;
  virtual std::vector<std::string> params() const;
  virtual TupleKindPtr apply(const Substitution &subs,
    const TupleKindPtr &self) const;
  virtual TupleKindPtr left() const;
  virtual TupleKindPtr right() const;
 
  const std::string name;
};
 
/* A sequence of tuple kinds, representing a kind of objects.
 */
struct Kind : public std::vector<TupleKindPtr> {
  Kind() {}
  Kind(std::initializer_list<TupleKindPtr> list) : vector(list) {}
 
  bool is_anon() const;
  bool is_set() const;
  bool is_anon_set() const;
  std::vector<std::string> params() const;
  Kind apply(const Substitution &subs) const;
};
 
/* A representation of a template class.
 *
 * "class_name" is the name of the template class.
 * "super_name" is the (fully qualified) name of the corresponding
 * plain C++ interface class, from which this template class derives.
 * "clazz" describes the plain class.
 *
 * "class_tuples" contains the specializations.
 * It is initialized with a predefined set of specializations,
 * but may be extended during the generations of the specializations.
 */
struct template_class {
  const std::string class_name;
  const std::string super_name;
  const isl_class &clazz;
 
  std::vector<Kind> class_tuples;
 
  bool is_anon() const;
  bool is_anon_set() const;
  void add_specialization(const Kind &kind);
};
 
/* A generator for templated C++ bindings.
 *
 * "template_classes" contains all generated template classes,
 * keyed on their names.
 */
class template_cpp_generator : public cpp_generator {
  struct class_printer;
  struct method_decl_printer;
  struct method_impl_printer;
  struct class_decl_printer;
  struct class_impl_printer;
 
  void add_template_class(const isl_class &clazz, const std::string &name,
    const std::vector<Kind> &class_tuples);
public:
  template_cpp_generator(clang::SourceManager &SM,
    std::set<clang::RecordDecl *> &exported_types,
    std::set<clang::FunctionDecl *> exported_functions,
    std::set<clang::FunctionDecl *> functions);
 
  virtual void generate() override;
  void foreach_template_class(
    const std::function<void(const template_class &)> &fn) const;
  void print_forward_declarations(std::ostream &os);
  void print_friends(std::ostream &os);
 
  std::map<std::string, template_class> template_classes;
};
 
#endif