autoc 1.1 → 1.2

data/lib/autoc/collection/queue.rb

@@ -193,7 +193,12 @@ WARNING: current position *must* be valid otherwise the behavior is undefined. S
 =end
 class Queue < 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})
@@ -210,7 +215,7 @@ class Queue < Collection
       };
       struct #{it} {
         int start, forward;
-        #{type}* queue;
+        #{type_ref} queue;
         #{node}* this_node;
       };
       struct #{node} {
@@ -221,50 +226,51 @@ class Queue < 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} #{ctor.declaration};
+      #{declare} #{dtor.declaration};
+      #{declare} #{copy.declaration};
+      #{declare} #{equal.declaration};
+      #{declare} #{identify.declaration};
+      #{declare} void #{purge}(#{type_ref});
       #define #{peek}(self) #{peekHead}(self)
-      #{declare} #{element.type} #{peekHead}(#{type}*);
-      #{declare} #{element.type} #{peekTail}(#{type}*);
+      #{declare} #{element.type} #{peekHead}(#{type_ref});
+      #{declare} #{element.type} #{peekTail}(#{type_ref});
       #define #{push}(self, element) #{pushTail}(self, element)
-      #{declare} void #{pushTail}(#{type}*, #{element.type});
-      #{declare} void #{pushHead}(#{type}*, #{element.type});
+      #{declare} void #{pushTail}(#{type_ref}, #{element.type});
+      #{declare} void #{pushHead}(#{type_ref}, #{element.type});
       #define #{pop}(self) #{popHead}(self)
-      #{declare} #{element.type} #{popHead}(#{type}*);
-      #{declare} #{element.type} #{popTail}(#{type}*);
-      #{declare} int #{contains}(#{type}*, #{element.type});
-      #{declare} #{element.type} #{find}(#{type}*, #{element.type});
+      #{declare} #{element.type} #{popHead}(#{type_ref});
+      #{declare} #{element.type} #{popTail}(#{type_ref});
+      #{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} void #{itCtor}(#{it_ref}, #{type_ref});
       #define #{itCtor}(self, type) #{itCtorEx}(self, type, 1)
-      #{declare} void #{itCtorEx}(#{it}*, #{type}*, int);
-      #{declare} int #{itMove}(#{it}*);
-      #{declare} #{element.type} #{itGet}(#{it}*);
+      #{declare} void #{itCtorEx}(#{it_ref}, #{type_ref}, int);
+      #{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 = self->tail_node = NULL;
         self->node_count = 0;
       }
-      #{define} void #{dtor}(#{type}* self) {
+      #{define} #{dtor.definition} {
         #{node}* node;
         #{assert}(self);
         node = self->head_node;
@@ -275,7 +281,7 @@ class Queue < Collection
           #{free}(this_node);
         }
       }
-      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+      #{define} #{copy.definition} {
         #{it} it;
         #{assert}(src);
         #{assert}(dst);
@@ -287,7 +293,7 @@ class Queue < Collection
           #{element.dtor("element")};
         }
       }
-      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+      #{define} #{equal.definition} {
         if(#{size}(lt) == #{size}(rt)) {
           #{it} lit, rit;
           #{itCtor}(&lit, lt);
@@ -304,7 +310,7 @@ class Queue < Collection
         } else
           return 0;
       }
-      #{define} size_t #{identify}(#{type}* self) {
+      #{define} #{identify.definition} {
         #{node}* node;
         size_t result = 0;
         #{assert}(self);
@@ -314,25 +320,25 @@ class Queue < Collection
         }
         return result;
       }
-      #{define} void #{purge}(#{type}* self) {
+      #{define} void #{purge}(#{type_ref} self) {
         #{dtor}(self);
         #{ctor}(self);
       }
-      #{define} #{element.type} #{peekHead}(#{type}* self) {
+      #{define} #{element.type} #{peekHead}(#{type_ref} self) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(!#{empty}(self));
         #{element.copy("result", "self->head_node->element")};
         return result;
       }
