sh_list.h

rsa算法打的一个包

// SH_List.h: interface for the SH_List class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SH_LIST_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)
#define AFX_SH_LIST_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "SH_Object.h"


////////////////////////////////////////////////////////////////
//SH_List
template<class ARG> 
class AFX_EXT_CLASS SH_List : public SH_Object  
{
protected:
    typedef struct _SH_ListNode
    {
    public:
        struct _SH_ListNode * prev;
        struct _SH_ListNode * next;
        ARG               data;
    }SH_ListNode;
public: 
	SH_List();
	virtual ~SH_List();

    virtual VOID Destroy(ARG data) {};

    //Function decl
    VOID        AddHead(ARG val);
    VOID        AddTail(ARG val);

    BOOL        GetHead(ARG & val);
    BOOL        GetTail(ARG & val);

    SH_Position GetHeadPosition(VOID);
    SH_Position GetTailPosition(VOID);

    ARG &       GetPrev(SH_Position & pos);
    ARG &       GetNext(SH_Position & pos);
    
    BOOL        RemoveAt(SH_Position & pos);
    int         GetCount() const;

    ARG         RemoveHead();
    ARG         RemoveTail();
    VOID        RemoveAll(VOID);

    BOOL        IsEmpty(VOID);
private:
    int           m_nCount;
    SH_ListNode * m_pHead;
    SH_ListNode * m_pTail;
};
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
template<class ARG>
SH_List<ARG>::SH_List()
{
    m_pHead  = NULL;
    m_pTail  = NULL;
    m_nCount = 0;
}

template<class ARG>
SH_List<ARG>::~SH_List()
{
    RemoveAll();

    m_pHead  = NULL;
    m_pTail  = NULL;
    m_nCount = 0;
}

template<class ARG>
VOID  SH_List<ARG>::AddHead(ARG val)
{
    SH_ListNode * pNode = new SH_ListNode;
    
    ASSERT( pNode != NULL);
    pNode->data = val;

    if(m_pHead == NULL)
    {
        pNode->next = NULL;
        pNode->prev = NULL;
        m_pHead     = pNode;
        m_pTail     = pNode;
    }
    else
    {
        pNode->prev = NULL;
        pNode->next = m_pHead;
        m_pHead     = pNode;
    }
    m_nCount++;
}

template<class ARG>
VOID  SH_List<ARG>::AddTail(ARG val)
{
    SH_ListNode * pNode = new SH_ListNode;
    
    ASSERT( pNode != NULL);
    pNode->data = val;

    if(m_pHead == NULL)
    {
        pNode->next = NULL;
        pNode->prev = NULL;
        m_pHead     = pNode;
        m_pTail     = pNode;
    }
    else
    {
        pNode->prev = NULL;
        pNode->next = m_pHead;
        m_pHead     = pNode;
    }
    m_nCount++;
}

template<class ARG>
BOOL  SH_List<ARG>::GetHead(ARG & val)
{
    if(m_pHead == NULL)
        return FALSE;

    val = m_pHead->data;
    return TRUE;
}

template<class ARG>
BOOL  SH_List<ARG>::GetTail(ARG & val)
{
    if(m_pTail == NULL)
        return FALSE;

    val = m_pTail->data;
    return TRUE;
}

template<class ARG>
SH_Position SH_List<ARG>::GetHeadPosition(VOID)
{
    if(m_pHead == NULL)
        return (SH_Position)NULL;

    return (SH_Position)m_pHead;
}

template<class ARG>
SH_Position SH_List<ARG>::GetTailPosition(VOID)
{
    if(m_pTail == NULL)
        return (SH_Position)NULL;

    return (SH_Position)m_pTail;
}

template<class ARG>
ARG & SH_List<ARG>::GetPrev(SH_Position & pos)
{
    SH_ListNode * pNode;
    ASSERT(pos != NULL);
    
    pNode = (SH_ListNode*)pos;

    pos = (SH_Position)pNode->prev;

    return (ARG&)pNode->data;
}

template<class ARG>
ARG & SH_List<ARG>::GetNext(SH_Position & pos)
{
    SH_ListNode * pNode;
    ASSERT(pos != NULL);
    
    pNode = (SH_ListNode*)pos;

    pos = (SH_Position)pNode->next;

    return (ARG&)pNode->data;
}

template<class ARG>
BOOL  SH_List<ARG>::RemoveAt(SH_Position & pos)
{
    SH_ListNode * tmp;
    SH_ListNode * pNode = (SH_ListNode*)pos;

    if(pNode == NULL)
        return FALSE;

    tmp = pNode;
    if(pNode->prev == NULL)
    {
        m_pHead       = pNode->next;
        if(m_pHead)
            m_pHead->prev = NULL;
    }
    else
        pNode->prev->next = pNode->next;

    if(pNode->next == NULL)
    {
        m_pTail = pNode->prev;
        if(m_pTail)
            m_pTail->next = NULL;
    }
    else
        pNode->next->prev = pNode->prev;

    Destroy(tmp->data);
    SAFE_DELETE(tmp);

    m_nCount--;

    return TRUE;
}

template<class ARG>
ARG SH_List<ARG>::RemoveHead()
{
    ARG val = 0;
    SH_ListNode * tmp;

    if(!m_pHead)
        return NULL;

    val = m_pHead->data;
    tmp = m_pHead;

    m_pHead       = m_pHead->next;
    
    if(m_pHead)
        m_pHead->prev = NULL;
    else
        m_pTail = NULL;

    SAFE_DELETE(tmp);

    m_nCount--;

    return val;

}

template<class ARG>
ARG SH_List<ARG>::RemoveTail()
{
    ARG val = 0;
    SH_ListNode * tmp;

    if(!m_pTail)
        return NULL;

    val = m_pTail->data;
    tmp = m_pTail;
    m_pTail = m_pTail->prev;

    if(m_pTail)
        m_pTail->next = NULL;
    else
        m_pHead = NULL;

    SAFE_DELETE(tmp);

    m_nCount--;

    return val;
}

template<class ARG>
VOID        SH_List<ARG>::RemoveAll(VOID)
{
    SH_ListNode * pNode;
    SH_ListNode * tmp;
    
    for(pNode = m_pHead; pNode != NULL;)
    {
        tmp = pNode;

        pNode = pNode->next;

        Destroy(tmp->data);
        SAFE_DELETE(tmp);
    }
    m_nCount = 0;

    m_pHead = NULL;
    m_pTail = NULL;
}

template<class ARG>
AFX_INLINE BOOL SH_List<ARG>::IsEmpty(VOID)
{
    return (m_nCount == 0);
}

template<class ARG>
AFX_INLINE int SH_List<ARG>::GetCount()  const
{
    return m_nCount;
}

#endif // !defined(AFX_SH_LIST_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)