[Polly][isl] Add neutrally-named accessors to isl list elements and sizes

[philip.pfaffe]

Summary

This could simplify the isl iterator implementation a lot.

[grosser]

LGTM

[Meinersbur]

Where's the code for the generator?

[philip.pfaffe]

In D49019#1154400, @Meinersbur wrote:

Where's the code for the generator?

I didn't add it to the generator. Do we actually ever generate the header?

[Meinersbur]

Tobias does from time-to-time. Last time was r333688 on 2018-05-31.

[grosser]

Right. I am busy today, but can do a normal update thursday afternoon. I will then also push the current generator to github.

[philip.pfaffe]

Is the generator in the repo?

[grosser]

I have a patched version of the generator (very hacky) on top of the isl bindings. Not sure if this (happens to) be the right one: https://github.com/tobig/isl/tree/polly-bindings-andrei

You can try, but otherwise, I will cross-check myself on thursday.

[philip.pfaffe]

Should I commit this change, or wait until the generator is updated and recreate it using that?

[grosser]

You can commit this. It will just be covered in the next update.

polly/trunk/lib/External/isl/include/isl/isl-noexceptions.h

public:
 
   inline isl::aff_list add(isl::aff el) const;
   static inline isl::aff_list alloc(isl::ctx ctx, int n);
   inline isl::aff_list concat(isl::aff_list list2) const;
   inline isl::aff_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::aff)> &fn) const;
   static inline isl::aff_list from_aff(isl::aff el);
   inline isl::aff get_aff(int index) const;
+  inline isl::aff get_at(int index) const;
   inline isl::aff_list insert(unsigned int pos, isl::aff el) const;
   inline int n_aff() const;
+  inline int size() const;
   inline isl::aff_list set_aff(int index, isl::aff el) const;
 };
 
 // declarations for isl::ast_build
 inline isl::ast_build manage(__isl_take isl_ast_build *ptr);
 inline isl::ast_build manage_copy(__isl_keep isl_ast_build *ptr);
 
 class ast_build {
public:
 
   inline isl::ast_expr_list add(isl::ast_expr el) const;
   static inline isl::ast_expr_list alloc(isl::ctx ctx, int n);
   inline isl::ast_expr_list concat(isl::ast_expr_list list2) const;
   inline isl::ast_expr_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::ast_expr)> &fn) const;
   static inline isl::ast_expr_list from_ast_expr(isl::ast_expr el);
   inline isl::ast_expr get_ast_expr(int index) const;
+  inline isl::ast_expr get_at(int index) const;
   inline isl::ast_expr_list insert(unsigned int pos, isl::ast_expr el) const;
   inline int n_ast_expr() const;
+  inline int size() const;
   inline isl::ast_expr_list set_ast_expr(int index, isl::ast_expr el) const;
 };
 
 // declarations for isl::ast_node
 inline isl::ast_node manage(__isl_take isl_ast_node *ptr);
 inline isl::ast_node manage_copy(__isl_keep isl_ast_node *ptr);
 
 class ast_node {
public:
 
   inline isl::ast_node_list add(isl::ast_node el) const;
   static inline isl::ast_node_list alloc(isl::ctx ctx, int n);
   inline isl::ast_node_list concat(isl::ast_node_list list2) const;
   inline isl::ast_node_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::ast_node)> &fn) const;
   static inline isl::ast_node_list from_ast_node(isl::ast_node el);
   inline isl::ast_node get_ast_node(int index) const;
+  inline isl::ast_node get_at(int index) const;
   inline isl::ast_node_list insert(unsigned int pos, isl::ast_node el) const;
   inline int n_ast_node() const;
+  inline int size() const;
   inline isl::ast_node_list set_ast_node(int index, isl::ast_node el) const;
 };
 
 // declarations for isl::basic_map
 inline isl::basic_map manage(__isl_take isl_basic_map *ptr);
 inline isl::basic_map manage_copy(__isl_keep isl_basic_map *ptr);
 
 class basic_map {
public:
 
   inline isl::basic_map_list add(isl::basic_map el) const;
   static inline isl::basic_map_list alloc(isl::ctx ctx, int n);
   inline isl::basic_map_list concat(isl::basic_map_list list2) const;
   inline isl::basic_map_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::basic_map)> &fn) const;
   static inline isl::basic_map_list from_basic_map(isl::basic_map el);
   inline isl::basic_map get_basic_map(int index) const;
