sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/IntHash.h

@@ -0,0 +1,314 @@
+/*
+ * File:  IntHash.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _INTHASH_H
+#define _INTHASH_H
+
+#include "common/sedna.h"
+
+// T - value type
+// 32-bit integer is hashed by the following template:
+// 000000...001111................11110000.........0000
+// \_________/\______________________/\_______________/
+//             middle_significan_bits  right_zero_bits
+template <class T, int middle_significan_bits, int right_zero_bits>
+class IntHash
+{
+private:
+
+    struct add_cell
+    {
+        int key;
+        T val;
+        add_cell *next;
+    };
+
+    struct cell 
+    {
+        int key;
+        T val;
+        add_cell *next;
+        bool is_present;
+    };
+
+    int templ;
+
+    cell tbl[1 << middle_significan_bits];
+
+public:
+
+    IntHash();
+    ~IntHash();
+
+    // functions return 0 if all OK    
+
+    int  insert(int key, T val);
+    int  find(int key, T &val);
+    int  remove(int key);
+    int  find_remove(int key, T &val);
+    int  replace(int key, T &new_val, T &old_val);
+    void clear();
+};
+
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+IntHash<T, middle_significan_bits, right_zero_bits>::IntHash() 
+{
+    int k = 32 - middle_significan_bits - right_zero_bits;
+    templ = 0xFFFFFFFF << k >> k >> right_zero_bits << right_zero_bits;
+
+    for (int i = 0; i < (1 << middle_significan_bits); i++)
+    {
+        tbl[i].next = NULL;
+        tbl[i].key = 0;
+        tbl[i].is_present = false;
+    }
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+IntHash<T, middle_significan_bits, right_zero_bits>::~IntHash() 
+{
+    for (int i = 0; i < (1 << middle_significan_bits); i++)
+    {
+        add_cell * p = tbl[i].next;
+
+        for (; p != NULL; )
+        {
+            add_cell * tmp = p;
+            p = p->next;
+            delete tmp;
+        }
+
+        tbl[i].next = NULL;
+    }
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+int IntHash<T, middle_significan_bits, right_zero_bits>::insert(int key, T val)
+{
+    cell &start = tbl[(key & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        add_cell * new_cell = se_new add_cell;
+        new_cell->key = key;
+        new_cell->val = val;
+        new_cell->next = start.next;
+        start.next = new_cell;
+    }
+    else 
+    {
+        start.key = key;
+        start.val = val;
+        start.next = NULL;
+        start.is_present = true;
+    }
+
+    return 0;
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+int IntHash<T, middle_significan_bits, right_zero_bits>::find(int key, T &val)
+{
+    cell &start = tbl[(key & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            val = start.val;
+            return 0;
+        }
+
+        add_cell * p = start.next;
+        for (; p != NULL; p = p->next)
+        {
+            if (p->key == key)
+            {
+                val = p->val;
+                return 0;
+            }
+        }
+        return 1;
+    }
+    else return 1;
+
+    return 0;
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+int IntHash<T, middle_significan_bits, right_zero_bits>::remove(int key)
+{
+    cell &start = tbl[(key & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            if (start.next == NULL)
+            {
+                start.key = 0;
+                start.is_present = false;
+            }
+            else
+            {
+                start.key = start.next->key;
+                start.val = start.next->val;
+                add_cell *p = start.next;
+                start.next = start.next->next;
+                delete p;
+                start.is_present = true;
+            }
+            return 0;
+        }
+        else
+        {
+            if (start.next == NULL) return 1;
+
+            if (start.next->key == key)
+            {
+                add_cell * p = start.next;
+                start.next = start.next->next;
+                delete p;
+                return 0;
+            }
+
+            add_cell * pred = start.next;
+            add_cell * cur = start.next->next;
+
+            for (; cur != NULL; cur = cur->next, pred = pred->next)
+            {
+                if (cur->key == key)
+                {
+                    pred->next = cur->next;
+                    delete cur;
+                    return 0;
+                }
+            }
+            return 1;
+            
+        }
+    }
+    else return 1;
+
+    return 0;
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+int IntHash<T, middle_significan_bits, right_zero_bits>::find_remove(int key, T &val)
+{
+    cell &start = tbl[(key & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            if (start.next == NULL)
+            {
+                val = start.val;
+                start.key = 0;
+                start.is_present = false;
+            }
+            else
+            {
+                val = start.val;
+                start.key = start.next->key;
+                start.val = start.next->val;
+                add_cell *p = start.next;
+                start.next = start.next->next;
+                delete p;
+                start.is_present = true;
+            }
+            return 0;
+        }
+        else
+        {
+            if (start.next == NULL) return 1;
+
+            if (start.next->key == key)
+            {
+                val = start.next->val;
+                add_cell * p = start.next;
+                start.next = start.next->next;
+                delete p;
+                return 0;
+            }
+
+            add_cell * pred = start.next;
+            add_cell * cur = start.next->next;
+
+            for (; cur != NULL; cur = cur->next, pred = pred->next)
+            {
+                if (cur->key == key)
+                {
+                    val = cur->val;
+                    pred->next = cur->next;
+                    delete cur;
+                    return 0;
+                }
+            }
+            return 1;
+        }
+    }
+    else return 1;
+
+    return 0;
+}
+
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+int IntHash<T, middle_significan_bits, right_zero_bits>::replace(int key, T &new_val, T &old_val)
+{
+    cell &start = tbl[(key & templ) >> right_zero_bits];
+    if (start.is_present)
+    {
+        if (start.key == key)
+        {
+            old_val = start.val;
+            start.val = new_val;
+            return 0;
+        }
+
+        add_cell * p = start.next;
+        for (; p != NULL; p = p->next)
+        {
+            if (p->key == key)
+            {
+                old_val = p->val;
+                p->val = new_val;
+                return 0;
+            }
+        }
+        return 1;
+    }
+    else return 1;
+
+    return 0;
+}
+
+template <class T, int middle_significan_bits, int right_zero_bits>
+void IntHash<T, middle_significan_bits, right_zero_bits>::clear()
+{
+    for (int i = 0; i < (1 << middle_significan_bits); i++)
+    {
+        add_cell *cur = tbl[i].next, *tmp = NULL;
+        while (cur)
+        {
+            tmp = cur;
+            cur = cur->next;
+            delete tmp;
+        }
+
+        tbl[i].next = NULL;
+        tbl[i].key = 0;
+        tbl[i].is_present = false;
+    }
+}
+
+#endif
+

data/vendor/sedna/kernel/common/IntList.h

@@ -0,0 +1,224 @@
+/*
+ * File:  IntList.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _INTLIST_H
+#define _INTLIST_H
+
+#include "common/sedna.h"
+#include "common/IntHash.h"
+
+
+// middle_significan_bits, right_zero_bits - parameters of HashTable
+template <int middle_significan_bits, int right_zero_bits>
+class IntList
+{
+private:
+
+    struct elem
+    {
+        int val;
+        elem *next;
+        elem *pred;
+    };
+
+    elem * start;
+    elem * last;
+    int num;
+
+    IntHash<elem*, middle_significan_bits, right_zero_bits> tbl;
+
+
+
+    class ilit
+    {
+    private:
+        elem *p;
+
+        ilit(elem *_p_) : p(_p_) {}
+
+    public:
+        static ilit begin(IntList *_lst_) { return ilit(_lst_->start); }
+        static ilit end(IntList *_lst_)   { return ilit(NULL); }
+
+        ilit() : p(NULL) {}
+        ilit(const ilit& x) : p(x.p) {}
+        ilit& operator=(const ilit &x) { p = x.p; return *this; }
+
+        bool operator==(const ilit &x) { return p == x.p; }
+        bool operator!=(const ilit &x) { return !operator==(x); }
+    
+        ilit &operator++() { if (p) p = p->next; return *this; }
+        const int &operator*() { return p->val; }
+    };
+
+
+public:
+
+    friend class ilit;
+    typedef ilit iterator;
+
+    IntList();
+    ~IntList();
+
+    int size() { return num; }
+
+    // functions return 0 if all OK
+
+    int  push       (int  /*in*/  val);
+    int  pop        (int& /*out*/ val);
+    int  find       (int  /*in*/  val);
+    int  find_remove(int  /*in*/  val);
+    void clear      ();
+
+    iterator begin() { return ilit::begin(this); }
+    iterator end() { return ilit::end(this); }
+};
+
+
+
+template <int middle_significan_bits, int right_zero_bits>
+IntList<middle_significan_bits, right_zero_bits>::IntList() 
+{
+    num = 0;
+    start = NULL;
+    last = NULL;
+}
+
+
+template <int middle_significan_bits, int right_zero_bits>
+IntList<middle_significan_bits, right_zero_bits>::~IntList() 
+{
+    elem * p = start;
+    for (; p != NULL; )
+    {
+        elem * tmp = p;
+        p = p->next;
+        delete tmp;
+    }
+
+    start = NULL;
+    last = NULL;
+    num = 0;
+}
+
+
+template <int middle_significan_bits, int right_zero_bits>
+int IntList<middle_significan_bits, right_zero_bits>::push(int /*in*/ val)
+{
+    elem * tmp = se_new elem;
+    tmp->val = val;
+    tmp->pred = NULL;
+    num++;
+    tbl.insert(val, tmp);
+
+    if (start == NULL)
+    {
+        tmp->next = NULL;
+        start = last = tmp;
+    }
+    else
+    {
+        tmp->next = start;
+        start->pred = tmp;
+        start = tmp;
+    }
+
+    return 0;
+}
+
+
+template <int middle_significan_bits, int right_zero_bits>
+int IntList<middle_significan_bits, right_zero_bits>::pop(int& /*out*/ val)
+{
+    if (last == NULL) return 1;
+
+    val = last->val;
+    num--;
+    tbl.remove(val);
+
+    if (start == last) 
+    {
+        delete last;
+        start = last = NULL;
+    }
+    else
+    {
+        last = last->pred;
+        delete (last->next);
+        last->next = NULL;
+    }
+
+    return 0;
+}
+
+
+template <int middle_significan_bits, int right_zero_bits>
+int IntList<middle_significan_bits, right_zero_bits>::find(int /*in*/ val)
+{
+    elem * tmp = NULL;
+
+    return tbl.find(val, tmp);
+}
+
+
+template <int middle_significan_bits, int right_zero_bits>
+int IntList<middle_significan_bits, right_zero_bits>::find_remove(int /*in*/ val)
+{
+    elem * tmp = NULL;
+
+    if (tbl.find_remove(val, tmp) == 0)
+    {
+        num--;
+
+        if (tmp->next == NULL && tmp->pred == NULL) // the only elem in the list
+        {
+            start = last = NULL;
+        } 
+        else if (tmp->next == NULL) // the last elem in the list
+        {
+            last = tmp->pred;
+            last->next = NULL;
+        } 
+        else if (tmp->pred == NULL) // the first elem in the list
+        {
+            start = tmp->next;
+            start->pred = NULL;
+        }
+        else
+        {
+            tmp->pred->next = tmp->next;
+            tmp->next->pred = tmp->pred;
+        }
+        
+        delete tmp;
+        return 0;
+    }
+
+    return 1;
+}
+
+template <int middle_significan_bits, int right_zero_bits>
+void IntList<middle_significan_bits, right_zero_bits>::clear()
+{
+    elem *cur = start, *tmp = NULL;
+    while (tmp)
+    {
+        tmp = cur;
+        cur = cur->next;
+        delete tmp;
+    }
+
+    tbl.clear();
+
+    num = 0;
+    start = NULL;
+    last = NULL;
+}
+
+
+
+#endif
+