开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
QList.c
资源名称：ST_5105DTV.rar　[点击查看]
上传用户：fy98168
上传日期：2015-06-26
资源大小：13771k
文件大小：7k
源码类别：

DVD

开发平台：

C/C++

QList.c：源码内容
  1. #include <assert.h>
  2. #include "QList.h"
  3. #include <stdlib.h>
  4. #include "osp.h"
  6. QList NewQList()
  7. {
  8.    QList self;
  9.    self.Clear = QListClear;
  10.    self.Add = QListAdd;
  11.    self.Insert = QListInsert;
  12.    self.GetData = QListGetData;
  13.    self.MoveToHead = QListMoveToHead;
  14.    self.MoveToTail = QListMoveToTail;
  15.    self.MoveNext = QListMoveNext;
  16.    self.MovePrev = QListMovePrev;
  17.    self.IsEmpty = QListIsEmpty;
  18.    self.GetSize = QListGetSize;
  19.    self.PlaceAtHead = QListPlaceAtHead;
  20.    self.Remove = QListRemove;
  21.    
  22.    self.m_pHead = NULL;
  23.    self.m_pTail = NULL;
  24.    self.m_pCurrent = NULL;
  25.    self.m_nSize = 0;
  26.    return self;
  27. }
  29. QList *MallocQList()
  30. {
  31.    QList *self = (QList *)KB_OSPMalloc(sizeof(QList));
  32.    if(!self) return NULL;
  34.    self->Clear = QListClear;
  35.    self->Add = QListAdd;
  36.    self->Insert = QListInsert;
  37.    self->GetData = QListGetData;
  38.    self->MoveToHead = QListMoveToHead;
  39.    self->MoveToTail = QListMoveToTail;
  40.    self->MoveNext = QListMoveNext;
  41.    self->MovePrev = QListMovePrev;
  42.    self->IsEmpty = QListIsEmpty;
  43.    self->GetSize = QListGetSize;
  44.    self->PlaceAtHead = QListPlaceAtHead;
  45.    self->Remove = QListRemove;
  47.    self->m_pHead = NULL;
  48.    self->m_pTail = NULL;
  49.    self->m_pCurrent = NULL;
  50.    self->m_nSize = 0;
  51.    return self;
  52. }
  55. void QListClear(QList *self)
  56. {
  57.    List *pTemp;
  58.    List *p;
  59.    assert(self);
  60.    if (self->m_pHead == NULL)
  61.        return;
  62.    p = self->m_pTail;
  63.    while (p)
  64.    {
  65.       pTemp = p->pPrev;      
  66.       KB_OSPFree(p);
  67.       p = NULL;
  68.       p = pTemp;
  69.    }
  70.    self->m_pHead = self->m_pTail = self->m_pCurrent = NULL;
  71. }
  73. int QListAdd(QList *self,void* pData)
  74. {
  75.    List *p;
  76.    
  77.    assert(self);
  78.    if (self->m_pHead == NULL)
  79.       return self->PlaceAtHead(self,pData);
  81.    p = self->m_pTail;
  82.    p->pNext = (List*)KB_OSPMalloc(sizeof(List));
  83.    if (p->pNext==NULL)
  84.       return QLIST_OUT_MEMORY;
  85.    
  86.    p = p->pNext;
  87.    p->pPrev = self->m_pTail;
  88.    p->pData = pData;
  89.    p->pNext = NULL;
  90.    self->m_pTail = p;
  91.    self->m_nSize++;
  92.    return QLIST_OK;
  95. }
  96. int      QListInsert(QList *self,void* pData)
  97. {
  98.    List *p;
  100.    assert(self);
  101.    if (self->m_pHead == NULL)
  102.       return self->PlaceAtHead(self,pData);
  103.    
  104.    p = (List*)KB_OSPMalloc(sizeof(List));
  105.    if (p==NULL)
  106.       return QLIST_OUT_MEMORY;
  108.    if (self->m_pCurrent->pNext == NULL)
  109.    {
  110.       // append
  111.       self->m_pCurrent->pNext = p;
  112.       p->pPrev = self->m_pCurrent;
  113.       p->pNext = NULL;
  114.    }
  115.    else
  116.    {
  117.       // insert
  118.       p->pNext = self->m_pCurrent->pNext;
  119.       p->pPrev = self->m_pCurrent;
  120.       self->m_pCurrent->pNext->pPrev = p;
  121.       self->m_pCurrent->pNext = p;
  122.    }
  123.    return QLIST_OK;
  125. }
  126. void   *QListGetData(QList *self)
  127. {
  128.    assert(self);
  129.    if (self->m_pCurrent==NULL)
  130.       return NULL;
  131.    return self->m_pCurrent->pData;
  132. }
  133. int      QListMoveToHead(QList *self)
  134. {
  135.    assert(self);
  136.    if (self->m_pHead == NULL)
  137.    {
  138.       self->m_pCurrent = NULL;
  139.       return QLIST_EMPTY;
  140.    }
  141.    self->m_pCurrent = self->m_pHead;
  142.    return QLIST_OK;
  143. }
  144. int      QListMoveToTail(QList *self)
  145. {
  146.    assert(self);
  148.    if (self->m_pTail == NULL)
  149.    {
  150.       self->m_pCurrent = NULL;
  151.       return QLIST_EMPTY;
  152.    }
  153.    self->m_pCurrent = self->m_pTail;
  154.    return QLIST_OK;
  155. }
  156. int      QListMoveNext(QList *self)
  157. {
  158.    assert(self);
  160.    if (self->m_pHead == NULL)
  161.    {
  162.       self->m_pCurrent = NULL;
  163.       return QLIST_EMPTY;
  164.    }
  165.    if (self->m_pCurrent->pNext != NULL)
  166.    {
  167.       self->m_pCurrent = self->m_pCurrent->pNext;
  168.       return QLIST_OK;
  169.    }
  170.    self->m_pCurrent = NULL;
  171.    return QLIST_END;
  173. }
  174. int      QListMovePrev(QList *self)
  175. {
  176.    assert(self);
  178.    if (self->m_pHead == NULL)
  179.    {
  180.       self->m_pCurrent = NULL;
  181.       return QLIST_EMPTY;
  182.    }
  183.    if (self->m_pCurrent->pPrev != NULL)
  184.    {
  185.       self->m_pCurrent = self->m_pCurrent->pPrev;
  186.       return QLIST_OK;
  187.    }
  188.    self->m_pCurrent = NULL;
  189.    return QLIST_BEGIN;
  191. }
  192. int      QListIsEmpty(QList *self)
  193. {
  194.    assert(self);
  195.    return (self->m_pHead==NULL);
  196. }
  197. int      QListGetSize(QList *self)
  198. {
  199.    assert(self);
  200.    return (self->m_nSize);
  202. }
  204. int      QListPlaceAtHead(QList *self,void* pData)
  205. {
  206.    assert(self);
  208.    self->m_pHead = (List*)KB_OSPMalloc(sizeof(List));
  209.    if (self->m_pHead==NULL)
  210.       return QLIST_OUT_MEMORY;
  211.    self->m_pCurrent = self->m_pHead;
  212.    self->m_pCurrent->pData = pData;
  213.    self->m_pCurrent->pNext = NULL;
  214.    self->m_pCurrent->pPrev = NULL;
  215.    self->m_pTail = self->m_pCurrent;
  216.    self->m_nSize++;
  217.    return QLIST_OK;
  218. }
  220. int      QListRemove(QList *self)
  221. {
  222.       
  223.    List *p;
  224.    List *pPrev;
  225.    List *pNext;
  227.    assert(self);
  229.    if (self->m_pHead == NULL)
  230.       return QLIST_EMPTY;
  232.    p = self->m_pCurrent;
  234.    if(p == NULL) 
  235.       return QLIST_END;
  236.    pPrev = p->pPrev;
  237.    pNext = p->pNext;
  239.    if(pPrev == NULL)
  240.    {
  242.       self->m_pHead = pNext;
  243.       pNext->pPrev = NULL;
  244.    }
  245.    else
  246.    {
  247.       pPrev->pNext = pNext;
  248.       pNext->pPrev = pPrev;
  249.    }
  251.    self->m_pCurrent = pNext;
  252.    KB_OSPFree(p);
  253.    p = NULL;
  254.    self->m_nSize--;
  255.    return QLIST_OK;
  256. }
  261. QAutoList   NewQAutoList()
  262. {
  263.    QAutoList self;
  264.    self.list = NewQList();
  265.    self.Release = QAutoListRelease;
  266.    return self;
  268. }
  269. QAutoList   *MallocQAutoList()
  270. {
  271.    QAutoList *self = (QAutoList *) KB_OSPMalloc(sizeof(QAutoList));
  272.    if(!self) return NULL;
  274.    self->list = NewQList();
  275.    self->Release = QAutoListRelease;
  276.    return self;
  279. }
  281. void   QAutoListRelease(QAutoList *self)
  282. {
  283.    List *pTemp;
  284.    List *p;
  286.    assert(self);
  288.    if (self->list.m_pHead == NULL)
  289.       return;
  291.    p = self->list.m_pTail;
  293.    while (p)
  294.    {
  295.       pTemp = p->pPrev;
  296.       if(p->pData)
  297.       {
  298.          KB_OSPFree(p->pData);
  299.          p->pData = NULL;
  300.       }
  301.       p = pTemp;
  302.    }
  303.    self->list.Clear(&self->list);   
  304. }
  309. QInn   NewQInn()
  310. {
  311.    QInn self;
  312.    self.Push = QInnPush;
  313.         self.Pop = QInnPop;
  314.         self.Release = QInnRelease;
  315.    self.pHead = NULL;
  316.    self.pTail = NULL;
  317.    return self;
  318. }
  320. QInn   *MallocQInn()
  321. {
  322.    QInn *self = (QInn *)KB_OSPMalloc(sizeof(QInn));
  324.    if(self == NULL) return NULL;
  325.    self->Push = QInnPush;
  326.         self->Pop = QInnPop;
  327.         self->Release = QInnRelease;
  329.    self->pHead = NULL;
  330.    self->pTail = NULL;
  331.    return self;
  333. }
  335. void   QInnPush(QInn *self,void *data)
  336. {
  337.    Inn *p;
  338.    Inn *temp;
  339.    assert(self);
  340.    
  341.    if(data == NULL) return;
  343.    temp = (Inn *)KB_OSPMalloc(sizeof(Inn));
  344.    if(temp == NULL) return ;
  345.    
  346.    temp->data = data;
  347.    temp->pNext = NULL;
  349.    if(self->pHead)
  350.    {
  351.       p = self->pTail;
  352.       p->pNext = temp;
  353.       self->pTail = temp;
  354.    }
  355.    else
  356.    {
  357.       self->pHead = temp;
  358.       self->pTail = temp;
  359.    }
  360. }
  362. void   *QInnPop(QInn *self)
  363. {
  364.    Inn *p;
  365.    void *data;
  366.    assert(self);
  367.    p = self->pHead;
  368.    if(p)
  369.    {
  370.       self->pHead = p->pNext;
  371.       data  = p->data;
  372.       KB_OSPFree(p);
  373.       p = NULL;
  374.       return data;
  375.    }
  376.    return NULL;
  377. }
  379. void   QInnRelease(QInn *self)
  380. {
  381.    assert(self);
  382.    self->pHead = NULL;
  383.    self->pTail = NULL;
  384. }