+  inline isl::basic_map get_at(int index) const;
   inline isl::basic_map_list insert(unsigned int pos, isl::basic_map el) const;
   inline isl::basic_map intersect() const;
   inline int n_basic_map() const;
+  inline int size() const;
   inline isl::basic_map_list set_basic_map(int index, isl::basic_map el) const;
 };
 
 // declarations for isl::basic_set
 inline isl::basic_set manage(__isl_take isl_basic_set *ptr);
 inline isl::basic_set manage_copy(__isl_keep isl_basic_set *ptr);
 
 class basic_set {
public:
   inline isl::basic_set_list add(isl::basic_set el) const;
   static inline isl::basic_set_list alloc(isl::ctx ctx, int n);
   inline isl::basic_set_list coefficients() const;
   inline isl::basic_set_list concat(isl::basic_set_list list2) const;
   inline isl::basic_set_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::basic_set)> &fn) const;
   static inline isl::basic_set_list from_basic_set(isl::basic_set el);
   inline isl::basic_set get_basic_set(int index) const;
+  inline isl::basic_set get_at(int index) const;
   inline isl::basic_set_list insert(unsigned int pos, isl::basic_set el) const;
   inline isl::basic_set intersect() const;
   inline int n_basic_set() const;
+  inline int size() const;
   inline isl::basic_set_list set_basic_set(int index, isl::basic_set el) const;
 };
 
 // declarations for isl::constraint
 inline isl::constraint manage(__isl_take isl_constraint *ptr);
 inline isl::constraint manage_copy(__isl_keep isl_constraint *ptr);
 
 class constraint {
public:
 
   inline isl::constraint_list add(isl::constraint el) const;
   static inline isl::constraint_list alloc(isl::ctx ctx, int n);
   inline isl::constraint_list concat(isl::constraint_list list2) const;
   inline isl::constraint_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::constraint)> &fn) const;
   static inline isl::constraint_list from_constraint(isl::constraint el);
   inline isl::constraint get_constraint(int index) const;
+  inline isl::constraint get_at(int index) const;
   inline isl::constraint_list insert(unsigned int pos, isl::constraint el) const;
   inline int n_constraint() const;
+  inline int size() const;
   inline isl::constraint_list set_constraint(int index, isl::constraint el) const;
 };
 
 // declarations for isl::id
 inline isl::id manage(__isl_take isl_id *ptr);
 inline isl::id manage_copy(__isl_keep isl_id *ptr);
 
 class id {
public:
 
   inline isl::id_list add(isl::id el) const;
   static inline isl::id_list alloc(isl::ctx ctx, int n);
   inline isl::id_list concat(isl::id_list list2) const;
   inline isl::id_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::id)> &fn) const;
   static inline isl::id_list from_id(isl::id el);
   inline isl::id get_id(int index) const;
+  inline isl::id get_at(int index) const;
   inline isl::id_list insert(unsigned int pos, isl::id el) const;
   inline int n_id() const;
+  inline int size() const;
   inline isl::id_list set_id(int index, isl::id el) const;
 };
 
 // declarations for isl::id_to_ast_expr
 inline isl::id_to_ast_expr manage(__isl_take isl_id_to_ast_expr *ptr);
 inline isl::id_to_ast_expr manage_copy(__isl_keep isl_id_to_ast_expr *ptr);
 
 class id_to_ast_expr {
public:
 
   inline isl::map_list add(isl::map el) const;
   static inline isl::map_list alloc(isl::ctx ctx, int n);
   inline isl::map_list concat(isl::map_list list2) const;
   inline isl::map_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::map)> &fn) const;
   static inline isl::map_list from_map(isl::map el);
   inline isl::map get_map(int index) const;
+  inline isl::map get_at(int index) const;
   inline isl::map_list insert(unsigned int pos, isl::map el) const;
   inline int n_map() const;
