2005-11-21 01:55:47 +00:00
|
|
|
/* $Id$ */
|
|
|
|
/*
|
|
|
|
* Copyright (C)2003-2006 Benny Prijono <benny@prijono.org>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
#ifndef __PJPP_LIST_HPP__
|
|
|
|
#define __PJPP_LIST_HPP__
|
|
|
|
|
|
|
|
#include <pj/list.h>
|
|
|
|
#include <pj++/pool.hpp>
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Linked-list.
|
|
|
|
//
|
|
|
|
// Note:
|
|
|
|
// List_Node must have public member next and prev. Normally
|
|
|
|
// it will be declared like:
|
|
|
|
//
|
|
|
|
// struct my_node
|
|
|
|
// {
|
|
|
|
// PJ_DECL_LIST_MEMBER(struct my_node);
|
|
|
|
// ..
|
|
|
|
// };
|
|
|
|
//
|
|
|
|
//
|
|
|
|
template <class List_Node>
|
|
|
|
class Pj_List : public Pj_Object
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
//
|
|
|
|
// List const_iterator.
|
|
|
|
//
|
|
|
|
class const_iterator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
const_iterator()
|
|
|
|
: node_(NULL)
|
|
|
|
{}
|
|
|
|
const_iterator(const List_Node *nd)
|
|
|
|
: node_((List_Node*)nd)
|
|
|
|
{}
|
|
|
|
const List_Node * operator *()
|
|
|
|
{
|
|
|
|
return node_;
|
|
|
|
}
|
|
|
|
const List_Node * operator -> ()
|
|
|
|
{
|
|
|
|
return node_;
|
|
|
|
}
|
|
|
|
const_iterator operator++()
|
|
|
|
{
|
|
|
|
return const_iterator(node_->next);
|
|
|
|
}
|
|
|
|
bool operator==(const const_iterator &rhs)
|
|
|
|
{
|
|
|
|
return node_ == rhs.node_;
|
|
|
|
}
|
|
|
|
bool operator!=(const const_iterator &rhs)
|
|
|
|
{
|
|
|
|
return node_ != rhs.node_;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
List_Node *node_;
|
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// List iterator.
|
|
|
|
//
|
|
|
|
class iterator : public const_iterator
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
iterator()
|
|
|
|
{}
|
|
|
|
iterator(List_Node *nd)
|
|
|
|
: const_iterator(nd)
|
|
|
|
{}
|
|
|
|
List_Node * operator *()
|
|
|
|
{
|
|
|
|
return node_;
|
|
|
|
}
|
|
|
|
List_Node * operator -> ()
|
|
|
|
{
|
|
|
|
return node_;
|
|
|
|
}
|
|
|
|
iterator operator++()
|
|
|
|
{
|
|
|
|
return iterator(node_->next);
|
|
|
|
}
|
|
|
|
bool operator==(const iterator &rhs)
|
|
|
|
{
|
|
|
|
return node_ == rhs.node_;
|
|
|
|
}
|
|
|
|
bool operator!=(const iterator &rhs)
|
|
|
|
{
|
|
|
|
return node_ != rhs.node_;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
//
|
|
|
|
// Default constructor.
|
|
|
|
//
|
|
|
|
Pj_List()
|
|
|
|
{
|
|
|
|
pj_list_init(&root_);
|
|
|
|
if (0) compiletest();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Check if list is empty.
|
|
|
|
//
|
|
|
|
bool empty() const
|
|
|
|
{
|
|
|
|
return pj_list_empty(&root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get first element.
|
|
|
|
//
|
|
|
|
iterator begin()
|
|
|
|
{
|
|
|
|
return iterator(root_.next);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get first element.
|
|
|
|
//
|
|
|
|
const_iterator begin() const
|
|
|
|
{
|
|
|
|
return const_iterator(root_.next);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get end-of-element
|
|
|
|
//
|
|
|
|
const_iterator end() const
|
|
|
|
{
|
|
|
|
return const_iterator((List_Node*)&root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get end-of-element
|
|
|
|
//
|
|
|
|
iterator end()
|
|
|
|
{
|
|
|
|
return iterator((List_Node*)&root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert node.
|
|
|
|
//
|
|
|
|
void insert_before (iterator &pos, List_Node *node)
|
|
|
|
{
|
|
|
|
pj_list_insert_before( *pos, node );
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert node.
|
|
|
|
//
|
|
|
|
void insert_after(iterator &pos, List_Node *node)
|
|
|
|
{
|
|
|
|
pj_list_insert_after(*pos, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Merge list.
|
|
|
|
//
|
|
|
|
void merge_first(List_Node *list2)
|
|
|
|
{
|
|
|
|
pj_list_merge_first(&root_, list2);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Merge list.
|
|
|
|
//
|
|
|
|
void merge_last(Pj_List *list)
|
|
|
|
{
|
|
|
|
pj_list_merge_last(&root_, &list->root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert list.
|
|
|
|
//
|
|
|
|
void insert_nodes_before(iterator &pos, Pj_List *list2)
|
|
|
|
{
|
|
|
|
pj_list_insert_nodes_before(*pos, &list2->root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert list.
|
|
|
|
//
|
|
|
|
void insert_nodes_after(iterator &pos, Pj_List *list2)
|
|
|
|
{
|
|
|
|
pj_list_insert_nodes_after(*pos, &list2->root_);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Erase an element.
|
|
|
|
//
|
|
|
|
void erase(iterator &it)
|
|
|
|
{
|
|
|
|
pj_list_erase(*it);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get first element.
|
|
|
|
//
|
|
|
|
List_Node *front()
|
|
|
|
{
|
|
|
|
return root_.next;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get first element.
|
|
|
|
//
|
|
|
|
const List_Node *front() const
|
|
|
|
{
|
|
|
|
return root_.next;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Remove first element.
|
|
|
|
//
|
|
|
|
void pop_front()
|
|
|
|
{
|
|
|
|
pj_list_erase(root_.next);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get last element.
|
|
|
|
//
|
|
|
|
List_Node *back()
|
|
|
|
{
|
|
|
|
return root_.prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get last element.
|
|
|
|
//
|
|
|
|
const List_Node *back() const
|
|
|
|
{
|
|
|
|
return root_.prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Remove last element.
|
|
|
|
//
|
|
|
|
void pop_back()
|
|
|
|
{
|
|
|
|
pj_list_erase(root_.prev);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Find a node.
|
|
|
|
//
|
|
|
|
iterator find(List_Node *node)
|
|
|
|
{
|
|
|
|
List_Node *n = pj_list_find_node(&root_, node);
|
|
|
|
return n ? iterator(n) : end();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Find a node.
|
|
|
|
//
|
|
|
|
const_iterator find(List_Node *node) const
|
|
|
|
{
|
|
|
|
List_Node *n = pj_list_find_node(&root_, node);
|
|
|
|
return n ? const_iterator(n) : end();
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert a node in the back.
|
|
|
|
//
|
|
|
|
void push_back(List_Node *node)
|
|
|
|
{
|
|
|
|
pj_list_insert_after(root_.prev, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Insert a node in the front.
|
|
|
|
//
|
|
|
|
void push_front(List_Node *node)
|
|
|
|
{
|
|
|
|
pj_list_insert_before(root_.next, node);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Remove all elements.
|
|
|
|
//
|
|
|
|
void clear()
|
|
|
|
{
|
|
|
|
root_.next = &root_;
|
|
|
|
root_.prev = &root_;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
struct RootNode
|
|
|
|
{
|
|
|
|
PJ_DECL_LIST_MEMBER(List_Node);
|
|
|
|
} root_;
|
|
|
|
|
|
|
|
void compiletest()
|
|
|
|
{
|
|
|
|
// If you see error in this line,
|
|
|
|
// it's because List_Node is not derived from Pj_List_Node.
|
|
|
|
List_Node *n = (List_Node*)0;
|
|
|
|
n = n->next; n = n->prev;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
#endif /* __PJPP_LIST_HPP__ */
|
|
|
|
|