mirror of
https://github.com/eclipse/paho.mqtt-sn.embedded-c.git
synced 2025-12-14 07:56:52 +01:00
Update: Add Tree23 and List template classes
Signed-off-by: tomoaki <tomoaki@tomy-tech.com>
This commit is contained in:
tomoaki
@@ -253,6 +253,729 @@ private:
|
||||
QueElement<T>* _tail;
|
||||
};
|
||||
|
||||
/*=====================================
|
||||
Class Tree23
|
||||
====================================*/
|
||||
#define TREE23_INSERT_ACTIVE (1)
|
||||
#define TREE23_DELETE_ACTIVE (2)
|
||||
#define TREE23_BI_NODE (3)
|
||||
#define TREE23_TRI_NODE (4)
|
||||
|
||||
template <typename K, typename V>
|
||||
class Tree23Elm{
|
||||
template<typename T, typename U> friend class Tree23;
|
||||
public:
|
||||
Tree23Elm()
|
||||
{
|
||||
_key = 0;
|
||||
_val = 0;
|
||||
}
|
||||
|
||||
Tree23Elm(K* key, V* val)
|
||||
{
|
||||
_key = key;
|
||||
_val = val;
|
||||
}
|
||||
|
||||
~Tree23Elm()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
int compare(Tree23Elm<K, V>* elm)
|
||||
{
|
||||
return _key->compare(elm->_key);
|
||||
}
|
||||
private:
|
||||
K* _key;
|
||||
V* _val;
|
||||
};
|
||||
|
||||
|
||||
template <typename K, typename V>
|
||||
class Tree23Node{
|
||||
template<typename S, typename W> friend class Tree23;
|
||||
public:
|
||||
Tree23Node(const int type)
|
||||
{
|
||||
_type = type;
|
||||
_telm0 = _telm1 = NULL;
|
||||
_left = _midle = _right = NULL;
|
||||
}
|
||||
|
||||
Tree23Node(const int type, Tree23Node<K, V>* midle)
|
||||
{
|
||||
_type = type;
|
||||
_telm0 = _telm1 = NULL;
|
||||
_left = _right = NULL;
|
||||
_midle = midle;
|
||||
}
|
||||
|
||||
Tree23Node(const int type, Tree23Elm<K, V>* telm)
|
||||
{
|
||||
_type = type;
|
||||
_telm0 = telm;
|
||||
_telm1 = NULL;
|
||||
_left = _midle = _right = NULL;
|
||||
}
|
||||
|
||||
Tree23Node(const int type, Tree23Elm<K, V>* telm, Tree23Node<K, V>* left, Tree23Node<K, V>* right)
|
||||
{
|
||||
_type = type;
|
||||
_telm0 = telm;
|
||||
_telm1 = NULL;
|
||||
_left = left;
|
||||
_midle = NULL;
|
||||
_right = right;
|
||||
}
|
||||
|
||||
Tree23Node(const int type, Tree23Elm<K, V>* telm0, Tree23Elm<K, V>* telm1, Tree23Node<K, V>* left, Tree23Node<K, V>* midle, Tree23Node<K, V>* right)
|
||||
{
|
||||
_type = type;
|
||||
_telm0 = telm0;
|
||||
_telm1 = telm1;
|
||||
_left = left;
|
||||
_midle = midle;
|
||||
_right = right;
|
||||
}
|
||||
|
||||
~Tree23Node()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
private:
|
||||
int _type;
|
||||
Tree23Elm<K, V>* _telm0;
|
||||
Tree23Elm<K, V>* _telm1;
|
||||
Tree23Node<K, V>* _left;
|
||||
Tree23Node<K, V>* _midle;
|
||||
Tree23Node<K, V>* _right;
|
||||
};
|
||||
|
||||
template <typename K, typename V>
|
||||
class Tree23{
|
||||
public:
|
||||
Tree23()
|
||||
{
|
||||
_root = NULL;
|
||||
}
|
||||
|
||||
~Tree23()
|
||||
{
|
||||
if ( _root )
|
||||
{
|
||||
delete _root;
|
||||
}
|
||||
}
|
||||
|
||||
void add(K* key, V* val)
|
||||
{
|
||||
_root = add( _root, new Tree23Elm<K, V>(key, val));
|
||||
_root->_type = abs(_root->_type);
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* add(Tree23Node<K, V>* n, Tree23Elm<K, V>* elm)
|
||||
{
|
||||
if ( n == 0 )
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_INSERT_ACTIVE, elm);
|
||||
}
|
||||
|
||||
int cmp0 = elm->compare(n->_telm0);
|
||||
int cmp1 = 0;
|
||||
switch ( n->_type )
|
||||
{
|
||||
case 2:
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
n->_left = add(n->_left, elm);
|
||||
return addLeft2(n);
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
n->_telm0 = elm;
|
||||
return n;
|
||||
}
|
||||
else
|
||||
{
|
||||
n->_right = add(n->_right, elm);
|
||||
return addRight2(n);
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
cmp1 = elm->compare(n->_telm1);
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
n->_left = add(n->_left, elm);
|
||||
return addLeft3(n);
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
n->_telm0 = elm;
|
||||
return n;
|
||||
}
|
||||
else if ( cmp1 < 0 )
|
||||
{
|
||||
n->_midle = add(n->_midle, elm);
|
||||
return addMidle3(n);
|
||||
}
|
||||
else if ( cmp1 == 0 )
|
||||
{
|
||||
n->_telm1 = elm;
|
||||
return n;
|
||||
}
|
||||
else
|
||||
{
|
||||
n->_right = add(n->_right, elm);
|
||||
return addRight3(n);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void remove(K* k)
|
||||
{
|
||||
_root = remove(_root, k);
|
||||
if ( _root != NULL && _root->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
_root = _root->_midle;
|
||||
}
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* remove(Tree23Node<K, V>* node, K* k)
|
||||
{
|
||||
if ( node == NULL )
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
int cmp0 = k->compare(node->_telm0->_key);
|
||||
int cmp1 = 0;
|
||||
switch ( node->_type )
|
||||
{
|
||||
case 2:
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
node->_left = remove( node->_left, k);
|
||||
return removeLeft2(node);
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
if ( node->_left == NULL)
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_DELETE_ACTIVE);
|
||||
}
|
||||
Tree23Elm<K, V>* maxLeft = new Tree23Elm<K, V>();
|
||||
node->_left = removeMax(node->_left, maxLeft);
|
||||
node->_telm0 = maxLeft;
|
||||
return removeLeft2(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
node->_right = remove(node->_right, k);
|
||||
return removeRight2(node);
|
||||
}
|
||||
case 3:
|
||||
cmp1 = k->compare(node->_telm1->_key);
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
node->_left = remove(node->_left, k);
|
||||
return removeLeft3(node);
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
if ( node->_left == NULL )
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1);
|
||||
}
|
||||
Tree23Elm<K, V>* maxLeft = new Tree23Elm<K, V>();
|
||||
node->_left = removeMax(node->_left, maxLeft);
|
||||
node->_telm0 = maxLeft;
|
||||
return removeLeft3(node);
|
||||
}
|
||||
else if ( cmp1 < 0 )
|
||||
{
|
||||
node->_midle = remove(node->_midle, k);
|
||||
return removeMidle3(node);
|
||||
}
|
||||
else if ( cmp1 == 0 )
|
||||
{
|
||||
if ( node->_midle == NULL )
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0);
|
||||
}
|
||||
Tree23Elm<K, V>* maxMidle = new Tree23Elm<K, V>();
|
||||
node->_midle = removeMax(node->_midle, maxMidle);
|
||||
node->_telm1 = maxMidle;
|
||||
return removeMidle3(node);
|
||||
}
|
||||
else
|
||||
{
|
||||
node->_right = remove(node->_right, k);
|
||||
return removeRight3(node);
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool find(K* key)
|
||||
{
|
||||
Tree23Node<K, V>* node = _root;
|
||||
while (node != NULL)
|
||||
{
|
||||
int cmp0 = key->compare(node->_telm0->_key);
|
||||
int cmp1 = 0;
|
||||
switch (node->_type)
|
||||
{
|
||||
case 2:
|
||||
if ( cmp0 < 0 ) node = node->_left;
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = node->_right;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
cmp1 = key->compare(node->_telm1->_key);
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
node = node->_left;
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if ( cmp1 < 0 )
|
||||
{
|
||||
node = node->_midle;
|
||||
}
|
||||
else if ( cmp1 == 0 )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = node->_right;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
V* getVal(K* key)
|
||||
{
|
||||
Tree23Node<K, V>* node = _root;
|
||||
while (node != NULL)
|
||||
{
|
||||
int cmp0 = key->compare(node->_telm0->_key);
|
||||
int cmp1 = 0;
|
||||
switch (node->_type)
|
||||
{
|
||||
case 2:
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
node = node->_left;
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
return node->_telm0->_val;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = node->_right;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
cmp1 = key->compare(node->_telm1->_key);
|
||||
if ( cmp0 < 0 )
|
||||
{
|
||||
node = node->_left;
|
||||
}
|
||||
else if ( cmp0 == 0 )
|
||||
{
|
||||
return node->_telm0->_val;
|
||||
}
|
||||
else if ( cmp1 < 0 )
|
||||
{
|
||||
node = node->_midle;
|
||||
}
|
||||
else if ( cmp1 == 0 )
|
||||
{
|
||||
return node->_telm1->_val;
|
||||
}
|
||||
else
|
||||
{
|
||||
node = node->_right;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
private:
|
||||
Tree23Node<K, V>* addLeft2(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_left;
|
||||
if ( n != NULL && n->_type == TREE23_INSERT_ACTIVE )
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_TRI_NODE, n->_telm0, node->_telm0, n->_left, n->_right, node->_right);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* addLeft3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_left;
|
||||
if ( n != NULL && n->_type == TREE23_INSERT_ACTIVE)
|
||||
{
|
||||
n->_type = TREE23_BI_NODE;
|
||||
Tree23Node<K, V>* nn = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1, node->_midle, node->_right);
|
||||
return new Tree23Node<K, V>(TREE23_INSERT_ACTIVE, node->_telm0, n, nn);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* addRight2(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_right;
|
||||
if (n != NULL && n->_type == TREE23_INSERT_ACTIVE)
|
||||
{
|
||||
return new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm0, n->_telm0, node->_left, n->_left, n->_right);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* addRight3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_right;
|
||||
if (n != NULL && n->_type == TREE23_INSERT_ACTIVE) {
|
||||
n->_type = TREE23_BI_NODE;
|
||||
Tree23Node<K, V>* nn = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, node->_left, node->_midle);
|
||||
return new Tree23Node<K, V>(TREE23_INSERT_ACTIVE, node->_telm1, nn, n);
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* addMidle3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_midle;
|
||||
if ( n != NULL && n->_type == TREE23_INSERT_ACTIVE )
|
||||
{
|
||||
n->_left = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, node->_left, n->_left);
|
||||
n->_right = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1, n->_right, node->_right);
|
||||
return n;
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
Tree23Node<K, V>* removeMax(Tree23Node<K, V>* node, Tree23Elm<K, V>* elm)
|
||||
{
|
||||
if (node->_right == NULL)
|
||||
{
|
||||
switch (node->_type)
|
||||
{
|
||||
case 2:
|
||||
elm->_key = node->_telm0->_key;
|
||||
elm->_val = node->_telm0->_val;
|
||||
return new Tree23Node<K, V>(TREE23_DELETE_ACTIVE);
|
||||
case 3:
|
||||
elm->_key = node->_telm1->_key;
|
||||
elm->_val = node->_telm1->_val;
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
node->_right = removeMax(node->_right, elm);
|
||||
switch (node->_type)
|
||||
{
|
||||
case 2:
|
||||
return removeRight2(node);
|
||||
case 3:
|
||||
return removeRight3(node);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
Tree23Node<K, V>* removeLeft2(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_left;
|
||||
if ( n != NULL && n->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
Tree23Node<K, V>* r = node->_right;
|
||||
Tree23Node<K, V>* midle;
|
||||
Tree23Node<K, V>* left;
|
||||
Tree23Node<K, V>* right;
|
||||
|
||||
switch ( r->_type )
|
||||
{
|
||||
case 2:
|
||||
midle = new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm0, r->_telm0, n->_midle, r->_left, r->_right);
|
||||
return new Tree23Node<K, V>(TREE23_DELETE_ACTIVE, midle);
|
||||
case 3:
|
||||
left = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, n->_midle, r->_left);
|
||||
right = new Tree23Node<K, V>(TREE23_BI_NODE, r->_telm1, r->_midle, r->_right);
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, r->_telm0, left, right);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* removeRight2(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_right;
|
||||
if ( n != NULL && n->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
Tree23Node<K, V>* l = node->_left;
|
||||
Tree23Node<K, V>* midle;
|
||||
Tree23Node<K, V>* left;
|
||||
Tree23Node<K, V>* right;
|
||||
|
||||
switch (l->_type)
|
||||
{
|
||||
case 2:
|
||||
midle = new Tree23Node<K, V>(TREE23_TRI_NODE, l->_telm0, node->_telm0, l->_left, l->_right, n->_midle);
|
||||
return new Tree23Node<K, V>(-1, midle);
|
||||
case 3:
|
||||
right = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, l->_right, n->_midle);
|
||||
left = new Tree23Node<K, V>(TREE23_BI_NODE, l->_telm0, l->_left, l->_midle);
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, l->_telm1, left, right);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* removeLeft3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_left;
|
||||
if ( n != NULL && n->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
Tree23Node<K, V>* m = node->_midle;
|
||||
Tree23Node<K, V>* r = node->_right;
|
||||
Tree23Node<K, V>* left;
|
||||
Tree23Node<K, V>* midle;
|
||||
|
||||
switch (m->_type) {
|
||||
case 2:
|
||||
left = new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm0, m->_telm0, n->_midle, m->_left, m->_right);
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1, left, r);
|
||||
case 3:
|
||||
left = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, n->_midle, m->_left);
|
||||
midle = new Tree23Node<K, V>(TREE23_BI_NODE, m->_telm1, m->_midle, m->_right);
|
||||
return new Tree23Node<K, V>(TREE23_TRI_NODE, m->_telm0, node->_telm1, left, midle, r);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* removeMidle3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_midle;
|
||||
if ( n != NULL && n->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
Tree23Node<K, V>* l = node->_left;
|
||||
Tree23Node<K, V>* r = node->_right;
|
||||
Tree23Node<K, V>* midle;
|
||||
Tree23Node<K, V>* right;
|
||||
switch (r->_type)
|
||||
{
|
||||
case 2:
|
||||
right = new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm1, r->_telm0, n->_midle, r->_left, r->_right);
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, l, right);
|
||||
case 3:
|
||||
midle = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1, n->_midle, r->_left);
|
||||
right = new Tree23Node<K, V>(TREE23_BI_NODE, r->_telm1, r->_midle, r->_right);
|
||||
return new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm0, r->_telm0, l, midle, right);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
Tree23Node<K, V>* removeRight3(Tree23Node<K, V>* node)
|
||||
{
|
||||
Tree23Node<K, V>* n = node->_right;
|
||||
if ( n != NULL && n->_type == TREE23_DELETE_ACTIVE )
|
||||
{
|
||||
Tree23Node<K, V>* l = node->_left;
|
||||
Tree23Node<K, V>* m = node->_midle;
|
||||
Tree23Node<K, V>* midle;
|
||||
Tree23Node<K, V>* right;
|
||||
switch (m->_type)
|
||||
{
|
||||
case 2:
|
||||
right = new Tree23Node<K, V>(TREE23_TRI_NODE, m->_telm0, node->_telm1, m->_left, m->_right, n->_midle);
|
||||
return new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm0, l, right);
|
||||
case 3:
|
||||
right = new Tree23Node<K, V>(TREE23_BI_NODE, node->_telm1, m->_right, n->_midle);
|
||||
midle = new Tree23Node<K, V>(TREE23_BI_NODE, m->_telm0, m->_left, m->_midle);
|
||||
return new Tree23Node<K, V>(TREE23_TRI_NODE, node->_telm0, m->_telm1, l, midle, right);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
Tree23Node<K, V>* _root;
|
||||
};
|
||||
|
||||
/*=====================================
|
||||
Class List
|
||||
=====================================*/
|
||||
template <typename T>
|
||||
class ListElm
|
||||
{
|
||||
template<typename U> friend class List;
|
||||
public:
|
||||
ListElm()
|
||||
{
|
||||
_elm = 0;
|
||||
_prev = _next = 0;
|
||||
}
|
||||
ListElm(T* elm)
|
||||
{
|
||||
_elm = elm;
|
||||
_prev = _next = 0;
|
||||
}
|
||||
T* getContent(void)
|
||||
{
|
||||
return _elm;
|
||||
}
|
||||
~ListElm(){}
|
||||
|
||||
private:
|
||||
ListElm<T>* getNext(void){return _next;}
|
||||
T* _elm;
|
||||
ListElm<T>* _prev;
|
||||
ListElm<T>* _next;
|
||||
};
|
||||
|
||||
|
||||
template <typename T>
|
||||
class List{
|
||||
public:
|
||||
List()
|
||||
{
|
||||
_head = _tail = 0;
|
||||
_size = 0;
|
||||
}
|
||||
~List()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
int add(T* t)
|
||||
{
|
||||
ListElm<T>* elm = new ListElm<T>(t);
|
||||
if ( elm == 0 )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if ( _head == 0 )
|
||||
{
|
||||
_head = elm;
|
||||
_tail = elm;
|
||||
}
|
||||
else
|
||||
{
|
||||
elm->_prev = _tail;
|
||||
_tail->_next = elm;
|
||||
_tail = elm;
|
||||
}
|
||||
_size++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void erase(ListElm<T>* elm)
|
||||
{
|
||||
if ( _head == elm )
|
||||
{
|
||||
_head = elm->_next;
|
||||
_size--;
|
||||
delete elm;
|
||||
}
|
||||
else if ( _tail == elm )
|
||||
{
|
||||
_tail = elm->_prev;
|
||||
elm->_prev->_next = 0;
|
||||
_size--;
|
||||
delete elm;
|
||||
}
|
||||
else
|
||||
{
|
||||
elm->_prev->_next = elm->_next;
|
||||
elm->_next->_prev = elm->_prev;
|
||||
_size--;
|
||||
delete elm;
|
||||
}
|
||||
}
|
||||
void clear(void)
|
||||
{
|
||||
ListElm<T>* p = _head;
|
||||
while ( p )
|
||||
{
|
||||
ListElm<T>* q = p->_next;
|
||||
delete p;
|
||||
p = q;
|
||||
}
|
||||
_head = 0;
|
||||
_tail = 0;
|
||||
_size = 0;
|
||||
}
|
||||
|
||||
ListElm<T>* getElm(void)
|
||||
{
|
||||
return _head;
|
||||
}
|
||||
|
||||
ListElm<T>* getNext(ListElm<T>* elm)
|
||||
{
|
||||
return elm->getNext();
|
||||
}
|
||||
|
||||
int getSize(void)
|
||||
{
|
||||
return _size;
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
ListElm<T>* _head;
|
||||
ListElm<T>* _tail;
|
||||
int _size;
|
||||
};
|
||||
|
||||
|
||||
extern Process* theProcess;
|
||||
extern MultiTaskProcess* theMultiTaskProcess;
|
||||
|
||||
Reference in New Issue
Block a user