autoc 1.1 → 1.2

data/lib/autoc/collection/hash_set.rb

@@ -148,64 +148,67 @@ class HashSet < Collection
   def initialize(*args)
     super
     @list = List.new(list, element, :static)
+    @capability.subtract [:orderable]
+    key_type_check(element)
   end
   
-  def write_exported_types(stream)
+  def write_intf_types(stream)
     stream << %$
       /***
       **** #{type}<#{element.type}> (#{self.class})
       ***/
     $ if public?
-    @list.write_exported_types(stream)
+    @list.write_intf_types(stream)
     stream << %$
       typedef struct #{type} #{type};
       typedef struct #{it} #{it};
       struct #{type} {
-        #{@list.type}* buckets;
+        #{@list.type_ref} buckets;
         size_t bucket_count, min_bucket_count;
         size_t size, min_size, max_size;
         unsigned min_fill, max_fill, capacity_multiplier; /* ?*1e-2 */
       };
       struct #{it} {
-        #{type}* set;
+        #{type_ref} set;
         int bucket_index;
         #{@list.it} it;
       };
     $
   end
   
-  def write_exported_declarations(stream, declare, define)
+  def write_intf_decls(stream, declare, define)
+    super
     stream << %$
-      #{declare} void #{ctor}(#{type}*);
-      #{declare} void #{dtor}(#{type}*);
-      #{declare} void #{copy}(#{type}*, #{type}*);
-      #{declare} int #{equal}(#{type}*, #{type}*);
-      #{declare} size_t #{identify}(#{type}*);
-      #{declare} void #{purge}(#{type}*);
-      #{declare} int #{contains}(#{type}*, #{element.type});
-      #{declare} #{element.type} #{get}(#{type}*, #{element.type});
-      #{declare} size_t #{size}(#{type}*);
+      #{declare} #{ctor.declaration};
+      #{declare} #{dtor.declaration};
+      #{declare} #{copy.declaration};
+      #{declare} #{equal.declaration};
+      #{declare} #{identify.declaration};
+      #{declare} void #{purge}(#{type_ref});
+      #{declare} int #{contains}(#{type_ref}, #{element.type});
+      #{declare} #{element.type} #{get}(#{type_ref}, #{element.type});
+      #{declare} size_t #{size}(#{type_ref});
       #define #{empty}(self) (#{size}(self) == 0)
-      #{declare} int #{put}(#{type}*, #{element.type});
-      #{declare} int #{replace}(#{type}*, #{element.type});
-      #{declare} int #{remove}(#{type}*, #{element.type});
-      #{declare} void #{exclude}(#{type}*, #{type}*);
-      #{declare} void #{retain}(#{type}*, #{type}*);
-      #{declare} void #{include}(#{type}*, #{type}*);
-      #{declare} void #{invert}(#{type}*, #{type}*);
-      #{declare} void #{itCtor}(#{it}*, #{type}*);
-      #{declare} int #{itMove}(#{it}*);
-      #{declare} #{element.type} #{itGet}(#{it}*);
+      #{declare} int #{put}(#{type_ref}, #{element.type});
+      #{declare} int #{replace}(#{type_ref}, #{element.type});
+      #{declare} int #{remove}(#{type_ref}, #{element.type});
+      #{declare} void #{exclude}(#{type_ref}, #{type_ref});
+      #{declare} void #{retain}(#{type_ref}, #{type_ref});
+      #{declare} void #{include}(#{type_ref}, #{type_ref});
+      #{declare} void #{invert}(#{type_ref}, #{type_ref});
+      #{declare} void #{itCtor}(#{it_ref}, #{type_ref});
+      #{declare} int #{itMove}(#{it_ref});
+      #{declare} #{element.type} #{itGet}(#{it_ref});
     $
   end
 
-  def write_implementations(stream, define)
-    @list.write_exported_declarations(stream, static, inline)
-    @list.write_implementations(stream, static)
+  def write_impls(stream, define)
+    @list.write_intf_decls(stream, static, inline)
+    @list.write_impls(stream, static)
     stream << %$
-      #{define} #{element.type}* #{itGetRef}(#{it}*);
-      static void #{rehash}(#{type}* self) {
-        #{@list.type}* buckets;
+      #{define} #{element.type_ref} #{itGetRef}(#{it_ref});
+      static void #{rehash}(#{type_ref} self) {
+        #{@list.type_ref} buckets;
         size_t index, bucket_count, size, fill;
         #{assert}(self);
         #{assert}(self->min_fill > 0);
