Added some extensions to cstack and cpque. cstack can now be used as a vector-lite.

4 files changed, 33 insertions, 18 deletions

diff --git a/docs/cpque_api.md b/docs/cpque_api.md
index 3b940648..63573082 100644
--- a/docs/cpque_api.md
+++ b/docs/cpque_api.md
@@ -26,20 +26,22 @@ cpque_X                 cpque_X_init(void);
 cpque_X                 cpque_X_clone(cpque_X pq);
 
 void                    cpque_X_clear(cpque_X* self);
+void                    cpque_X_reserve(cpque_X* self, size_t n);
 void                    cpque_X_copy(cpque_X* self, cpque_X other);
-void                    cpque_X_make_heap(cpque_X* self);
-void                    cpque_X_del(cpque_X* self);      // destructor
+void                    cpque_X_del(cpque_X* self);        // destructor
 
 size_t                  cpque_X_size(cpque_X pq);
 bool                    cpque_X_empty(cpque_X pq);
 const cpque_X_value_t*  cpque_X_top(const cpque_X* self);
 
+void                    cpque_X_make_heap(cpque_X* self);  // call after using push_back().
 void                    cpque_X_push(cpque_X* self, cpque_X_value_t value);
 void                    cpque_X_emplace(cpque_X* self, cpque_X_rawvalue_t raw);
 
 void                    cpque_X_pop(cpque_X* self);
 void                    cpque_X_erase_at(cpque_X* self, size_t idx);
 
+void                    cpque_X_push_back(cpque_X* self, cpque_X_value_t value); // breaks heap-property
 cpque_X_value_t         cpque_X_value_clone(cpque_X_value_t val);
 ```
 
diff --git a/docs/cstack_api.md b/docs/cstack_api.md
index 79b515c6..91fa7de5 100644
--- a/docs/cstack_api.md
+++ b/docs/cstack_api.md
@@ -26,6 +26,8 @@ cstack_X                cstack_X_init(void);
 cstack_X                cstack_X_clone(cstack_X st);
 
 void                    cstack_X_clear(cstack_X* self);
+void                    cstack_X_reserve(cstack_X* self, size_t n);
+void                    cstack_X_shrink_to_fit(cstack_X* self);
 void                    cstack_X_copy(cstack_X* self, cstack_X other);
 void                    cstack_X_del(cstack_X* self);      // destructor
 
@@ -42,6 +44,7 @@ cstack_X_iter_t         cstack_X_begin(const cstack_X* self);
 cstack_X_iter_t         cstack_X_end(const cstack_X* self);
 void                    cstack_X_next(cstack_X_iter_t* it);
 
+cstack_X_rawvalue_t     cstack_X_value_toraw(cvec_X_value_t* pval);
 cstack_X_value_t        cstack_X_value_clone(cstack_X_value_t val);
 ```
 
diff --git a/include/stc/cpque.h b/include/stc/cpque.h
index 7a81d486..642f04cb 100644
--- a/include/stc/cpque.h
+++ b/include/stc/cpque.h
@@ -51,6 +51,11 @@ STC_INLINE Self cx_memb(_with_capacity)(size_t cap) {
     return out;

 }

 

+STC_INLINE void cx_memb(_reserve)(Self* self, size_t n) {

+    if (n >= self->size)

+        self->data = (cx_value_t *)c_realloc(self->data, (self->capacity = n)*sizeof(cx_rawvalue_t));

+}

+

 STC_INLINE void cx_memb(_clear)(Self* self) {

     size_t i = self->size; self->size = 0;

     while (i--) i_valdel(&self->data[i]);

@@ -85,17 +90,9 @@ STC_INLINE void cx_memb(_emplace)(Self* self, cx_rawvalue_t raw)
 STC_INLINE i_val cx_memb(_value_clone)(cx_value_t val)

     { return i_valfrom(i_valto(&val)); }

 

-STC_INLINE int cx_memb(_value_compare)(const cx_value_t* x, const cx_value_t* y) {

-    cx_rawvalue_t rx = i_valto(x), ry = i_valto(y);

-    return i_cmp(&rx, &ry);

-}

-

 STC_INLINE void

 cx_memb(_push_back)(Self* self, cx_value_t value) {

-    if (self->size == self->capacity) {

-        self->capacity = self->size*3/2 + 4;

-        self->data = (cx_value_t *)c_realloc(self->data, self->capacity*sizeof value);

-    }

+    if (self->size == self->capacity) cx_memb(_reserve)(self, self->size*3/2 + 4);

     self->data[ self->size++ ] = value;

 }

 

diff --git a/include/stc/cstack.h b/include/stc/cstack.h
index 2aaff4d9..7bc0f3fb 100644
--- a/include/stc/cstack.h
+++ b/include/stc/cstack.h
@@ -42,7 +42,13 @@ STC_INLINE Self cx_memb(_init)(void)
     { return c_make(Self){0, 0, 0}; }

 

 STC_INLINE Self cx_memb(_with_capacity)(size_t cap) {

-    Self out = {(cx_value_t *) c_malloc(cap*sizeof(cx_value_t)), 0, cap};

+    Self out = {(cx_value_t *) c_malloc(cap*sizeof(i_val)), 0, cap};

+    return out;

+}

+

+STC_INLINE Self cx_memb(_with_size)(size_t size, i_val fill) {

+    Self out = {(cx_value_t *) c_malloc(size*sizeof fill), size, size};

+    while (size) out.data[--size] = fill;

     return out;

 }

 

@@ -69,12 +75,17 @@ STC_INLINE cx_value_t* cx_memb(_top)(const Self* self)
 STC_INLINE void cx_memb(_pop)(Self* self)

     { --self->size; i_valdel(&self->data[self->size]); }

 

-STC_INLINE void cx_memb(_push)(Self* self, cx_value_t value) {

-    if (self->size == self->capacity) {

-        self->capacity = self->size*3/2 + 4;

-        self->data = (cx_value_t *)c_realloc(self->data, self->capacity*sizeof value);

-    }

-    self->data[ self->size++ ] = value;

+STC_INLINE void cx_memb(_reserve)(Self* self, size_t n) {

+    if (n >= self->size)

+        self->data = (cx_value_t *)c_realloc(self->data, (self->capacity = n)*sizeof(cx_rawvalue_t));

+}

+

+STC_INLINE void cx_memb(_shrink_to_fit)(Self* self)

+    { cx_memb(_reserve)(self, self->size); }

+

+STC_INLINE void cx_memb(_push)(Self* self, cx_value_t val) {

+    if (self->size == self->capacity) cx_memb(_reserve)(self, self->size*3/2 + 4);

+    self->data[ self->size++ ] = val;

 }

 

 STC_INLINE void cx_memb(_emplace)(Self* self, cx_rawvalue_t raw)

@@ -93,6 +104,8 @@ STC_INLINE void cx_memb(_copy)(Self *self, Self other) {
 

 STC_INLINE i_val cx_memb(_value_clone)(cx_value_t val)

     { return i_valfrom(i_valto(&val)); }

+STC_INLINE i_valraw cx_memb(_value_toraw)(cx_value_t* val)

+    { return i_valto(val); }

 

 STC_INLINE cx_iter_t cx_memb(_begin)(const Self* self)

     { return c_make(cx_iter_t){self->data}; }