+  inline int size() const;
   inline isl::map_list set_map(int index, isl::map el) const;
 };
 
 // declarations for isl::mat
 inline isl::mat manage(__isl_take isl_mat *ptr);
 inline isl::mat manage_copy(__isl_keep isl_mat *ptr);
 
 class mat {
public:
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::multi_aff flat_range_product(isl::multi_aff multi2) const;
   inline isl::multi_aff flatten_domain() const;
   inline isl::multi_aff flatten_range() const;
   inline isl::multi_aff floor() const;
   static inline isl::multi_aff from_aff_list(isl::space space, isl::aff_list list);
   inline isl::multi_aff from_range() const;
   inline isl::aff get_aff(int pos) const;
+  inline isl::aff get_at(int pos) const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::multi_aff gist(isl::set context) const;
   inline isl::multi_aff gist_params(isl::set context) const;
   inline isl::boolean has_tuple_id(isl::dim type) const;
public:
   inline isl::multi_pw_aff flat_range_product(isl::multi_pw_aff multi2) const;
   inline isl::multi_pw_aff flatten_range() const;
   static inline isl::multi_pw_aff from_pw_aff_list(isl::space space, isl::pw_aff_list list);
   inline isl::multi_pw_aff from_range() const;
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline uint32_t get_hash() const;
   inline isl::pw_aff get_pw_aff(int pos) const;
+  inline isl::pw_aff get_at(int pos) const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::multi_pw_aff gist(isl::set set) const;
   inline isl::multi_pw_aff gist_params(isl::set set) const;
   inline isl::boolean has_tuple_id(isl::dim type) const;
   static inline isl::multi_pw_aff identity(isl::space space);
   inline isl::multi_pw_aff insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
public:
   static inline isl::multi_union_pw_aff from_union_map(isl::union_map umap);
   static inline isl::multi_union_pw_aff from_union_pw_aff_list(isl::space space, isl::union_pw_aff_list list);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::union_pw_aff get_union_pw_aff(int pos) const;
+  inline isl::union_pw_aff get_at(int pos) const;
   inline isl::multi_union_pw_aff gist(isl::union_set context) const;
   inline isl::multi_union_pw_aff gist_params(isl::set context) const;
   inline isl::boolean has_tuple_id(isl::dim type) const;
   inline isl::multi_union_pw_aff intersect_domain(isl::union_set uset) const;
   inline isl::multi_union_pw_aff intersect_params(isl::set params) const;
   inline isl::multi_union_pw_aff intersect_range(isl::set set) const;
   inline isl::boolean involves_nan() const;
   inline isl::multi_union_pw_aff mod_multi_val(isl::multi_val mv) const;
public:
   inline isl::multi_val from_range() const;
   static inline isl::multi_val from_val_list(isl::space space, isl::val_list list);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::val get_val(int pos) const;
+  inline isl::val get_at(int pos) const;
   inline isl::boolean has_tuple_id(isl::dim type) const;
   inline isl::multi_val insert_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::boolean involves_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline isl::boolean involves_nan() const;
   inline isl::multi_val mod_multi_val(isl::multi_val mv) const;
   inline isl::multi_val mod_val(isl::val v) const;
   inline isl::multi_val neg() const;
   inline isl::boolean plain_is_equal(const isl::multi_val &multi2) const;
public:
   static inline isl::pw_aff_list alloc(isl::ctx ctx, int n);
   inline isl::pw_aff_list concat(isl::pw_aff_list list2) const;
   inline isl::pw_aff_list drop(unsigned int first, unsigned int n) const;
   inline isl::set eq_set(isl::pw_aff_list list2) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::pw_aff)> &fn) const;
   static inline isl::pw_aff_list from_pw_aff(isl::pw_aff el);
   inline isl::set ge_set(isl::pw_aff_list list2) const;
   inline isl::pw_aff get_pw_aff(int index) const;
+  inline isl::pw_aff get_at(int index) const;
   inline isl::set gt_set(isl::pw_aff_list list2) const;
   inline isl::pw_aff_list insert(unsigned int pos, isl::pw_aff el) const;
   inline isl::set le_set(isl::pw_aff_list list2) const;
   inline isl::set lt_set(isl::pw_aff_list list2) const;
   inline isl::pw_aff max() const;
   inline isl::pw_aff min() const;
   inline int n_pw_aff() const;
+  inline int size() const;
   inline isl::set ne_set(isl::pw_aff_list list2) const;
   inline isl::pw_aff_list set_pw_aff(int index, isl::pw_aff el) const;
 };
 
 // declarations for isl::pw_multi_aff
 inline isl::pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr);
 inline isl::pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr);
 