@@ -230,7 +233,7 @@ class HashSet < Collection
           bucket_count = self->min_bucket_count;
           size = 0;
         }
-        buckets = (#{@list.type}*)#{malloc}(bucket_count*sizeof(#{@list.type})); #{assert}(buckets);
+        buckets = (#{@list.type_ref})#{malloc}(bucket_count*sizeof(#{@list.type})); #{assert}(buckets);
         for(index = 0; index < bucket_count; ++index) {
           #{@list.ctor}(&buckets[index]);
         }
@@ -250,7 +253,17 @@ class HashSet < Collection
         self->bucket_count = bucket_count;
         self->size = size;
       }
-      #{define} void #{ctor}(#{type}* self) {
+      static int #{containsAllOf}(#{type_ref} self, #{type_ref} other) {
+        #{it} it;
+        #{itCtor}(&it, self);
+        while(#{itMove}(&it)) {
+          int found = 0;
+          if(#{contains}(other, *#{itGetRef}(&it))) found = 1;
+          if(!found) return 0;
+        }
+        return 1;
+      }
+      #{define} #{ctor.definition} {
         #{assert}(self);
         self->min_bucket_count = 16;
         self->min_fill = 20;
@@ -261,7 +274,7 @@ class HashSet < Collection
         self->buckets = NULL;
         #{rehash}(self);
       }
-      #{define} void #{dtor}(#{type}* self) {
+      #{define} #{dtor.definition} {
         size_t i;
         #{assert}(self);
         for(i = 0; i < self->bucket_count; ++i) {
@@ -269,7 +282,7 @@ class HashSet < Collection
         }
         #{free}(self->buckets);
       }
-      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+      #{define} #{copy.definition} {
         #{it} it;
         #{assert}(src);
         #{assert}(dst);
@@ -277,22 +290,12 @@ class HashSet < Collection
         #{itCtor}(&it, src);
         while(#{itMove}(&it)) #{put}(dst, *#{itGetRef}(&it));
       }
-      static int #{containsAllOf}(#{type}* self, #{type}* other) {
-        #{it} it;
-        #{itCtor}(&it, self);
-        while(#{itMove}(&it)) {
-          int found = 0;
-          if(#{contains}(other, *#{itGetRef}(&it))) found = 1;
-          if(!found) return 0;
-        }
-        return 1;
-      }
-      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+      #{define} #{equal.definition} {
         #{assert}(lt);
         #{assert}(rt);
         return #{size}(lt) == #{size}(rt) && #{containsAllOf}(lt, rt) && #{containsAllOf}(rt, lt);
       }
-      #{define} size_t #{identify}(#{type}* self) {
+      #{define} #{identify.definition} {
         #{it} it;
         size_t result = 0;
         #{assert}(self);
@@ -304,29 +307,29 @@ class HashSet < Collection
         }
         return result;
       }
-      #{define} void #{purge}(#{type}* self) {
+      #{define} void #{purge}(#{type_ref} self) {
         #{assert}(self);
         #{dtor}(self);
         self->buckets = NULL;
         #{rehash}(self);
       }
-      #{define} int #{contains}(#{type}* self, #{element.type} element) {
+      #{define} int #{contains}(#{type_ref} self, #{element.type} element) {
         #{assert}(self);
         return #{@list.contains}(&self->buckets[#{element.identify("element")} % self->bucket_count], element);
       }
-      #{define} #{element.type} #{get}(#{type}* self, #{element.type} element) {
+      #{define} #{element.type} #{get}(#{type_ref} self, #{element.type} element) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(#{contains}(self, element));
         result = #{@list.find}(&self->buckets[#{element.identify("element")} % self->bucket_count], element);
         return result;
       }
-      #{define} size_t #{size}(#{type}* self) {
+      #{define} size_t #{size}(#{type_ref} self) {
         #{assert}(self);
         return self->size;
       }
-      #{define} int #{put}(#{type}* self, #{element.type} element) {
-        #{@list.type}* bucket;
+      #{define} int #{put}(#{type_ref} self, #{element.type} element) {
+        #{@list.type_ref} bucket;
         #{assert}(self);
         bucket = &self->buckets[#{element.identify("element")} % self->bucket_count];
         if(!#{@list.contains}(bucket, element)) {
@@ -337,14 +340,14 @@ class HashSet < Collection
         }
         return 0;
       }