-      #{define} #{element.type} #{peekTail}(#{type}* self) {
+      #{define} #{element.type} #{peekTail}(#{type_ref} self) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(!#{empty}(self));
         #{element.copy("result", "self->tail_node->element")};
         return result;
       }
-      #{define} #{element.type} #{popHead}(#{type}* self) {
+      #{define} #{element.type} #{popHead}(#{type_ref} self) {
         #{node}* node;
         #{element.type} result;
         #{assert}(self);
@@ -345,7 +351,7 @@ class Queue < Collection
         #{free}(node);
         return result;
       }
-      #{define} #{element.type} #{popTail}(#{type}* self) {
+      #{define} #{element.type} #{popTail}(#{type_ref} self) {
         #{node}* node;
         #{element.type} result;
         #{assert}(self);
@@ -358,7 +364,7 @@ class Queue < Collection
         #{free}(node);
         return result;
       }
-      #{define} void #{pushTail}(#{type}* self, #{element.type} element) {
+      #{define} void #{pushTail}(#{type_ref} self, #{element.type} element) {
         #{node}* node;
         #{assert}(self);
         node = (#{node}*)#{malloc}(sizeof(#{node})); #{assert}(node);
@@ -374,7 +380,7 @@ class Queue < Collection
         }
         ++self->node_count;
       }
-      #{define} void #{pushHead}(#{type}* self, #{element.type} element) {
+      #{define} void #{pushHead}(#{type_ref} self, #{element.type} element) {
         #{node}* node;
         #{assert}(self);
         node = (#{node}*)#{malloc}(sizeof(#{node})); #{assert}(node);
@@ -390,7 +396,7 @@ class Queue < Collection
         }
         ++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);
@@ -404,7 +410,7 @@ class Queue < 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));
@@ -419,7 +425,7 @@ class Queue < 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);
@@ -436,7 +442,7 @@ class Queue < 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;
         int removed = 0;
         #{assert}(self);
@@ -472,18 +478,18 @@ class Queue < Collection
         }
         return removed;
       }
-      #{define} size_t #{size}(#{type}* self) {
+      #{define} size_t #{size}(#{type_ref} self) {
         #{assert}(self);
         return self->node_count;
       }
-      #{define} void #{itCtorEx}(#{it}* self, #{type}* queue, int forward) {
+      #{define} void #{itCtorEx}(#{it_ref} self, #{type_ref} queue, int forward) {
         #{assert}(self);
         #{assert}(queue);
         self->start = 1;
         self->queue = queue;
         self->forward = forward;
       }