public:
   static inline isl::pw_multi_aff from_domain(isl::set set);
   static inline isl::pw_multi_aff from_map(isl::map map);
   static inline isl::pw_multi_aff from_multi_pw_aff(isl::multi_pw_aff mpa);
   static inline isl::pw_multi_aff from_set(isl::set set);
   inline isl::id get_dim_id(isl::dim type, unsigned int pos) const;
   inline std::string get_dim_name(isl::dim type, unsigned int pos) const;
   inline isl::space get_domain_space() const;
   inline isl::pw_aff get_pw_aff(int pos) const;
+  inline isl::pw_aff get_at(int pos) const;
   inline isl::space get_space() const;
   inline isl::id get_tuple_id(isl::dim type) const;
   inline std::string get_tuple_name(isl::dim type) const;
   inline isl::pw_multi_aff gist(isl::set set) const;
   inline isl::pw_multi_aff gist_params(isl::set set) const;
   inline isl::boolean has_tuple_id(isl::dim type) const;
   inline isl::boolean has_tuple_name(isl::dim type) const;
   static inline isl::pw_multi_aff identity(isl::space space);
public:
 
   inline isl::set_list add(isl::set el) const;
   static inline isl::set_list alloc(isl::ctx ctx, int n);
   inline isl::set_list concat(isl::set_list list2) const;
   inline isl::set_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::set)> &fn) const;
   static inline isl::set_list from_set(isl::set el);
   inline isl::set get_set(int index) const;
+  inline isl::set get_at(int index) const;
   inline isl::set_list insert(unsigned int pos, isl::set el) const;
   inline int n_set() const;
+  inline int size() const;
   inline isl::set_list set_set(int index, isl::set el) const;
   inline isl::set unite() const;
 };
 
 // declarations for isl::space
 inline isl::space manage(__isl_take isl_space *ptr);
 inline isl::space manage_copy(__isl_keep isl_space *ptr);
 
public:
 
   inline isl::union_map_list add(isl::union_map el) const;
   static inline isl::union_map_list alloc(isl::ctx ctx, int n);
   inline isl::union_map_list concat(isl::union_map_list list2) const;
   inline isl::union_map_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::union_map)> &fn) const;
   static inline isl::union_map_list from_union_map(isl::union_map el);
   inline isl::union_map get_union_map(int index) const;
+  inline isl::union_map get_at(int index) const;
   inline isl::union_map_list insert(unsigned int pos, isl::union_map el) const;
   inline int n_union_map() const;
+  inline int size() const;
   inline isl::union_map_list set_union_map(int index, isl::union_map el) const;
 };
 
 // declarations for isl::union_pw_aff
 inline isl::union_pw_aff manage(__isl_take isl_union_pw_aff *ptr);
 inline isl::union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr);
 
 class union_pw_aff {
public:
 
   inline isl::union_pw_aff_list add(isl::union_pw_aff el) const;
   static inline isl::union_pw_aff_list alloc(isl::ctx ctx, int n);
   inline isl::union_pw_aff_list concat(isl::union_pw_aff_list list2) const;
   inline isl::union_pw_aff_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::union_pw_aff)> &fn) const;
   static inline isl::union_pw_aff_list from_union_pw_aff(isl::union_pw_aff el);
   inline isl::union_pw_aff get_union_pw_aff(int index) const;
+  inline isl::union_pw_aff get_at(int index) const;
   inline isl::union_pw_aff_list insert(unsigned int pos, isl::union_pw_aff el) const;
   inline int n_union_pw_aff() const;