-      #{define} int #{replace}(#{type}* self, #{element.type} element) {
-        #{@list.type}* bucket;
+      #{define} int #{replace}(#{type_ref} self, #{element.type} element) {
+        #{@list.type_ref} bucket;
         #{assert}(self);
         bucket = &self->buckets[#{element.identify("element")} % self->bucket_count];
         return #{@list.replace}(bucket, element);
       }
-      #{define} int #{remove}(#{type}* self, #{element.type} element) {
-        #{@list.type}* bucket;
+      #{define} int #{remove}(#{type_ref} self, #{element.type} element) {
+        #{@list.type_ref} bucket;
         #{assert}(self);
         bucket = &self->buckets[#{element.identify("element")} % self->bucket_count];
         if(#{@list.remove}(bucket, element)) {
@@ -354,21 +357,21 @@ class HashSet < Collection
         }
         return 0;
       }
-      #{define} void #{exclude}(#{type}* self, #{type}* other) {
+      #{define} void #{exclude}(#{type_ref} self, #{type_ref} other) {
         #{it} it;
         #{assert}(self);
         #{assert}(other);
         #{itCtor}(&it, other);
         while(#{itMove}(&it)) #{remove}(self, *#{itGetRef}(&it));
       }
-      #{define} void #{include}(#{type}* self, #{type}* other) {
+      #{define} void #{include}(#{type_ref} self, #{type_ref} other) {
         #{it} it;
         #{assert}(self);
         #{assert}(other);
         #{itCtor}(&it, other);
         while(#{itMove}(&it)) #{put}(self, *#{itGetRef}(&it));
       }
-      #{define} void #{retain}(#{type}* self, #{type}* other) {
+      #{define} void #{retain}(#{type_ref} self, #{type_ref} other) {
         #{it} it;
         #{type} set;
         #{assert}(self);
@@ -382,7 +385,7 @@ class HashSet < Collection
         #{dtor}(self);
         *self = set;
       }
-      #{define} void #{invert}(#{type}* self, #{type}* other) {
+      #{define} void #{invert}(#{type_ref} self, #{type_ref} other) {
         #{it} it;
         #{type} set;
         #{assert}(self);
@@ -401,12 +404,12 @@ class HashSet < Collection
         #{dtor}(self);
         *self = set;
       }
-      #{define} void #{itCtor}(#{it}* self, #{type}* set) {
+      #{define} void #{itCtor}(#{it_ref} self, #{type_ref} set) {
         #{assert}(self);
         self->set = set;
         self->bucket_index = -1;
       }
-      #{define} int #{itMove}(#{it}* self) {
+      #{define} int #{itMove}(#{it_ref} self) {
         #{assert}(self);
         if(self->bucket_index < 0) #{@list.itCtor}(&self->it, &self->set->buckets[self->bucket_index = 0]);
         if(#{@list.itMove}(&self->it)) return 1;
@@ -416,17 +419,24 @@ class HashSet < Collection
         }
         return 0;
       }
-      #{define} #{element.type} #{itGet}(#{it}* self) {
+      #{define} #{element.type} #{itGet}(#{it_ref} self) {
         #{assert}(self);
         return #{@list.itGet}(&self->it);
       }
-      #{define} #{element.type}* #{itGetRef}(#{it}* self) {
+      #{define} #{element.type_ref} #{itGetRef}(#{it_ref} self) {
         #{assert}(self);
         return #{@list.itGetRef}(&self->it);
       }
     $
   end
   
+  private
+  
+  def key_type_check(obj)
+    raise "type #{obj.type} (#{obj}) must be hashable" unless obj.hashable?
+    element_type_check(obj)
+  end
+
 end # HashSet
 
 

data/lib/autoc/collection/list.rb

@@ -154,7 +154,12 @@ WARNING: current position *must* be valid otherwise the behavior is undefined. S
 =end
 class List < Collection
   
