Enlightenment CVS committal
Author : mej
Project : eterm
Module : libast
Dir : eterm/libast/src
Modified Files:
dlinked_list.c linked_list.c
Log Message:
Wed Nov 19 17:39:01 2003 Michael Jennings (mej)
Added linked_list and dlinked_list implementations of the vector
interface.
Added iterator functionality for linked_list and dlinked_list.
Added unit tests for the above.
===================================================================
RCS file: /cvsroot/enlightenment/eterm/libast/src/dlinked_list.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -3 -r1.10 -r1.11
--- dlinked_list.c 19 Nov 2003 04:21:15 -0000 1.10
+++ dlinked_list.c 19 Nov 2003 22:39:57 -0000 1.11
@@ -21,7 +21,7 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-static const char cvs_ident[] = "$Id: dlinked_list.c,v 1.10 2003/11/19 04:21:15 mej
Exp $";
+static const char cvs_ident[] = "$Id: dlinked_list.c,v 1.11 2003/11/19 22:39:57 mej
Exp $";
#ifdef HAVE_CONFIG_H
# include <config.h>
@@ -29,6 +29,14 @@
#include <libast_internal.h>
+/* *INDENT-OFF* */
+SPIF_DECL_OBJ(dlinked_list_iterator) {
+ SPIF_DECL_PARENT_TYPE(obj);
+ spif_dlinked_list_t subject;
+ spif_dlinked_list_item_t current;
+};
+/* *INDENT-ON* */
+
static spif_dlinked_list_item_t spif_dlinked_list_item_new(void);
static spif_bool_t spif_dlinked_list_item_init(spif_dlinked_list_item_t);
static spif_bool_t spif_dlinked_list_item_done(spif_dlinked_list_item_t);
@@ -41,17 +49,22 @@
static spif_bool_t spif_dlinked_list_item_set_data(spif_dlinked_list_item_t,
spif_obj_t);
static spif_dlinked_list_t spif_dlinked_list_new(void);
+static spif_dlinked_list_t spif_dlinked_list_vector_new(void);
static spif_bool_t spif_dlinked_list_init(spif_dlinked_list_t);
+static spif_bool_t spif_dlinked_list_vector_init(spif_dlinked_list_t);
static spif_bool_t spif_dlinked_list_done(spif_dlinked_list_t);
static spif_bool_t spif_dlinked_list_del(spif_dlinked_list_t);
static spif_str_t spif_dlinked_list_show(spif_dlinked_list_t, spif_charptr_t,
spif_str_t, size_t);
static spif_cmp_t spif_dlinked_list_comp(spif_dlinked_list_t, spif_dlinked_list_t);
static spif_dlinked_list_t spif_dlinked_list_dup(spif_dlinked_list_t);
+static spif_dlinked_list_t spif_dlinked_list_vector_dup(spif_dlinked_list_t);
static spif_classname_t spif_dlinked_list_type(spif_dlinked_list_t);
static spif_bool_t spif_dlinked_list_append(spif_dlinked_list_t, spif_obj_t);
static spif_bool_t spif_dlinked_list_contains(spif_dlinked_list_t, spif_obj_t);
+static spif_bool_t spif_dlinked_list_vector_contains(spif_dlinked_list_t, spif_obj_t);
static size_t spif_dlinked_list_count(spif_dlinked_list_t);
static spif_obj_t spif_dlinked_list_find(spif_dlinked_list_t, spif_obj_t);
+static spif_obj_t spif_dlinked_list_vector_find(spif_dlinked_list_t, spif_obj_t);
static spif_obj_t spif_dlinked_list_get(spif_dlinked_list_t, size_t);
static size_t spif_dlinked_list_index(spif_dlinked_list_t, spif_obj_t);
static spif_bool_t spif_dlinked_list_insert(spif_dlinked_list_t, spif_obj_t);
@@ -62,6 +75,16 @@
static spif_obj_t spif_dlinked_list_remove_at(spif_dlinked_list_t, size_t);
static spif_bool_t spif_dlinked_list_reverse(spif_dlinked_list_t);
static spif_obj_t *spif_dlinked_list_to_array(spif_dlinked_list_t);
+static spif_dlinked_list_iterator_t
spif_dlinked_list_iterator_new(spif_dlinked_list_t subject);
+static spif_bool_t spif_dlinked_list_iterator_init(spif_dlinked_list_iterator_t self,
spif_dlinked_list_t subject);
+static spif_bool_t spif_dlinked_list_iterator_done(spif_dlinked_list_iterator_t self);
+static spif_bool_t spif_dlinked_list_iterator_del(spif_dlinked_list_iterator_t self);
+static spif_str_t spif_dlinked_list_iterator_show(spif_dlinked_list_iterator_t self,
spif_charptr_t name, spif_str_t buff, size_t indent);
+static spif_cmp_t spif_dlinked_list_iterator_comp(spif_dlinked_list_iterator_t self,
spif_dlinked_list_iterator_t other);
+static spif_dlinked_list_iterator_t
spif_dlinked_list_iterator_dup(spif_dlinked_list_iterator_t self);
+static spif_classname_t spif_dlinked_list_iterator_type(spif_dlinked_list_iterator_t
self);
+static spif_bool_t spif_dlinked_list_iterator_has_next(spif_dlinked_list_iterator_t
self);
+static spif_obj_t spif_dlinked_list_iterator_next(spif_dlinked_list_iterator_t self);
/* *INDENT-OFF* */
static SPIF_CONST_TYPE(class) dli_class = {
@@ -105,6 +128,45 @@
(spif_func_t) spif_dlinked_list_to_array
};
spif_listclass_t SPIF_LISTCLASS_VAR(dlinked_list) = &dl_class;
+
+static spif_const_vectorclass_t dlv_class = {
+ {
+ SPIF_DECL_CLASSNAME(dlinked_list),
+ (spif_func_t) spif_dlinked_list_vector_new,
+ (spif_func_t) spif_dlinked_list_vector_init,
+ (spif_func_t) spif_dlinked_list_done,
+ (spif_func_t) spif_dlinked_list_del,
+ (spif_func_t) spif_dlinked_list_show,
+ (spif_func_t) spif_dlinked_list_comp,
+ (spif_func_t) spif_dlinked_list_vector_dup,
+ (spif_func_t) spif_dlinked_list_type
+ },
+ (spif_func_t) spif_dlinked_list_vector_contains,
+ (spif_func_t) spif_dlinked_list_count,
+ (spif_func_t) spif_dlinked_list_vector_find,
+ (spif_func_t) spif_dlinked_list_insert,
+ (spif_func_t) spif_dlinked_list_iterator,
+ (spif_func_t) spif_dlinked_list_remove,
+ (spif_func_t) spif_dlinked_list_to_array
+};
+spif_vectorclass_t SPIF_VECTORCLASS_VAR(dlinked_list) = &dlv_class;
+
+static spif_const_iteratorclass_t dlli_class = {
+ {
+ SPIF_DECL_CLASSNAME(dlinked_list),
+ (spif_func_t) spif_dlinked_list_iterator_new,
+ (spif_func_t) spif_dlinked_list_iterator_init,
+ (spif_func_t) spif_dlinked_list_iterator_done,
+ (spif_func_t) spif_dlinked_list_iterator_del,
+ (spif_func_t) spif_dlinked_list_iterator_show,
+ (spif_func_t) spif_dlinked_list_iterator_comp,
+ (spif_func_t) spif_dlinked_list_iterator_dup,
+ (spif_func_t) spif_dlinked_list_iterator_type
+ },
+ (spif_func_t) spif_dlinked_list_iterator_has_next,
+ (spif_func_t) spif_dlinked_list_iterator_next
+};
+spif_iteratorclass_t SPIF_ITERATORCLASS_VAR(dlinked_list) = &dlli_class;
/* *INDENT-ON* */
static spif_dlinked_list_item_t
@@ -213,6 +275,16 @@
return self;
}
+static spif_dlinked_list_t
+spif_dlinked_list_vector_new(void)
+{
+ spif_dlinked_list_t self;
+
+ self = SPIF_ALLOC(dlinked_list);
+ spif_dlinked_list_vector_init(self);
+ return self;
+}
+
static spif_bool_t
spif_dlinked_list_init(spif_dlinked_list_t self)
{
@@ -225,6 +297,17 @@
}
static spif_bool_t
+spif_dlinked_list_vector_init(spif_dlinked_list_t self)
+{
+ spif_obj_init(SPIF_OBJ(self));
+ spif_obj_set_class(SPIF_OBJ(self),
SPIF_CLASS(SPIF_VECTORCLASS_VAR(dlinked_list)));
+ self->len = 0;
+ self->head = SPIF_NULL_TYPE(dlinked_list_item);
+ self->tail = SPIF_NULL_TYPE(dlinked_list_item);
+ return TRUE;
+}
+
+static spif_bool_t
spif_dlinked_list_done(spif_dlinked_list_t self)
{
spif_dlinked_list_item_t current;
@@ -308,6 +391,26 @@
return tmp;
}
+static spif_dlinked_list_t
+spif_dlinked_list_vector_dup(spif_dlinked_list_t self)
+{
+ spif_dlinked_list_t tmp;
+ spif_dlinked_list_item_t src, dest, prev;
+
+ tmp = spif_dlinked_list_vector_new();
+ memcpy(tmp, self, SPIF_SIZEOF_TYPE(dlinked_list));
+ tmp->head = spif_dlinked_list_item_dup(self->head);
+ for (src = self->head, dest = tmp->head, prev = SPIF_NULL_TYPE(dlinked_list_item);
+ src->next;
+ src = src->next, prev = dest, dest = dest->next) {
+ dest->next = spif_dlinked_list_item_dup(src->next);
+ dest->prev = prev;
+ }
+ dest->next = SPIF_NULL_TYPE(dlinked_list_item);
+ tmp->tail = prev;
+ return tmp;
+}
+
static spif_classname_t
spif_dlinked_list_type(spif_dlinked_list_t self)
{
@@ -343,6 +446,12 @@
return ((SPIF_LIST_ISNULL(spif_dlinked_list_find(self, obj))) ? (FALSE) : (TRUE));
}
+static spif_bool_t
+spif_dlinked_list_vector_contains(spif_dlinked_list_t self, spif_obj_t obj)
+{
+ return ((SPIF_LIST_ISNULL(spif_dlinked_list_vector_find(self, obj))) ? (FALSE) :
(TRUE));
+}
+
static size_t
spif_dlinked_list_count(spif_dlinked_list_t self)
{
@@ -363,6 +472,24 @@
}
static spif_obj_t
+spif_dlinked_list_vector_find(spif_dlinked_list_t self, spif_obj_t obj)
+{
+ spif_dlinked_list_item_t current;
+
+ for (current = self->head; current; current = current->next) {
+ spif_cmp_t c;
+
+ c = SPIF_OBJ_COMP(current->data, obj);
+ if (SPIF_CMP_IS_EQUAL(c)) {
+ return current->data;
+ } else if (SPIF_CMP_IS_GREATER(c)) {
+ break;
+ }
+ }
+ return SPIF_NULL_TYPE(obj);
+}
+
+static spif_obj_t
spif_dlinked_list_get(spif_dlinked_list_t self, size_t idx)
{
size_t i;
@@ -455,8 +582,7 @@
static spif_iterator_t
spif_dlinked_list_iterator(spif_dlinked_list_t self)
{
- USE_VAR(self);
- return SPIF_NULL_TYPE(iterator);
+ return SPIF_CAST(iterator) spif_dlinked_list_iterator_new(self);
}
static spif_bool_t
@@ -581,5 +707,121 @@
for (i = 0, current = self->head; i < self->len; current = current->next, i++) {
tmp[i] = SPIF_CAST(obj) SPIF_OBJ(spif_dlinked_list_item_get_data(current));
}
+ return tmp;
+}
+
+static spif_dlinked_list_iterator_t
+spif_dlinked_list_iterator_new(spif_dlinked_list_t subject)
+{
+ spif_dlinked_list_iterator_t self;
+
+ self = SPIF_ALLOC(dlinked_list_iterator);
+ spif_dlinked_list_iterator_init(self, subject);
+ return self;
+}
+
+static spif_bool_t
+spif_dlinked_list_iterator_init(spif_dlinked_list_iterator_t self,
spif_dlinked_list_t subject)
+{
+ spif_obj_init(SPIF_OBJ(self));
+ spif_obj_set_class(SPIF_OBJ(self),
SPIF_CLASS(SPIF_ITERATORCLASS_VAR(dlinked_list)));
+ self->subject = subject;
+ if (SPIF_LIST_ISNULL(self->subject)) {
+ self->current = SPIF_NULL_TYPE(dlinked_list_item);
+ } else {
+ self->current = self->subject->head;
+ }
+ return TRUE;
+}
+
+static spif_bool_t
+spif_dlinked_list_iterator_done(spif_dlinked_list_iterator_t self)
+{
+ self->subject = SPIF_NULL_TYPE(dlinked_list);
+ self->current = SPIF_NULL_TYPE(dlinked_list_item);
+ return TRUE;
+}
+
+static spif_bool_t
+spif_dlinked_list_iterator_del(spif_dlinked_list_iterator_t self)
+{
+ spif_dlinked_list_iterator_done(self);
+ SPIF_DEALLOC(self);
+ return TRUE;
+}
+
+static spif_str_t
+spif_dlinked_list_iterator_show(spif_dlinked_list_iterator_t self, spif_charptr_t
name, spif_str_t buff, size_t indent)
+{
+ char tmp[4096];
+
+ if (SPIF_ITERATOR_ISNULL(self)) {
+ SPIF_OBJ_SHOW_NULL(iterator, name, buff, indent, tmp);
+ return buff;
+ }
+
+ memset(tmp, ' ', indent);
+ snprintf(tmp + indent, sizeof(tmp) - indent, "(spif_dlinked_list_iterator_t) %s:
%010p {\n", name, self);
+ if (SPIF_STR_ISNULL(buff)) {
+ buff = spif_str_new_from_ptr(tmp);
+ } else {
+ spif_str_append_from_ptr(buff, tmp);
+ }
+
+ buff = spif_dlinked_list_show(self->subject, "subject", buff, indent + 2);
+ buff = spif_dlinked_list_item_show(self->current, "current", buff, indent + 2);
+
+ snprintf(tmp + indent, sizeof(tmp) - indent, "}\n");
+ spif_str_append_from_ptr(buff, tmp);
+ return buff;
+}
+
+static spif_cmp_t
+spif_dlinked_list_iterator_comp(spif_dlinked_list_iterator_t self,
spif_dlinked_list_iterator_t other)
+{
+ return spif_dlinked_list_comp(self->subject, other->subject);
+}
+
+static spif_dlinked_list_iterator_t
+spif_dlinked_list_iterator_dup(spif_dlinked_list_iterator_t self)
+{
+ spif_dlinked_list_iterator_t tmp;
+
+ tmp = spif_dlinked_list_iterator_new(self->subject);
+ tmp->current = self->current;
+ return tmp;
+}
+
+static spif_classname_t
+spif_dlinked_list_iterator_type(spif_dlinked_list_iterator_t self)
+{
+ return SPIF_OBJ_CLASSNAME(self);
+}
+
+static spif_bool_t
+spif_dlinked_list_iterator_has_next(spif_dlinked_list_iterator_t self)
+{
+ spif_dlinked_list_t subject;
+
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), FALSE);
+ subject = self->subject;
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(subject), FALSE);
+ if (self->current) {
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+static spif_obj_t
+spif_dlinked_list_iterator_next(spif_dlinked_list_iterator_t self)
+{
+ spif_obj_t tmp;
+
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(!SPIF_DLINKED_LIST_ITEM_ISNULL(self->current), SPIF_NULL_TYPE(obj));
+ tmp = self->current->data;
+ self->current = self->current->next;
return tmp;
}
===================================================================
RCS file: /cvsroot/enlightenment/eterm/libast/src/linked_list.c,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -3 -r1.13 -r1.14
--- linked_list.c 19 Nov 2003 04:21:15 -0000 1.13
+++ linked_list.c 19 Nov 2003 22:39:57 -0000 1.14
@@ -21,7 +21,7 @@
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-static const char cvs_ident[] = "$Id: linked_list.c,v 1.13 2003/11/19 04:21:15 mej
Exp $";
+static const char cvs_ident[] = "$Id: linked_list.c,v 1.14 2003/11/19 22:39:57 mej
Exp $";
#ifdef HAVE_CONFIG_H
# include <config.h>
@@ -29,6 +29,14 @@
#include <libast_internal.h>
+/* *INDENT-OFF* */
+SPIF_DECL_OBJ(linked_list_iterator) {
+ SPIF_DECL_PARENT_TYPE(obj);
+ spif_linked_list_t subject;
+ spif_linked_list_item_t current;
+};
+/* *INDENT-ON* */
+
static spif_linked_list_item_t spif_linked_list_item_new(void);
static spif_bool_t spif_linked_list_item_init(spif_linked_list_item_t);
static spif_bool_t spif_linked_list_item_done(spif_linked_list_item_t);
@@ -41,17 +49,22 @@
static spif_bool_t spif_linked_list_item_set_data(spif_linked_list_item_t,
spif_obj_t);
static spif_linked_list_t spif_linked_list_new(void);
+static spif_linked_list_t spif_linked_list_vector_new(void);
static spif_bool_t spif_linked_list_init(spif_linked_list_t);
+static spif_bool_t spif_linked_list_vector_init(spif_linked_list_t);
static spif_bool_t spif_linked_list_done(spif_linked_list_t);
static spif_bool_t spif_linked_list_del(spif_linked_list_t);
static spif_str_t spif_linked_list_show(spif_linked_list_t, spif_charptr_t,
spif_str_t, size_t);
static spif_cmp_t spif_linked_list_comp(spif_linked_list_t, spif_linked_list_t);
static spif_linked_list_t spif_linked_list_dup(spif_linked_list_t);
+static spif_linked_list_t spif_linked_list_vector_dup(spif_linked_list_t);
static spif_classname_t spif_linked_list_type(spif_linked_list_t);
static spif_bool_t spif_linked_list_append(spif_linked_list_t, spif_obj_t);
static spif_bool_t spif_linked_list_contains(spif_linked_list_t, spif_obj_t);
+static spif_bool_t spif_linked_list_vector_contains(spif_linked_list_t, spif_obj_t);
static size_t spif_linked_list_count(spif_linked_list_t);
static spif_obj_t spif_linked_list_find(spif_linked_list_t, spif_obj_t);
+static spif_obj_t spif_linked_list_vector_find(spif_linked_list_t, spif_obj_t);
static spif_obj_t spif_linked_list_get(spif_linked_list_t, size_t);
static size_t spif_linked_list_index(spif_linked_list_t, spif_obj_t);
static spif_bool_t spif_linked_list_insert(spif_linked_list_t, spif_obj_t);
@@ -62,6 +75,16 @@
static spif_obj_t spif_linked_list_remove_at(spif_linked_list_t, size_t);
static spif_bool_t spif_linked_list_reverse(spif_linked_list_t);
static spif_obj_t *spif_linked_list_to_array(spif_linked_list_t);
+static spif_linked_list_iterator_t spif_linked_list_iterator_new(spif_linked_list_t
subject);
+static spif_bool_t spif_linked_list_iterator_init(spif_linked_list_iterator_t self,
spif_linked_list_t subject);
+static spif_bool_t spif_linked_list_iterator_done(spif_linked_list_iterator_t self);
+static spif_bool_t spif_linked_list_iterator_del(spif_linked_list_iterator_t self);
+static spif_str_t spif_linked_list_iterator_show(spif_linked_list_iterator_t self,
spif_charptr_t name, spif_str_t buff, size_t indent);
+static spif_cmp_t spif_linked_list_iterator_comp(spif_linked_list_iterator_t self,
spif_linked_list_iterator_t other);
+static spif_linked_list_iterator_t
spif_linked_list_iterator_dup(spif_linked_list_iterator_t self);
+static spif_classname_t spif_linked_list_iterator_type(spif_linked_list_iterator_t
self);
+static spif_bool_t spif_linked_list_iterator_has_next(spif_linked_list_iterator_t
self);
+static spif_obj_t spif_linked_list_iterator_next(spif_linked_list_iterator_t self);
/* *INDENT-OFF* */
static SPIF_CONST_TYPE(class) lli_class = {
@@ -105,6 +128,45 @@
(spif_func_t) spif_linked_list_to_array
};
spif_listclass_t SPIF_LISTCLASS_VAR(linked_list) = &ll_class;
+
+static spif_const_vectorclass_t llv_class = {
+ {
+ SPIF_DECL_CLASSNAME(linked_list),
+ (spif_func_t) spif_linked_list_vector_new,
+ (spif_func_t) spif_linked_list_vector_init,
+ (spif_func_t) spif_linked_list_done,
+ (spif_func_t) spif_linked_list_del,
+ (spif_func_t) spif_linked_list_show,
+ (spif_func_t) spif_linked_list_comp,
+ (spif_func_t) spif_linked_list_vector_dup,
+ (spif_func_t) spif_linked_list_type
+ },
+ (spif_func_t) spif_linked_list_vector_contains,
+ (spif_func_t) spif_linked_list_count,
+ (spif_func_t) spif_linked_list_vector_find,
+ (spif_func_t) spif_linked_list_insert,
+ (spif_func_t) spif_linked_list_iterator,
+ (spif_func_t) spif_linked_list_remove,
+ (spif_func_t) spif_linked_list_to_array
+};
+spif_vectorclass_t SPIF_VECTORCLASS_VAR(linked_list) = &llv_class;
+
+static spif_const_iteratorclass_t li_class = {
+ {
+ SPIF_DECL_CLASSNAME(linked_list),
+ (spif_func_t) spif_linked_list_iterator_new,
+ (spif_func_t) spif_linked_list_iterator_init,
+ (spif_func_t) spif_linked_list_iterator_done,
+ (spif_func_t) spif_linked_list_iterator_del,
+ (spif_func_t) spif_linked_list_iterator_show,
+ (spif_func_t) spif_linked_list_iterator_comp,
+ (spif_func_t) spif_linked_list_iterator_dup,
+ (spif_func_t) spif_linked_list_iterator_type
+ },
+ (spif_func_t) spif_linked_list_iterator_has_next,
+ (spif_func_t) spif_linked_list_iterator_next
+};
+spif_iteratorclass_t SPIF_ITERATORCLASS_VAR(linked_list) = &li_class;
/* *INDENT-ON* */
static spif_linked_list_item_t
@@ -211,6 +273,16 @@
return self;
}
+static spif_linked_list_t
+spif_linked_list_vector_new(void)
+{
+ spif_linked_list_t self;
+
+ self = SPIF_ALLOC(linked_list);
+ spif_linked_list_vector_init(self);
+ return self;
+}
+
static spif_bool_t
spif_linked_list_init(spif_linked_list_t self)
{
@@ -222,6 +294,16 @@
}
static spif_bool_t
+spif_linked_list_vector_init(spif_linked_list_t self)
+{
+ spif_obj_init(SPIF_OBJ(self));
+ spif_obj_set_class(SPIF_OBJ(self), SPIF_CLASS(SPIF_VECTORCLASS_VAR(linked_list)));
+ self->len = 0;
+ self->head = SPIF_NULL_TYPE(linked_list_item);
+ return TRUE;
+}
+
+static spif_bool_t
spif_linked_list_done(spif_linked_list_t self)
{
spif_linked_list_item_t current;
@@ -303,6 +385,22 @@
return tmp;
}
+static spif_linked_list_t
+spif_linked_list_vector_dup(spif_linked_list_t self)
+{
+ spif_linked_list_t tmp;
+ spif_linked_list_item_t src, dest;
+
+ tmp = spif_linked_list_vector_new();
+ memcpy(tmp, self, SPIF_SIZEOF_TYPE(linked_list));
+ tmp->head = spif_linked_list_item_dup(self->head);
+ for (src = self->head, dest = tmp->head; src->next; src = src->next, dest =
dest->next) {
+ dest->next = spif_linked_list_item_dup(src->next);
+ }
+ dest->next = SPIF_NULL_TYPE(linked_list_item);
+ return tmp;
+}
+
static spif_classname_t
spif_linked_list_type(spif_linked_list_t self)
{
@@ -336,6 +434,12 @@
return ((SPIF_LIST_ISNULL(spif_linked_list_find(self, obj))) ? (FALSE) : (TRUE));
}
+static spif_bool_t
+spif_linked_list_vector_contains(spif_linked_list_t self, spif_obj_t obj)
+{
+ return ((SPIF_LIST_ISNULL(spif_linked_list_vector_find(self, obj))) ? (FALSE) :
(TRUE));
+}
+
static size_t
spif_linked_list_count(spif_linked_list_t self)
{
@@ -356,6 +460,24 @@
}
static spif_obj_t
+spif_linked_list_vector_find(spif_linked_list_t self, spif_obj_t obj)
+{
+ spif_linked_list_item_t current;
+
+ for (current = self->head; current; current = current->next) {
+ spif_cmp_t c;
+
+ c = SPIF_OBJ_COMP(current->data, obj);
+ if (SPIF_CMP_IS_EQUAL(c)) {
+ return current->data;
+ } else if (SPIF_CMP_IS_GREATER(c)) {
+ break;
+ }
+ }
+ return SPIF_NULL_TYPE(obj);
+}
+
+static spif_obj_t
spif_linked_list_get(spif_linked_list_t self, size_t idx)
{
size_t i;
@@ -425,8 +547,7 @@
static spif_iterator_t
spif_linked_list_iterator(spif_linked_list_t self)
{
- USE_VAR(self);
- return SPIF_NULL_TYPE(iterator);
+ return SPIF_CAST(iterator) spif_linked_list_iterator_new(self);
}
static spif_bool_t
@@ -526,5 +647,121 @@
for (i = 0, current = self->head; i < self->len; current = current->next, i++) {
tmp[i] = SPIF_CAST(obj) SPIF_OBJ(spif_linked_list_item_get_data(current));
}
+ return tmp;
+}
+
+static spif_linked_list_iterator_t
+spif_linked_list_iterator_new(spif_linked_list_t subject)
+{
+ spif_linked_list_iterator_t self;
+
+ self = SPIF_ALLOC(linked_list_iterator);
+ spif_linked_list_iterator_init(self, subject);
+ return self;
+}
+
+static spif_bool_t
+spif_linked_list_iterator_init(spif_linked_list_iterator_t self, spif_linked_list_t
subject)
+{
+ spif_obj_init(SPIF_OBJ(self));
+ spif_obj_set_class(SPIF_OBJ(self),
SPIF_CLASS(SPIF_ITERATORCLASS_VAR(linked_list)));
+ self->subject = subject;
+ if (SPIF_LIST_ISNULL(self->subject)) {
+ self->current = SPIF_NULL_TYPE(linked_list_item);
+ } else {
+ self->current = self->subject->head;
+ }
+ return TRUE;
+}
+
+static spif_bool_t
+spif_linked_list_iterator_done(spif_linked_list_iterator_t self)
+{
+ self->subject = SPIF_NULL_TYPE(linked_list);
+ self->current = SPIF_NULL_TYPE(linked_list_item);
+ return TRUE;
+}
+
+static spif_bool_t
+spif_linked_list_iterator_del(spif_linked_list_iterator_t self)
+{
+ spif_linked_list_iterator_done(self);
+ SPIF_DEALLOC(self);
+ return TRUE;
+}
+
+static spif_str_t
+spif_linked_list_iterator_show(spif_linked_list_iterator_t self, spif_charptr_t name,
spif_str_t buff, size_t indent)
+{
+ char tmp[4096];
+
+ if (SPIF_ITERATOR_ISNULL(self)) {
+ SPIF_OBJ_SHOW_NULL(iterator, name, buff, indent, tmp);
+ return buff;
+ }
+
+ memset(tmp, ' ', indent);
+ snprintf(tmp + indent, sizeof(tmp) - indent, "(spif_linked_list_iterator_t) %s:
%010p {\n", name, self);
+ if (SPIF_STR_ISNULL(buff)) {
+ buff = spif_str_new_from_ptr(tmp);
+ } else {
+ spif_str_append_from_ptr(buff, tmp);
+ }
+
+ buff = spif_linked_list_show(self->subject, "subject", buff, indent + 2);
+ buff = spif_linked_list_item_show(self->current, "current", buff, indent + 2);
+
+ snprintf(tmp + indent, sizeof(tmp) - indent, "}\n");
+ spif_str_append_from_ptr(buff, tmp);
+ return buff;
+}
+
+static spif_cmp_t
+spif_linked_list_iterator_comp(spif_linked_list_iterator_t self,
spif_linked_list_iterator_t other)
+{
+ return spif_linked_list_comp(self->subject, other->subject);
+}
+
+static spif_linked_list_iterator_t
+spif_linked_list_iterator_dup(spif_linked_list_iterator_t self)
+{
+ spif_linked_list_iterator_t tmp;
+
+ tmp = spif_linked_list_iterator_new(self->subject);
+ tmp->current = self->current;
+ return tmp;
+}
+
+static spif_classname_t
+spif_linked_list_iterator_type(spif_linked_list_iterator_t self)
+{
+ return SPIF_OBJ_CLASSNAME(self);
+}
+
+static spif_bool_t
+spif_linked_list_iterator_has_next(spif_linked_list_iterator_t self)
+{
+ spif_linked_list_t subject;
+
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), FALSE);
+ subject = self->subject;
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(subject), FALSE);
+ if (self->current) {
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+static spif_obj_t
+spif_linked_list_iterator_next(spif_linked_list_iterator_t self)
+{
+ spif_obj_t tmp;
+
+ ASSERT_RVAL(!SPIF_ITERATOR_ISNULL(self), SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(!SPIF_LIST_ISNULL(self->subject), SPIF_NULL_TYPE(obj));
+ REQUIRE_RVAL(!SPIF_LINKED_LIST_ITEM_ISNULL(self->current), SPIF_NULL_TYPE(obj));
+ tmp = self->current->data;
+ self->current = self->current->next;
return tmp;
}
-------------------------------------------------------
This SF.net email is sponsored by: SF.net Giveback Program.
Does SourceForge.net help you be more productive? Does it
help you create better code? SHARE THE LOVE, and help us help
YOU! Click Here: http://sourceforge.net/donate/
_______________________________________________
enlightenment-cvs mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/enlightenment-cvs