+  inline int size() const;
   inline isl::union_pw_aff_list set_union_pw_aff(int index, isl::union_pw_aff el) const;
 };
 
 // declarations for isl::union_pw_multi_aff
 inline isl::union_pw_multi_aff manage(__isl_take isl_union_pw_multi_aff *ptr);
 inline isl::union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr);
 
 class union_pw_multi_aff {
public:
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
   inline isl::union_pw_multi_aff flat_range_product(isl::union_pw_multi_aff upma2) const;
   inline isl::stat foreach_pw_multi_aff(const std::function<isl::stat(isl::pw_multi_aff)> &fn) const;
   static inline isl::union_pw_multi_aff from_aff(isl::aff aff);
   static inline isl::union_pw_multi_aff from_multi_union_pw_aff(isl::multi_union_pw_aff mupa);
   static inline isl::union_pw_multi_aff from_union_set(isl::union_set uset);
   inline isl::space get_space() const;
   inline isl::union_pw_aff get_union_pw_aff(int pos) const;
+  inline isl::union_pw_aff get_at(int pos) const;
   inline isl::union_pw_multi_aff gist(isl::union_set context) const;
   inline isl::union_pw_multi_aff gist_params(isl::set context) const;
   inline isl::union_pw_multi_aff intersect_domain(isl::union_set uset) const;
   inline isl::union_pw_multi_aff intersect_params(isl::set set) const;
   inline isl::boolean involves_nan() const;
   static inline isl::union_pw_multi_aff multi_val_on_domain(isl::union_set domain, isl::multi_val mv);
   inline int n_pw_multi_aff() const;
   inline isl::union_pw_multi_aff neg() const;
public:
 
   inline isl::union_pw_multi_aff_list add(isl::union_pw_multi_aff el) const;
   static inline isl::union_pw_multi_aff_list alloc(isl::ctx ctx, int n);
   inline isl::union_pw_multi_aff_list concat(isl::union_pw_multi_aff_list list2) const;
   inline isl::union_pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::union_pw_multi_aff)> &fn) const;
   static inline isl::union_pw_multi_aff_list from_union_pw_multi_aff(isl::union_pw_multi_aff el);
   inline isl::union_pw_multi_aff get_union_pw_multi_aff(int index) const;
+  inline isl::union_pw_multi_aff get_at(int index) const;
   inline isl::union_pw_multi_aff_list insert(unsigned int pos, isl::union_pw_multi_aff el) const;
   inline int n_union_pw_multi_aff() const;
+  inline int size() const;
   inline isl::union_pw_multi_aff_list set_union_pw_multi_aff(int index, isl::union_pw_multi_aff el) const;
 };
 
 // declarations for isl::union_pw_qpolynomial
 inline isl::union_pw_qpolynomial manage(__isl_take isl_union_pw_qpolynomial *ptr);
 inline isl::union_pw_qpolynomial manage_copy(__isl_keep isl_union_pw_qpolynomial *ptr);
 
 class union_pw_qpolynomial {
public:
 
   inline isl::union_set_list add(isl::union_set el) const;
   static inline isl::union_set_list alloc(isl::ctx ctx, int n);
   inline isl::union_set_list concat(isl::union_set_list list2) const;
   inline isl::union_set_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::union_set)> &fn) const;
   static inline isl::union_set_list from_union_set(isl::union_set el);
   inline isl::union_set get_union_set(int index) const;
+  inline isl::union_set get_at(int index) const;
   inline isl::union_set_list insert(unsigned int pos, isl::union_set el) const;
   inline int n_union_set() const;
+  inline int size() const;
   inline isl::union_set_list set_union_set(int index, isl::union_set el) const;
   inline isl::union_set unite() const;
 };
 
 // declarations for isl::val
 inline isl::val manage(__isl_take isl_val *ptr);
 inline isl::val manage_copy(__isl_keep isl_val *ptr);
 
public:
 
   inline isl::val_list add(isl::val el) const;
   static inline isl::val_list alloc(isl::ctx ctx, int n);
   inline isl::val_list concat(isl::val_list list2) const;
   inline isl::val_list drop(unsigned int first, unsigned int n) const;
   inline isl::stat foreach(const std::function<isl::stat(isl::val)> &fn) const;
   static inline isl::val_list from_val(isl::val el);
   inline isl::val get_val(int index) const;
+  inline isl::val get_at(int index) const;
   inline isl::val_list insert(unsigned int pos, isl::val el) const;
   inline int n_val() const;
+  inline int size() const;
   inline isl::val_list set_val(int index, isl::val el) const;
 };
 
 // declarations for isl::vec
 inline isl::vec manage(__isl_take isl_vec *ptr);
 inline isl::vec manage_copy(__isl_keep isl_vec *ptr);
 
 class vec {

 }
 
 isl::aff_list aff_list::from_aff(isl::aff el)
 {
   auto res = isl_aff_list_from_aff(el.release());
   return manage(res);
 }
 
