summaryrefslogtreecommitdiffstats
path: root/ksysguard/CContLib/ccont.c
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit4aed2c8219774f5d797760606b8489a92ddc5163 (patch)
tree3f8c130f7d269626bf6a9447407ef6c35954426a /ksysguard/CContLib/ccont.c
downloadtdebase-4aed2c8219774f5d797760606b8489a92ddc5163.tar.gz
tdebase-4aed2c8219774f5d797760606b8489a92ddc5163.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'ksysguard/CContLib/ccont.c')
-rw-r--r--ksysguard/CContLib/ccont.c364
1 files changed, 364 insertions, 0 deletions
diff --git a/ksysguard/CContLib/ccont.c b/ksysguard/CContLib/ccont.c
new file mode 100644
index 000000000..501429337
--- /dev/null
+++ b/ksysguard/CContLib/ccont.c
@@ -0,0 +1,364 @@
+/*
+ Lightweight C Container Library
+
+ Copyright (c) 2002 Tobias Koenig <tokoe@kde.org>
+
+ Original code was written by Chris Schlaeger <cs@kde.org>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+
+*/
+
+#include "ccont.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct container_info {
+ INDEX count;
+ CONTAINER currentNode;
+};
+
+typedef struct container_info T_CONTAINER_INFO;
+typedef struct container_info* CONTAINER_INFO;
+
+#define rpterr(x) fprintf(stderr, "%s\n", x)
+
+CONTAINER new_ctnr(void)
+{
+ CONTAINER_INFO info;
+ CONTAINER rootNode;
+
+ rootNode = (CONTAINER)malloc(sizeof(T_CONTAINER));
+
+ info = (CONTAINER_INFO)malloc(sizeof(T_CONTAINER_INFO));
+ info->count = 0;
+ info->currentNode = rootNode;
+
+ rootNode->next = rootNode;
+ rootNode->prev = rootNode;
+ rootNode->data = info;
+
+ return rootNode;
+}
+
+void zero_destr_ctnr(CONTAINER rootNode, DESTR_FUNC destr_func)
+{
+ INDEX counter;
+
+ if (rootNode == NIL || destr_func == NIL) {
+ rpterr("destr_ctnr: NIL argument");
+ return;
+ }
+
+ for (counter = level_ctnr(rootNode); counter > -1; --counter)
+ destr_func(pop_ctnr(rootNode));
+
+ if (rootNode->data)
+ free(rootNode->data);
+
+ free(rootNode);
+ rootNode = 0;
+
+ return;
+}
+
+INDEX level_ctnr(CONTAINER rootNode)
+{
+ if (rootNode == NIL) {
+ rpterr("level_ctnr: NIL argument");
+ return -1;
+ }
+
+ return ((CONTAINER_INFO)rootNode->data)->count;
+}
+
+void insert_ctnr(CONTAINER rootNode, void* object, INDEX pos)
+{
+ CONTAINER it;
+ INDEX counter = 0;
+
+ if (rootNode == NIL || object == NIL) {
+ rpterr("insert_ctnr: NIL argument");
+ return;
+ }
+
+ for (it = rootNode->next; it != rootNode; it = it->next) {
+ if (counter == pos) {
+ CONTAINER newNode = (CONTAINER)malloc(sizeof(T_CONTAINER));
+
+ newNode->prev = it;
+ newNode->next = it->next;
+ it->next->prev = newNode;
+ it->next = newNode;
+
+ newNode->data = object;
+ ((CONTAINER_INFO)rootNode->data)->count++;
+ return;
+ }
+
+ counter++;
+ }
+}
+
+void push_ctnr(CONTAINER rootNode, void* object)
+{
+ CONTAINER newNode;
+
+ if (rootNode == NIL || object == NIL) {
+ rpterr("push_ctnr: NIL argument");
+ return;
+ }
+
+ newNode = (CONTAINER)malloc(sizeof(T_CONTAINER));
+ newNode->next = rootNode;
+ newNode->prev = rootNode->prev;
+ rootNode->prev->next = newNode;
+ rootNode->prev = newNode;
+
+ newNode->data = object;
+ ((CONTAINER_INFO)rootNode->data)->count++;
+}
+
+void* remove_at_ctnr(CONTAINER rootNode, INDEX pos)
+{
+ CONTAINER it;
+ INDEX counter = 0;
+ void* retval;
+
+ if (rootNode == NIL) {
+ rpterr("remove_ctnr: NIL argument");
+ return NIL;
+ }
+
+ for (it = rootNode->next; it != rootNode; it = it->next) {
+ if (counter == pos) {
+ retval = it->data;
+
+ it->prev->next = it->next;
+ it->next->prev = it->prev;
+
+ free(it);
+
+ ((CONTAINER_INFO)rootNode->data)->count--;
+ return retval;
+ }
+
+ counter++;
+ }
+
+ return NIL;
+}
+
+void* pop_ctnr(CONTAINER rootNode)
+{
+ CONTAINER ptr;
+ void* retval;
+
+ if (rootNode == NIL) {
+ rpterr("pop_ctnr: NIL argument");
+ return NIL;
+ }
+
+ if (rootNode->next == rootNode)
+ return NIL;
+
+ ptr = rootNode->next;
+ retval = ptr->data;
+
+ rootNode->next = ptr->next;
+ ptr->next->prev = rootNode;
+
+ ((CONTAINER_INFO)rootNode->data)->count--;
+
+ free(ptr);
+
+ return retval;
+}
+
+void* get_ctnr(CONTAINER rootNode, INDEX pos)
+{
+ CONTAINER it;
+ INDEX counter = 0;
+
+ if (rootNode == NIL) {
+ rpterr("get_ctnr: NIL argument");
+ return NIL;
+ }
+
+ for (it = rootNode->next; it != rootNode; it = it->next) {
+ if (counter == pos)
+ return it->data;
+
+ counter++;
+ }
+
+ return NIL;
+}
+
+INDEX search_ctnr(CONTAINER rootNode, COMPARE_FUNC compare_func, void* pattern)
+{
+ CONTAINER it;
+ INDEX counter = 0;
+
+ if (rootNode == NIL || compare_func == NIL || pattern == NIL) {
+ rpterr("search_ctnr: NIL argument");
+ return -1;
+ }
+
+ for (it = rootNode->next; it != rootNode; it = it->next) {
+ if (compare_func(pattern, it->data) == 0)
+ return counter;
+
+ counter++;
+ }
+
+ return -1;
+}
+
+void swop_ctnr(CONTAINER rootNode, INDEX pos1, INDEX pos2)
+{
+ CONTAINER it, node1, node2;
+ INDEX counter = 0;
+ int found = 0;
+ void* tmpData;
+
+ if (rootNode == NIL) {
+ rpterr("swop_ctnr: NIL argument");
+ return;
+ }
+
+ if (pos1 == pos2)
+ return;
+
+ /**
+ * it is a bit hackish because of the 'goto' but it's fast
+ * since we have to run through the list only once
+ */
+ for (it = rootNode->next; it != rootNode; it = it->next) {
+ if (counter == pos1) {
+ node1 = it;
+ if (found)
+ goto swapIt;
+ else
+ found = 1;
+ }
+ if (counter == pos2) {
+ node2 = it;
+ if (found)
+ goto swapIt;
+ else
+ found = 1;
+ }
+
+ counter++;
+ }
+
+ return;
+
+swapIt:
+ tmpData = node1->data;
+ node1->data = node2->data;
+ node2->data = tmpData;
+ return;
+}
+
+void bsort_ctnr(CONTAINER rootNode, COMPARE_FUNC compare_func)
+{
+ INDEX right, i, level, last;
+
+ if (rootNode == NIL || compare_func == NIL) {
+ rpterr("destr_ctnr: NIL argument");
+ return;
+ }
+
+ last = level = level_ctnr(rootNode);
+ do
+ {
+ right = last;
+ last = 0;
+ for (i = 1; i < right; i++)
+ if (compare_func(get_ctnr(rootNode, i - 1), get_ctnr(rootNode, i)) > 0)
+ swop_ctnr(rootNode, i - 1, last = i);
+ } while (last > 0);
+}
+
+void* first_ctnr(CONTAINER rootNode)
+{
+ if (rootNode == NIL) {
+ rpterr("first_ctnr: NIL argument");
+ return NIL;
+ }
+
+ if (rootNode->next == rootNode)
+ return NIL;
+
+ ((CONTAINER_INFO)rootNode->data)->currentNode = rootNode->next;
+
+ return rootNode->next->data;
+}
+
+void* next_ctnr(CONTAINER rootNode)
+{
+ CONTAINER_INFO info;
+
+ if (rootNode == NIL) {
+ rpterr("next_ctnr: NIL argument");
+ return NIL;
+ }
+
+ info = (CONTAINER_INFO)rootNode->data;
+
+ if (info->currentNode->next == rootNode)
+ return NIL;
+
+ info->currentNode = info->currentNode->next;
+
+ return info->currentNode->data;
+}
+
+void* remove_ctnr(CONTAINER rootNode)
+{
+ CONTAINER currentNode, tmp;
+ CONTAINER_INFO info;
+ void* retval;
+
+ if (rootNode == NIL) {
+ rpterr("remove_curr_ctnr: NIL argument");
+ return NIL;
+ }
+
+ info = (CONTAINER_INFO)rootNode->data;
+ currentNode = info->currentNode;
+
+ if (currentNode == rootNode) { /* should never happen */
+ rpterr("remove_curr_ctnr: delete root node");
+ return NIL;
+ }
+
+ retval = currentNode->data;
+ tmp = currentNode->prev;
+
+ currentNode->prev->next = currentNode->next;
+ currentNode->next->prev = currentNode->prev;
+
+ free(currentNode);
+
+ info->count--;
+ info->currentNode = tmp;
+
+ return retval;
+}