-  def write_exported_types(stream)
+  def initialize(*args)
+    super
+    @capability.subtract [:orderable]
+  end
+  
+  def write_intf_types(stream)
     stream << %$
       /***
       **** #{type}<#{element.type}> (#{self.class})
@@ -170,7 +175,7 @@ class List < Collection
       };
       struct #{it} {
         int start;
-        #{type}* list;
+        #{type_ref} list;
         #{node}* this_node;
       };
       struct #{node} {
@@ -180,42 +185,43 @@ class List < Collection
     $
   end
   
-  def write_exported_declarations(stream, declare, define)
+  def write_intf_decls(stream, declare, define)
+    super
     stream << %$
-      #{declare} void #{ctor}(#{type}*);
-      #{declare} void #{dtor}(#{type}*);
-      #{declare} void #{copy}(#{type}*, #{type}*);
-      #{declare} int #{equal}(#{type}*, #{type}*);
-      #{declare} size_t #{identify}(#{type}*);
-      #{declare} void #{purge}(#{type}*);
-      #{declare} #{element.type} #{peek}(#{type}*);
-      #{declare} #{element.type} #{pop}(#{type}*);
-      #{declare} void #{push}(#{type}*, #{element.type});
-      #{declare} int #{contains}(#{type}*, #{element.type});
-      #{declare} #{element.type} #{find}(#{type}*, #{element.type});
+      #{declare} #{ctor.declaration};
+      #{declare} #{dtor.declaration};
+      #{declare} #{copy.declaration};
+      #{declare} #{equal.declaration};
+      #{declare} #{identify.declaration};
+      #{declare} void #{purge}(#{type_ref});
+      #{declare} #{element.type} #{peek}(#{type_ref});
+      #{declare} #{element.type} #{pop}(#{type_ref});
+      #{declare} void #{push}(#{type_ref}, #{element.type});
+      #{declare} int #{contains}(#{type_ref}, #{element.type});
+      #{declare} #{element.type} #{find}(#{type_ref}, #{element.type});
       #define #{replace}(self, with) #{replaceEx}(self, with, 1)
       #define #{replaceAll}(self, with) #{replaceEx}(self, with, -1)
-      #{declare} int #{replaceEx}(#{type}*, #{element.type}, int);
+      #{declare} int #{replaceEx}(#{type_ref}, #{element.type}, int);
       #define #{remove}(self, what) #{removeEx}(self, what, 1)
       #define #{removeAll}(self, what) #{removeEx}(self, what, -1)
-      #{declare} int #{removeEx}(#{type}*, #{element.type}, int);
-      #{declare} size_t #{size}(#{type}*);
+      #{declare} int #{removeEx}(#{type_ref}, #{element.type}, int);
+      #{declare} size_t #{size}(#{type_ref});
       #define #{empty}(self) (#{size}(self) == 0)
-      #{declare} void #{itCtor}(#{it}*, #{type}*);
-      #{declare} int #{itMove}(#{it}*);
-      #{declare} #{element.type} #{itGet}(#{it}*);
+      #{declare} void #{itCtor}(#{it_ref}, #{type_ref});
+      #{declare} int #{itMove}(#{it_ref});
+      #{declare} #{element.type} #{itGet}(#{it_ref});
     $
   end
   
-  def write_implementations(stream, define)
+  def write_impls(stream, define)
     stream << %$
-      #{define} #{element.type}* #{itGetRef}(#{it}*);
-      #{define} void #{ctor}(#{type}* self) {
+      #{define} #{element.type_ref} #{itGetRef}(#{it_ref});
+      #{define} #{ctor.definition} {
         #{assert}(self);
         self->head_node = NULL;
         self->node_count = 0;
       }
-      #{define} void #{dtor}(#{type}* self) {
+      #{define} #{dtor.definition} {
         #{node}* node;
         #{assert}(self);
         node = self->head_node;
@@ -226,7 +232,7 @@ class List < Collection
           #{free}(this_node);
         }
       }
-      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+      #{define} #{copy.definition} {
         #{it} it;
         #{assert}(src);
         #{assert}(dst);
@@ -236,14 +242,15 @@ class List < Collection
           #{push}(dst, *#{itGetRef}(&it));
         }
       }
-      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+      #{define} #{equal.definition} {
         if(#{size}(lt) == #{size}(rt)) {
           #{it} lit, rit;
           #{itCtor}(&lit, lt);
           #{itCtor}(&rit, rt);
           while(#{itMove}(&lit) && #{itMove}(&rit)) {
             int equal;
-            #{element.type} *le, *re;
+            #{element.type_ref} le;
+            #{element.type_ref} re;
             le = #{itGetRef}(&lit);
             re = #{itGetRef}(&rit);
             equal = #{element.equal("*le", "*re")};
@@ -253,7 +260,7 @@ class List < Collection
         } else
           return 0;
       }
-      #{define} size_t #{identify}(#{type}* self) {
+      #{define} #{identify.definition} {
         #{node}* node;
         size_t result = 0;
         #{assert}(self);
@@ -263,18 +270,18 @@ class List < Collection
         }
         return result;
       }
-      #{define} void #{purge}(#{type}* self) {
+      #{define} void #{purge}(#{type_ref} self) {
         #{dtor}(self);
         #{ctor}(self);
       }
-      #{define} #{element.type} #{peek}(#{type}* self) {
+      #{define} #{element.type} #{peek}(#{type_ref} self) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(!#{empty}(self));
         #{element.copy("result", "self->head_node->element")};
         return result;
       }
-      #{define} #{element.type} #{pop}(#{type}* self) {
+      #{define} #{element.type} #{pop}(#{type_ref} self) {
         #{node}* node;
         #{element.type} result;
         #{assert}(self);
@@ -286,7 +293,7 @@ class List < Collection
         #{free}(node);
         return result;
       }
-      #{define} void #{push}(#{type}* self, #{element.type} element) {
+      #{define} void #{push}(#{type_ref} self, #{element.type} element) {
         #{node}* node;
         #{assert}(self);
         node = (#{node}*)#{malloc}(sizeof(#{node})); #{assert}(node);
@@ -295,7 +302,7 @@ class List < Collection
         self->head_node = node;
         ++self->node_count;
       }
-      #{define} int #{contains}(#{type}* self, #{element.type} what) {
+      #{define} int #{contains}(#{type_ref} self, #{element.type} what) {
         #{node}* node;
         int found = 0;
         #{assert}(self);
@@ -309,7 +316,7 @@ class List < Collection
         }
         return found;
       }
-      #{define} #{element.type} #{find}(#{type}* self, #{element.type} what) {
+      #{define} #{element.type} #{find}(#{type_ref} self, #{element.type} what) {
         #{node}* node;
         #{assert}(self);
         #{assert}(#{contains}(self, what));
@@ -324,7 +331,7 @@ class List < Collection
         }
         #{abort}();
       }
-      #{define} int #{replaceEx}(#{type}* self, #{element.type} with, int count) {
+      #{define} int #{replaceEx}(#{type_ref} self, #{element.type} with, int count) {
         #{node}* node;
         int replaced = 0;
         #{assert}(self);
@@ -341,7 +348,7 @@ class List < Collection
         }
         return replaced;
       }
-      #{define} int #{removeEx}(#{type}* self, #{element.type} what, int count) {
+      #{define} int #{removeEx}(#{type_ref} self, #{element.type} what, int count) {
         #{node} *node, *prev_node;
         int removed = 0;
         #{assert}(self);
@@ -369,17 +376,17 @@ class List < Collection
         }
         return removed;
       }
-      #{define} size_t #{size}(#{type}* self) {
+      #{define} size_t #{size}(#{type_ref} self) {
         #{assert}(self);
         return self->node_count;
       }
-      #{define} void #{itCtor}(#{it}* self, #{type}* list) {
+      #{define} void #{itCtor}(#{it_ref} self, #{type_ref} list) {
         #{assert}(self);
         #{assert}(list);
         self->start = 1;
         self->list = list;
       }
-      #{define} int #{itMove}(#{it}* self) {
+      #{define} int #{itMove}(#{it_ref} self) {
         #{assert}(self);
         if(self->start) {
           self->this_node = self->list->head_node;
@@ -389,14 +396,14 @@ class List < Collection
         }
         return self->this_node != NULL;
       }
-      #{define} #{element.type} #{itGet}(#{it}* self) {
+      #{define} #{element.type} #{itGet}(#{it_ref} self) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(self->this_node);
         #{element.copy("result", "self->this_node->element")};
         return result;
       }
-      #{define} #{element.type}* #{itGetRef}(#{it}* self) {
+      #{define} #{element.type_ref} #{itGetRef}(#{it_ref} self) {
         #{assert}(self);
         #{assert}(self->this_node);
         return &self->this_node->element;