+isl::aff aff_list::get_at(int index) const { return get_aff(index); }
 isl::aff aff_list::get_aff(int index) const
 {
   auto res = isl_aff_list_get_aff(get(), index);
   return manage(res);
 }
 
 isl::aff_list aff_list::insert(unsigned int pos, isl::aff el) const
 {
   auto res = isl_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int aff_list::size() const { return n_aff(); }
 int aff_list::n_aff() const
 {
   auto res = isl_aff_list_n_aff(get());
   return res;
 }
 
 isl::aff_list aff_list::set_aff(int index, isl::aff el) const
 {

 }
 
 isl::ast_expr_list ast_expr_list::from_ast_expr(isl::ast_expr el)
 {
   auto res = isl_ast_expr_list_from_ast_expr(el.release());
   return manage(res);
 }
 
+isl::ast_expr ast_expr_list::get_at(int index) const {
+  return get_ast_expr(index);
+}
 isl::ast_expr ast_expr_list::get_ast_expr(int index) const
 {
   auto res = isl_ast_expr_list_get_ast_expr(get(), index);
   return manage(res);
 }
 
 isl::ast_expr_list ast_expr_list::insert(unsigned int pos, isl::ast_expr el) const
 {
   auto res = isl_ast_expr_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int ast_expr_list::size() const { return n_ast_expr(); }
 int ast_expr_list::n_ast_expr() const
 {
   auto res = isl_ast_expr_list_n_ast_expr(get());
   return res;
 }
 
 isl::ast_expr_list ast_expr_list::set_ast_expr(int index, isl::ast_expr el) const
 {

 }
 
 isl::ast_node_list ast_node_list::from_ast_node(isl::ast_node el)
 {
   auto res = isl_ast_node_list_from_ast_node(el.release());
   return manage(res);
 }
 
+isl::ast_node ast_node_list::get_at(int index) const {
+  return get_ast_node(index);
+}
 isl::ast_node ast_node_list::get_ast_node(int index) const
 {
   auto res = isl_ast_node_list_get_ast_node(get(), index);
   return manage(res);
 }
 
 isl::ast_node_list ast_node_list::insert(unsigned int pos, isl::ast_node el) const
 {
   auto res = isl_ast_node_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int ast_node_list::size() const { return n_ast_node(); }
 int ast_node_list::n_ast_node() const
 {
   auto res = isl_ast_node_list_n_ast_node(get());
   return res;
 }
 
 isl::ast_node_list ast_node_list::set_ast_node(int index, isl::ast_node el) const
 {

 }
 
 isl::basic_map_list basic_map_list::from_basic_map(isl::basic_map el)
 {
   auto res = isl_basic_map_list_from_basic_map(el.release());
   return manage(res);
 }
 
+isl::basic_map basic_map_list::get_at(int index) const {
+  return get_basic_map(index);
+}
 isl::basic_map basic_map_list::get_basic_map(int index) const
 {
   auto res = isl_basic_map_list_get_basic_map(get(), index);
   return manage(res);
 }
 
 isl::basic_map_list basic_map_list::insert(unsigned int pos, isl::basic_map el) const
 {
   auto res = isl_basic_map_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
 isl::basic_map basic_map_list::intersect() const
 {
   auto res = isl_basic_map_list_intersect(copy());
   return manage(res);
 }
 
+int basic_map_list::size() const { return n_basic_map(); }
 int basic_map_list::n_basic_map() const
 {
   auto res = isl_basic_map_list_n_basic_map(get());
   return res;
 }
 
 isl::basic_map_list basic_map_list::set_basic_map(int index, isl::basic_map el) const
 {

 }
 
 isl::basic_set_list basic_set_list::from_basic_set(isl::basic_set el)
 {
   auto res = isl_basic_set_list_from_basic_set(el.release());
   return manage(res);
 }
 
+isl::basic_set basic_set_list::get_at(int index) const {
+  return get_basic_set(index);
+}
 isl::basic_set basic_set_list::get_basic_set(int index) const
 {
   auto res = isl_basic_set_list_get_basic_set(get(), index);
   return manage(res);
 }
 
 isl::basic_set_list basic_set_list::insert(unsigned int pos, isl::basic_set el) const
 {
   auto res = isl_basic_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
 isl::basic_set basic_set_list::intersect() const
 {
   auto res = isl_basic_set_list_intersect(copy());
   return manage(res);
 }
 
+int basic_set_list::size() const { return n_basic_set(); }
 int basic_set_list::n_basic_set() const
 {
   auto res = isl_basic_set_list_n_basic_set(get());
   return res;
 }
 
 isl::basic_set_list basic_set_list::set_basic_set(int index, isl::basic_set el) const
 {

 }
 
 isl::constraint_list constraint_list::from_constraint(isl::constraint el)
 {
   auto res = isl_constraint_list_from_constraint(el.release());
   return manage(res);
 }
 
+isl::constraint constraint_list::get_at(int index) const {
+  return get_constraint(index);
+}
 isl::constraint constraint_list::get_constraint(int index) const
 {
   auto res = isl_constraint_list_get_constraint(get(), index);
   return manage(res);
 }
 
 isl::constraint_list constraint_list::insert(unsigned int pos, isl::constraint el) const
 {
   auto res = isl_constraint_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int constraint_list::size() const { return n_constraint(); }
 int constraint_list::n_constraint() const
 {
   auto res = isl_constraint_list_n_constraint(get());
   return res;
 }
 
 isl::constraint_list constraint_list::set_constraint(int index, isl::constraint el) const
 {

 }
 
 isl::id_list id_list::from_id(isl::id el)
 {
   auto res = isl_id_list_from_id(el.release());
   return manage(res);
 }
 
+isl::id id_list::get_at(int index) const { return get_id(index); }
 isl::id id_list::get_id(int index) const
 {
   auto res = isl_id_list_get_id(get(), index);
   return manage(res);
 }
 
 isl::id_list id_list::insert(unsigned int pos, isl::id el) const
 {
   auto res = isl_id_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int id_list::size() const { return n_id(); }
 int id_list::n_id() const
 {
   auto res = isl_id_list_n_id(get());
   return res;
 }
 
 isl::id_list id_list::set_id(int index, isl::id el) const
 {

 }
 
 isl::map_list map_list::from_map(isl::map el)
 {
   auto res = isl_map_list_from_map(el.release());
   return manage(res);
 }
 
+isl::map map_list::get_at(int index) const { return get_map(index); }
 isl::map map_list::get_map(int index) const
 {
   auto res = isl_map_list_get_map(get(), index);
   return manage(res);
 }
 
 isl::map_list map_list::insert(unsigned int pos, isl::map el) const
 {
   auto res = isl_map_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int map_list::size() const { return n_map(); }
 int map_list::n_map() const
 {
   auto res = isl_map_list_n_map(get());
   return res;
 }
 
 isl::map_list map_list::set_map(int index, isl::map el) const
 {

 }
 
 isl::set pw_aff_list::ge_set(isl::pw_aff_list list2) const
 {
   auto res = isl_pw_aff_list_ge_set(copy(), list2.release());
   return manage(res);
 }
 
+isl::pw_aff pw_aff_list::get_at(int index) const { return get_pw_aff(index); }
 isl::pw_aff pw_aff_list::get_pw_aff(int index) const
 {
   auto res = isl_pw_aff_list_get_pw_aff(get(), index);
   return manage(res);
 }
 
 isl::set pw_aff_list::gt_set(isl::pw_aff_list list2) const
 {

 }
 
 isl::pw_aff pw_aff_list::min() const
 {
   auto res = isl_pw_aff_list_min(copy());
   return manage(res);
 }
 
+int pw_aff_list::size() const { return n_pw_aff(); }
 int pw_aff_list::n_pw_aff() const
 {
   auto res = isl_pw_aff_list_n_pw_aff(get());
   return res;
 }
 
 isl::set pw_aff_list::ne_set(isl::pw_aff_list list2) const
 {

 }
 
 isl::set_list set_list::from_set(isl::set el)
 {
   auto res = isl_set_list_from_set(el.release());
   return manage(res);
 }
 
+isl::set set_list::get_at(int index) const { return get_set(index); }
 isl::set set_list::get_set(int index) const
 {
   auto res = isl_set_list_get_set(get(), index);
   return manage(res);
 }
 
 isl::set_list set_list::insert(unsigned int pos, isl::set el) const
 {
   auto res = isl_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int set_list::size() const { return n_set(); }
 int set_list::n_set() const
 {
   auto res = isl_set_list_n_set(get());
   return res;
 }
 
 isl::set_list set_list::set_set(int index, isl::set el) const
 {

 }
 
 isl::union_map_list union_map_list::from_union_map(isl::union_map el)
 {
   auto res = isl_union_map_list_from_union_map(el.release());
   return manage(res);
 }
 
+isl::union_map union_map_list::get_at(int index) const {
+  return get_union_map(index);
+}
 isl::union_map union_map_list::get_union_map(int index) const
 {
   auto res = isl_union_map_list_get_union_map(get(), index);
   return manage(res);
 }
 
 isl::union_map_list union_map_list::insert(unsigned int pos, isl::union_map el) const
 {
   auto res = isl_union_map_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int union_map_list::size() const { return n_union_map(); }
 int union_map_list::n_union_map() const
 {
   auto res = isl_union_map_list_n_union_map(get());
   return res;
 }
 
 isl::union_map_list union_map_list::set_union_map(int index, isl::union_map el) const
 {

 }
 
 isl::union_pw_aff_list union_pw_aff_list::from_union_pw_aff(isl::union_pw_aff el)
 {
   auto res = isl_union_pw_aff_list_from_union_pw_aff(el.release());
   return manage(res);
 }
 
+isl::union_pw_aff union_pw_aff_list::get_at(int index) const {
+  return get_union_pw_aff(index);
+}
 isl::union_pw_aff union_pw_aff_list::get_union_pw_aff(int index) const
 {
   auto res = isl_union_pw_aff_list_get_union_pw_aff(get(), index);
   return manage(res);
 }
 
 isl::union_pw_aff_list union_pw_aff_list::insert(unsigned int pos, isl::union_pw_aff el) const
 {
   auto res = isl_union_pw_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int union_pw_aff_list::size() const { return n_union_pw_aff(); }
 int union_pw_aff_list::n_union_pw_aff() const
 {
   auto res = isl_union_pw_aff_list_n_union_pw_aff(get());
   return res;
 }
 
 isl::union_pw_aff_list union_pw_aff_list::set_union_pw_aff(int index, isl::union_pw_aff el) const
 {

 }
 
 isl::union_pw_multi_aff_list union_pw_multi_aff_list::from_union_pw_multi_aff(isl::union_pw_multi_aff el)
 {
   auto res = isl_union_pw_multi_aff_list_from_union_pw_multi_aff(el.release());
   return manage(res);
 }
 
+isl::union_pw_multi_aff union_pw_multi_aff_list::get_at(int index) const {
+  return get_union_pw_multi_aff(index);
+}
 isl::union_pw_multi_aff union_pw_multi_aff_list::get_union_pw_multi_aff(int index) const
 {
   auto res = isl_union_pw_multi_aff_list_get_union_pw_multi_aff(get(), index);
   return manage(res);
 }
 
 isl::union_pw_multi_aff_list union_pw_multi_aff_list::insert(unsigned int pos, isl::union_pw_multi_aff el) const
 {
   auto res = isl_union_pw_multi_aff_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int union_pw_multi_aff_list::size() const { return n_union_pw_multi_aff(); }
 int union_pw_multi_aff_list::n_union_pw_multi_aff() const
 {
   auto res = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(get());
   return res;
 }
 
 isl::union_pw_multi_aff_list union_pw_multi_aff_list::set_union_pw_multi_aff(int index, isl::union_pw_multi_aff el) const
 {

 }
 
 isl::union_set_list union_set_list::from_union_set(isl::union_set el)
 {
   auto res = isl_union_set_list_from_union_set(el.release());
   return manage(res);
 }
 
+isl::union_set union_set_list::get_at(int index) const {
+  return get_union_set(index);
+}
 isl::union_set union_set_list::get_union_set(int index) const
 {
   auto res = isl_union_set_list_get_union_set(get(), index);
   return manage(res);
 }
 
 isl::union_set_list union_set_list::insert(unsigned int pos, isl::union_set el) const
 {
   auto res = isl_union_set_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int union_set_list::size() const { return n_union_set(); }
 int union_set_list::n_union_set() const
 {
   auto res = isl_union_set_list_n_union_set(get());
   return res;
 }
 
 isl::union_set_list union_set_list::set_union_set(int index, isl::union_set el) const
 {

 }
 
 isl::val_list val_list::from_val(isl::val el)
 {
   auto res = isl_val_list_from_val(el.release());
   return manage(res);
 }
 
+isl::val val_list::get_at(int index) const { return get_val(index); }
 isl::val val_list::get_val(int index) const
 {
   auto res = isl_val_list_get_val(get(), index);
   return manage(res);
 }
 
 isl::val_list val_list::insert(unsigned int pos, isl::val el) const
 {
   auto res = isl_val_list_insert(copy(), pos, el.release());
   return manage(res);
 }
 
+int val_list::size() const { return n_val(); }
 int val_list::n_val() const
 {
   auto res = isl_val_list_n_val(get());
   return res;
 }
 
 isl::val_list val_list::set_val(int index, isl::val el) const
 {