shm_list.h

hash表和单向链表的实现代码,相当实用.

/*=================================================================
** Copyright (c)2006,
** All rights reserved.
**
** 文件名称：ipc_list.h
**
** 当前版本：1.1
** 作    者：Like
** 完成日期：2006-11-24
**
===================================================================*/

#ifndef SHM_LIST_H
#define SHM_LIST_H

#include <stdlib.h>
#include <stdio.h>
#include "shm_elem.h"

class ShmList;

/******************************************************************************
** Author：       Like
** Class Name：   ShmListIter
** Created Date:  2006-11-24
** Description:   Used to go through a ShmList
**
** Usage:         See description of ShmList below
******************************************************************************/

class ShmListIter
{
    typedef ShmListIter iterator;    
    friend class ShmList;
    
public:
    ShmListIter() 
        : _prev((ShmOListElem*) 0), _node((ShmOListElem*) 0)
    {
    }

    ShmListIter(ShmOListElem* node)
        : _prev((ShmOListElem*) 0), _node(node)
    {
    }

    ShmListIter(ShmOListElem* prev, ShmOListElem* node)
        : _prev(prev), _node(node)
    {
    }

    ShmListIter(const iterator& it)
        : _prev(it._prev), _node(it._node)
    {
    }

    ShmOListElem* operator *()
    { 
        return _node;
    }

    iterator& operator ++ ();
    
    iterator operator ++ (int)
    { 
        iterator    tmp = *this; 
        
        ++*this; 
        
        return tmp; 
    }

    bool operator == (const iterator& it) const
    { 
        return _node == it._node; 
    }
    
    bool operator != (const iterator& it) const
    { 
        ShmOListElem*  n1 = _node;
        ShmOListElem*  n2 = it._node;
        return _node != it._node; 
    }

public:
    ShmOListElem*   _prev;
    ShmOListElem*   _node;
};

/******************************************************************************
** Author：       Like
** Class Name：   ShmDList
** Created Date:  2006-11-24
** Description:   是一个基于共享内存的环状单向链表的实现。
** Note:          任何插入ShmList的节点必须存放在共享内存上，并且和ShmList
**                存放于同一个共享内存。使用ShmMgr可以实现这一目的. 
**                Please see shm_mgr.h for more details.           
**
** Usage:
**         
** Step 1: ShmMgr         shm_mgr;           创建一个共享内存管理器
**         ShmList        list;              创建一个单向链表
**         char*          shared_mem = NULL;
**         ShmOListElem*  elem = NULL;
**      
** Step 2: shm_mgr.InitShmem(key, 1024); 初始化共享内存管理器
**         
**         // 为dlist分配一定的共享内存
** Step 3: shared_mem = shm_mgr.ShmAllocWithoutLock(ShmDList::BaseSpace());
**
**         // 初始化dlist
** Step 4: list.Attach(shared_mem, shm_mgr.IsCreated());  
**
**         // So far dlist can be used
** Step 5: elem = (ShmOListElem*) shm_mgr.ShmAllocWithoutLock(64); 
**         
**         // Insert an elem into list
** Step 6: list.push_back(elem); // or dlish.push_front(elem); 
**
**         // Scan a dlist
** Step 7: ShmDList::iterator it;   
** 
** Step 8: for (it = dlist.begin(); it != dlist.end(); it++)
**         {
**             elem = *it;
**
**             do something here
**         }
******************************************************************************/

typedef struct ShmListHead
{
    int             _size;
    ShmOListElem    _listHead;
    ShmOListElem    _listTail;
    
} ShmListHead;

class ShmList
{       
public:
    typedef ShmListIter iterator; 
    
    ShmList()
    {
        _location = NULL;
        _size     = NULL;
        _listHead = NULL; 
        _listTail = NULL;       
    }
    
    ~ShmList()
    {
        // Must not delete anything.
    }

    static int BaseSpace();
    
    void Attach(char* mem_addr, int flag = 0);
    void Init();

    void push_back(ShmOListElem* node);
    void push_front(ShmOListElem* node);
    void push_back(ShmList& input_list);
    void push_front(ShmList& input_list);
    void transfer_back(ShmList& input_list);
    void transfer_front(ShmList& input_list);

    iterator erase(iterator&);
    void     clear();

    inline iterator begin()
    {            
        if (_listHead->_nextOffset == 0)
        {
            return iterator();
        }
              
        return iterator((ShmOListElem*) MAKE_SHM_PTR(_listHead->_nextOffset)); 
    }
    
    inline iterator end()
    { 
        return iterator(); 
    }

    unsigned int size() const 
    { 
        return *_size; 
    }
           
    bool empty() const 
    { 
        return (*_size == 0); 
    }

    ShmOListElem* pop_front();
    
private:
    /*************************************************************/
    // _size points to _size variable of ShmListHead
    // which has been stored in a shared memory
    //
    // _listHead points to _listHead of ShmListHead
    // which has been stored in a shared memory
    //
    // _listTail points to _listTail of ShmListHead
    // which has been stored in a shared memory
    /*************************************************************/ 
    
    char*           _location;
    int*            _size;
    ShmOListElem*   _listHead; 
    ShmOListElem*   _listTail; 
};

#endif