D-Modem/pjproject-2.11.1/pjlib/include/pj++/list.hpp

353 lines
6.2 KiB
C++
Raw Normal View History

2021-10-30 02:41:03 +08:00
/* $Id$ */
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 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((const List_Node *)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((List_Node*)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();
}
//
// You can cast Pj_List to pj_list
//
operator pj_list&()
{
return (pj_list&)root_;
}
operator const pj_list&()
{
return (const pj_list&)root_;
}
//
// You can cast Pj_List to pj_list* too
//
operator pj_list*()
{
return (pj_list*)&root_;
}
operator const pj_list*()
{
return (const pj_list*)&root_;
}
//
// 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 = (List_Node *)n->next; n = (List_Node *)n->prev;
}
};
#endif /* __PJPP_LIST_HPP__ */