-      #{define} int #{itMove}(#{it}* self) {
+      #{define} int #{itMove}(#{it_ref} self) {
         #{assert}(self);
         if(self->start) {
           self->this_node = self->forward ? self->queue->head_node : self->queue->tail_node;
@@ -493,14 +499,14 @@ class Queue < 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;

data/lib/autoc/collection/vector.rb

@@ -78,8 +78,12 @@ Return number of elements stored in vector +self+.
 
 |*_void_* ~type~Sort(*_Type_* * +self+)
 |
+NOTE : optional operation.
+
 Perform a sorting operation on the contents of vector +self+ utilizing either generated of user supplied ordering functions.
 
+Note that this operation is defined only if element type is orderable, e.g. has equality testing and comparison operations defined.
+
 |*_int_* ~type~Within(*_Type_* * +self+, *_size_t_* +index+)
 |
 Return non-zero value if +index+ is a valid index and zero value otherwise.
@@ -117,11 +121,15 @@ WARNING: current position *must* be valid otherwise the behavior is undefined. S
 =end
 class Vector < Collection
 
-  def ctor(*args)
-    args.empty? ? super() : raise("#{self.class} provides no default constructor")
+  def initialize(*args)
+    super
+    # Override the default type constructor as the Vector's requires one extra parameter
+    # Note that this makes the Vector instance un-constructible
+    @ctor = define_function(:ctor, Function::Signature.new([type_ref^:self, :size_t^:element_count]))
+    @capability.subtract [:constructible, :orderable] # No default constructor and no less operation defined
   end
-  
-  def write_exported_types(stream)
+
+  def write_intf_types(stream)
     stream << %$
       /***
       **** #{type}<#{element.type}> (#{self.class})
@@ -131,76 +139,79 @@ class Vector < Collection
       typedef struct #{type} #{type};
       typedef struct #{it} #{it};
       struct #{type} {
-        #{element.type}* values;
+        #{element.type_ref} values;
         size_t element_count;
       };
       struct #{it} {
-        #{type}* vector;
+        #{type_ref} vector;
         int index;
         int forward;
       };
     $
   end
   
-  def write_exported_declarations(stream, declare, define)
+  def write_intf_decls(stream, declare, define)
+    super
     stream << %$
-      #{declare} void #{ctor}(#{type}*, size_t);
-      #{declare} void #{dtor}(#{type}*);
-      #{declare} void #{copy}(#{type}*, #{type}*);
-      #{declare} int #{equal}(#{type}*, #{type}*);
-      #{declare} void #{resize}(#{type}*, size_t);
-      #{declare} size_t #{identify}(#{type}*);
-      #{define} size_t #{size}(#{type}* self) {
+      #{declare} #{ctor.declaration};
+      #{declare} #{dtor.declaration};
+      #{declare} #{copy.declaration};
+      #{declare} #{equal.declaration};
+      #{declare} #{identify.declaration};
+      #{declare} void #{resize}(#{type_ref}, size_t);
+      #{define} size_t #{size}(#{type_ref} self) {
         #{assert}(self);
         return self->element_count;
       }
-      #{define} int #{within}(#{type}* self, size_t index) {
+      #{define} int #{within}(#{type_ref} self, size_t index) {
         #{assert}(self);
         return index < #{size}(self);
       }
-      #{define} #{element.type} #{get}(#{type}* self, size_t index) {
+      #{define} #{element.type} #{get}(#{type_ref} self, size_t index) {
         #{element.type} result;
         #{assert}(self);
         #{assert}(#{within}(self, index));
         #{element.copy("result", "self->values[index]")};
         return result;
       }
-      #{define} void #{set}(#{type}* self, size_t index, #{element.type} value) {
+      #{define} void #{set}(#{type_ref} self, size_t index, #{element.type} value) {
         #{assert}(self);
         #{assert}(#{within}(self, index));
         #{element.dtor("self->values[index]")};
         #{element.copy("self->values[index]", "value")};
       }
-      #{declare} void #{sort}(#{type}*);
       #define #{itCtor}(self, type) #{itCtorEx}(self, type, 1)
-      #{define} void #{itCtorEx}(#{it}* self, #{type}* vector, int forward) {
+      #{define} void #{itCtorEx}(#{it_ref} self, #{type_ref} vector, int forward) {
         #{assert}(self);
         #{assert}(vector);
         self->vector = vector;
         self->forward = forward;
         self->index = forward ? -1 : #{size}(vector);
       }
-      #{define} int #{itMove}(#{it}* self) {
+      #{define} int #{itMove}(#{it_ref} self) {
         #{assert}(self);
         if(self->forward) ++self->index; else --self->index;
         return #{within}(self->vector, self->index);
       }
-      #{define} #{element.type} #{itGet}(#{it}* self) {
+      #{define} #{element.type} #{itGet}(#{it_ref} self) {
         #{assert}(self);
         return #{get}(self->vector, self->index);
       }
     $
+    stream << %$
+      #{declare} void #{sort}(#{type_ref});
+    $ if element.orderable?
   end
   
-  def write_implementations(stream, define)
+  def write_impls(stream, define)
     stream << %$
-      static void #{allocate}(#{type}* self, size_t element_count) {
+      static void #{allocate}(#{type_ref} self, size_t element_count) {
         #{assert}(self);
         #{assert}(element_count > 0);
         self->element_count = element_count;
         self->values = (#{element.type}*)#{malloc}(element_count*sizeof(#{element.type})); #{assert}(self->values);
       }
-      #{define} void #{ctor}(#{type}* self, size_t element_count) {
+      #{define} #{ctor.definition} {
         size_t index;
         #{assert}(self);
         #{allocate}(self, element_count);
@@ -208,7 +219,7 @@ class Vector < Collection
           #{element.ctor("self->values[index]")};
         }
       }
-      #{define} void #{dtor}(#{type}* self) {
+      #{define} #{dtor.definition} {
         size_t index;
         #{assert}(self);
         for(index = 0; index < #{size}(self); ++index) {
@@ -216,7 +227,7 @@ class Vector < Collection
         }
         #{free}(self->values);
       }
-      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+      #{define} #{copy.definition} {
         size_t index, size;
         #{assert}(src);
         #{assert}(dst);
@@ -225,7 +236,7 @@ class Vector < Collection
           #{element.copy("dst->values[index]", "src->values[index]")};
         }
       }
-      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+      #{define} #{equal.definition} {
         size_t index, size;
         #{assert}(lt);
         #{assert}(rt);
@@ -237,11 +248,20 @@ class Vector < Collection
         } else
           return 0;
       }
-      #{define} void #{resize}(#{type}* self, size_t new_element_count) {
+      #{define} #{identify.definition} {
+        size_t index, result = 0;
+        #{assert}(self);
+        for(index = 0; index < self->element_count; ++index) {
+          result ^= #{element.identify("self->values[index]")};
+          result = AUTOC_RCYCLE(result);
+        }
+        return result;
+      }
+      #{define} void #{resize}(#{type_ref} self, size_t new_element_count) {
         size_t index, element_count, from, to;
         #{assert}(self);
         if((element_count = #{size}(self)) != new_element_count) {
-          #{element.type}* values = (#{element.type}*)#{malloc}(new_element_count*sizeof(#{element.type})); #{assert}(values);
+          #{element.type_ref} values = (#{element.type_ref})#{malloc}(new_element_count*sizeof(#{element.type})); #{assert}(values);
           from = AUTOC_MIN(element_count, new_element_count);
           to = AUTOC_MAX(element_count, new_element_count);
           for(index = 0; index < from; ++index) {
@@ -261,18 +281,11 @@ class Vector < Collection
           self->element_count = new_element_count;
         }
       }
-      #{define} size_t #{identify}(#{type}* self) {
-        size_t index, result = 0;
-        #{assert}(self);
-        for(index = 0; index < self->element_count; ++index) {
-          result ^= #{element.identify("self->values[index]")};
-          result = AUTOC_RCYCLE(result);
-        }
-        return result;
-      }
+    $
+    stream << %$
       static int #{comparator}(void* lp_, void* rp_) {
-        #{element.type}* lp = (#{element.type}*)lp_;
-        #{element.type}* rp = (#{element.type}*)rp_;
+        #{element.type_ref} lp = (#{element.type_ref})lp_;
+        #{element.type_ref} rp = (#{element.type_ref})rp_;
         if(#{element.equal("*lp", "*rp")}) {
           return 0;
         } else if(#{element.less("*lp", "*rp")}) {
@@ -281,14 +294,22 @@ class Vector < Collection
           return +1;
         }
       }
-      #{define} void #{sort}(#{type}* self) {
+      #{define} void #{sort}(#{type_ref} self) {
         typedef int (*F)(const void*, const void*);
         #{assert}(self);
         qsort(self->values, #{size}(self), sizeof(#{element.type}), (F)#{comparator});
       }
-    $
+    $ if element.orderable?
   end
+ 
+  private
   
+  def element_type_check(obj)
+    # Additional requirement is imposed on the vector's element
+    raise "type #{obj.type} (#{obj}) must be constructible" unless obj.constructible?
+    super
+  end
+
 end # Vector