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

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

DVD

开发平台：

C/C++

QString.c：源码内容
  1. #include <assert.h>
  2. #include <limits.h>
  3. #include "QString.h"
  4. #include "Osp.h"
  5. #include <string.h>
  6. #include <ctype.h>
  9. QString   NewQString()
  10. {
  11.    QString self;
  12.    self.Init =  QStringInit;
  13.    self.Release = QStringRelease;
  14.    self.AllocBuffer = QStringAllocBuffer;
  15.    self.GetLength = QStringGetLength;
  16.    self.IsEmpty = QStringIsEmpty;
  17.    self.ReSet = QStringReSet;
  18.    self.Append = QStringAppend;
  19.    self.AppendChar = QStringAppendChar;
  20.    self.AppendInt = QStringAppendInt;
  21.    self.AppendString = QStringAppendString;
  22.    self.GetAt = QStringGetAt;
  23.    self.Include = QStringInclude;
  24.    self.Find = QStringFind;
  25.    self.FindString = QStringFindString;
  26.    self.ToInt = QStringToInt;
  27.    self.CompareString = QStringCompareString;
  28.    self.Equal = QStringEqual;
  29.    self.Replace = QStringReplace;
  30.    self.Mid = QStringMid;
  31.    self.MidIndex = QStringMidIndex;
  32.    self.Left = QStringLeft;
  33.    self.Right = QStringRight;
  34.    self.Trim = QStringTrim;
  35.    self.TrimRight = QStringTrimRight;
  36.    self.TrimLeft = QStringTrimLeft;
  37.    self.MakeUpper = QStringMakeUpper;
  38.    self.MakeLower = QStringMakeLower;
  39.    self.Delete = QStringDelete;
  40.    self.Split = QStringSplit;
  42.    self.Init(&self);
  43.    return self;               
  44. }
  46. QString   *MallocQString()
  47. {
  48.    QString *self = (QString *)KB_OSPMalloc(sizeof(QString));
  49.    
  50.    if(!self) return NULL;
  52.    self->Init =  QStringInit;
  53.    self->Release = QStringRelease;
  54.    self->AllocBuffer = QStringAllocBuffer;
  55.    self->GetLength = QStringGetLength;
  56.    self->IsEmpty = QStringIsEmpty;
  57.    self->ReSet = QStringReSet;
  58.    self->Append = QStringAppend;
  59.    self->AppendChar = QStringAppendChar;
  60.    self->AppendInt = QStringAppendInt;
  61.    self->AppendString = QStringAppendString;
  62.    self->GetAt = QStringGetAt;
  63.    self->Include = QStringInclude;
  64.    self->Find = QStringFind;
  65.    self->FindString = QStringFindString;
  66.    self->ToInt = QStringToInt;
  67.    self->CompareString = QStringCompareString;
  68.    self->Equal = QStringEqual;
  69.    self->Replace = QStringReplace;
  70.    self->Mid = QStringMid;
  71.    self->MidIndex = QStringMidIndex;
  72.    self->Left = QStringLeft;
  73.    self->Right = QStringRight;
  74.    self->Trim = QStringTrim;
  75.    self->TrimRight = QStringTrimRight;
  76.    self->TrimLeft = QStringTrimLeft;
  77.    self->MakeUpper = QStringMakeUpper;
  78.    self->MakeLower = QStringMakeLower;
  79.    self->Delete = QStringDelete;
  80.    self->Split = QStringSplit;
  82.    self->Init(self);
  83.    return self;               
  84. }
  86. void QStringInit(QString * self)
  87. {
  88.    assert(self);
  89.    self->m_dataBuff = NULL;
  90.    self->m_nDataLength = 0;
  91.    self->m_nAllocLength = 0;
  92. }
  93. void QStringRelease(QString * self)
  94. {
  95.    assert(self);
  96.    if(self->m_nAllocLength) KB_OSPFree(self->m_dataBuff);
  98.    self->m_dataBuff = NULL;
  99.    self->m_nDataLength = 0;
  100.    self->m_nAllocLength = 0;
  101. }
  103. BOOL QStringAllocBuffer(QString * self,int nLen)
  104. {
  105.    assert(nLen >= 0);
  106.    assert(nLen <= INT_MAX - 1); 
  107.    assert(self);
  108.    if (nLen == 0){
  109.       self->Init(self);
  110.    }else{
  111.       char *pData = NULL;
  112.       int bufflen  = sizeof(char)*nLen+sizeof(char);
  113.       pData = KB_OSPMalloc(bufflen);
  114.       if(pData == NULL)
  115.    return FALSE;
  116.       self->m_nAllocLength = nLen;
  117.       memset(pData,0,bufflen);
  118.       self->m_dataBuff = pData;
  119.    }
  120.    return TRUE;   
  121. }
  123. int QStringGetLength(QString * self)
  124. {
  125.    assert(self);
  126.    return self->m_nDataLength;
  127. }
  129. BOOL QStringIsEmpty(QString * self)
  130. {
  131.    assert(self);
  132.    return self->m_nDataLength>0?FALSE:TRUE;
  133. }
  135. void QStringReSet(QString * self,const char *szStr)
  136. {
  137.    assert(self);
  139.    self->Release(self);
  140.    if(!szStr) return;
  141.       self->Append(self,szStr,strlen(szStr));
  143. }
  144. void QStringAppend(QString * self,const char *szStr,int nLen)
  145. {
  146.    int nNewStrSize;
  147.    int nStrSize;
  148.    char *pStr;
  149.    char *tmpData;
  150.    int newAllocSize;
  152.    assert(self);
  153.    if(!szStr) return;         
  154.       nStrSize = 0;
  155.    
  156.    pStr = (char *)szStr;
  157.    
  158.    while(*pStr && nStrSize < nLen){
  159.       pStr ++;
  160.       nStrSize ++;
  161.    }
  162.    
  163.    if(nStrSize < 0)
  164.       return;
  165.    
  166.    nNewStrSize = self->m_nDataLength + nStrSize + sizeof(char);
  167.    
  168.    if(nNewStrSize > self->m_nAllocLength){
  169.       tmpData = self->m_dataBuff;
  171.       newAllocSize = nNewStrSize + /*nNewStrSize;*/nNewStrSize/4;
  172.       if(!self->AllocBuffer(self,newAllocSize))
  173.          return ;
  174.    
  175.       memcpy(self->m_dataBuff,tmpData,self->m_nDataLength);
  176.       KB_OSPFree(tmpData);
  177.       memcpy(self->m_dataBuff + self->m_nDataLength,szStr,nStrSize);
  178.       
  179.       self->m_nDataLength += nStrSize; 
  180.       self->m_nAllocLength = newAllocSize;
  181.    }else{
  182.       memcpy (self->m_dataBuff + self->m_nDataLength, szStr,nStrSize);
  183.       self->m_nDataLength += nStrSize; 
  184.    }
  185.    self->m_dataBuff[self->m_nDataLength] = 0;
  186. }
  188. void QStringAppendChar(QString * self,char ch)
  189. {
  190.    char tempData[2] = {0,0};
  191.    assert(self);
  192.    tempData[0] = ch;
  193.    self->Append(self,tempData,1);
  194. }
  195. void QStringAppendInt(QString * self,int n)
  196. {
  197.    char tempData[32];
  198.    assert(self);
  199.    sprintf(tempData,"%d",n);   
  200.    self->Append(self,tempData,strlen(tempData));
  201. }
  202. void QStringAppendString(QString * self,const char *str)
  203. {
  204.    assert(self);
  205.    if(!str) return ;
  206.    
  207.    self->Append(self,str,strlen(str));   
  208. }
  210. char QStringGetAt(QString * self,int index)
  211. {
  212.    assert(self);
  213.    if(index<0 || index >= self->m_nDataLength || self->m_nDataLength<=0) 
  214.        return 0;
  215.    
  216.    return self->m_dataBuff[index];
  217. }
  219. BOOL QStringInclude(QString * self,char ch)
  220. {
  221.    assert(self);
  222.    return self->Find(self,ch,0)>=0?TRUE:FALSE;
  223. }
  225. int QStringFind(QString * self,char ch,int offset)
  226. {
  227.    char * lookUp;
  228.    assert(self);
  229.             
  230.    if (offset >= self->m_nDataLength)
  231.       return -1;
  232.    for (lookUp = self->m_dataBuff + offset; * lookUp; lookUp++)
  233.       if (* lookUp == ch)
  234.          return lookUp - self->m_dataBuff;
  235.    return -1;      
  236. }
  238. int QStringFindString(QString * self,const char *str,int offset)
  239. {
  240.    int strLen = 0;
  241.    int i = 0;
  242.    char *pStr = (char *)str;
  243.    
  244.    assert(self);
  245.    
  246.    if(pStr == NULL) return -1;
  248.    while(*pStr){
  249.       strLen++;
  250.       pStr++;
  251.    }   
  253.    i = offset;
  254.    while(i < self->m_nDataLength){
  255.       if(strncmp(self->m_dataBuff + i, str, strLen) == 0)
  256.          return i;
  257.          i++;
  258.    }
  259.    return -1;   
  260. }
  262. int QStringToInt(QString * self)
  263. {
  264.    assert(self);
  265.    return atoi(self->m_dataBuff);
  266. }
  268. int QStringCompareString(QString * self,const char * lpsz)
  269. {
  270.    assert(self);
  272.    return strcmp(self->m_dataBuff,lpsz);
  273. }
  275. BOOL QStringEqual(QString * self,const char * lpsz)
  276. {
  277.    assert(self);
  278.    
  279.    if(self->m_dataBuff == NULL) return FALSE;
  280.    
  281.    return strcmp(self->m_dataBuff,lpsz) == 0 ? TRUE:FALSE;   
  282. }
  284. int QStringReplace(QString * self,char chOld, char chNew)
  285. {
  286.    int nCount = 0;   
  288.    assert(self);
  289.    
  290.    if (chOld != chNew){
  291.       char *psz = self->m_dataBuff;
  292.       
  293.       for(; * psz; psz++){
  294.          if (*psz == chOld){
  295.             *psz = chNew;
  296.             nCount++;
  297.          }
  298.       }
  299.    }
  300.    return nCount;   
  301. }
  303. char *QStringMid(QString * self,int nFirst)
  304. {
  305.    assert(self);
  306.    return self->MidIndex(self,nFirst, self->m_nDataLength - nFirst);
  307. }
  308. char *QStringMidIndex(QString * self,int nFirst,int nCount)
  309. {
  310.    QString dest = NewQString();
  311.    assert(self);
  313.    nFirst = nFirst < 0 ? 0:nFirst;
  314.    nCount = nCount < 0 ? 0:nCount;
  316.    if(nFirst + nCount > self->m_nDataLength)
  317.       nCount = self->m_nDataLength - nFirst;
  318.    if (nFirst > self->m_nDataLength)
  319.       nCount = 0;
  320.    
  321.    dest.AllocBuffer(&dest,nCount);
  322.    memcpy(dest.m_dataBuff,self->m_dataBuff+nFirst,nCount);
  323.    //dest.m_dataBuff[nCount] = 0;
  324.    return dest.m_dataBuff;
  325. }
  327. char *QStringLeft(QString * self,int nCount)
  328. {
  329.    QString dest = NewQString();
  330.    
  331.    assert(self);
  332.  
  334.    if(nCount < 0)
  335.       nCount = 0;
  336.    else if (nCount > self->m_nDataLength)
  337.       nCount = self->m_nDataLength;
  338.    
  339.    dest.AllocBuffer(&dest,nCount);
  341.    memcpy(dest.m_dataBuff,self->m_dataBuff,nCount);
  342.    dest.m_dataBuff[nCount] = 0;
  343.    return dest.m_dataBuff;   
  344. }
  345. char *QStringRight(QString * self,int nCount)
  346. {
  347.    QString dest = NewQString();
  348.    assert(self);
  350.    if(nCount < 0)
  351.       nCount = 0;
  352.    else if (nCount > self->m_nDataLength)
  353.       nCount = self->m_nDataLength;
  355.    dest.AllocBuffer(&dest,nCount);
  356.    memcpy(dest.m_dataBuff,self->m_dataBuff+
  357.           (self->m_nDataLength-nCount),nCount);   
  358.    return dest.m_dataBuff;   
  359. }
  361. void QStringTrim(QString * self)
  362. {
  363.    char *lpsz = NULL;
  364.    char *lpszLast = NULL;
  365.    int nDataLength;
  366.    int nMoveDataLength;
  367.    assert(self);
  369.    if(!self->m_dataBuff) return;
  371.    lpsz = self->m_dataBuff;
  373.    while ((*lpsz ==' ' || 
  374.          *lpsz == 't' || 
  375.           *lpsz =='n' ||
  376.            *lpsz =='r')&& *lpsz)
  377.       lpsz++;
  378.   
  379.    // fix up data and length
  380.    nMoveDataLength = (int)(unsigned long)(lpsz - self->m_dataBuff);
  381.    nDataLength = self->m_nDataLength - nMoveDataLength;
  382.    memmove(self->m_dataBuff, lpsz, (nDataLength + 1) * sizeof(char));
  383.    
  384.    self->m_nAllocLength-= nMoveDataLength;   
  385.    self->m_nDataLength = nDataLength;
  386.    
  387.    while (*lpsz != ''){
  388.       if( *lpsz ==' ' || *lpsz == 't' || *lpsz =='n' || *lpsz =='r'){
  389.          if (lpszLast == NULL)
  390.             lpszLast = lpsz;
  391.          }else{
  392.             lpszLast = NULL;
  393.          }
  394.       lpsz++;
  395.    }
  397.    if(lpszLast != NULL){
  398.       // truncate at trailing space start
  399.       *lpszLast = '';
  400.       nDataLength = (int)(unsigned long)(lpszLast - self->m_dataBuff);
  401.       nMoveDataLength = self->m_nDataLength - nDataLength;
  402.       self->m_nDataLength = nDataLength;
  403.       self->m_nAllocLength -= nMoveDataLength;
  404.    }
  406. }
  407. void QStringTrimRight(QString * self)
  408. {
  409.    char *lpsz = NULL;
  410.    char *lpszLast = NULL;
  411.    int nMoveDataLength;
  412.    int nDataLength ;
  414.    assert(self);
  416.    if(!self->m_dataBuff) return;
  417.       lpsz = self->m_dataBuff;
  418.    while (*lpsz != ''){
  419.       if (*lpsz ==' ' || *lpsz == 't' || *lpsz =='n' || *lpsz =='r'){
  420.          if (lpszLast == NULL)
  421.             lpszLast = lpsz;
  422.       }else{
  423.          lpszLast = NULL;
  424.       }
  425.       lpsz++;
  426.    }
  427.    
  428.    if (lpszLast != NULL){
  429.       // truncate at trailing space start
  430.       *lpszLast = '';
  431.       nDataLength = (int)(unsigned long)(lpszLast - self->m_dataBuff);
  432.       nMoveDataLength = self->m_nDataLength - nDataLength;
  433.       self->m_nDataLength = nDataLength;
  434.       self->m_nAllocLength -= nMoveDataLength;
  435.    }
  436. }      
  438. void QStringTrimLeft(QString * self)
  439. {
  440.    // find first non-space character
  441.    char *lpsz = NULL;
  442.    int nMoveDataLength;
  443.    int nDataLength ;
  445.    assert(self);
  447.    if(!self->m_dataBuff) return;
  449.    lpsz = self->m_dataBuff;
  450.    while ((*lpsz ==' ' || *lpsz == 't' || *lpsz =='n' || *lpsz =='r')&&
  451.           *lpsz)
  452.      lpsz++;
  454.    // fix up data and length
  455.    nMoveDataLength = (int)(unsigned long)(lpsz - self->m_dataBuff);
  456.    nDataLength = self->m_nDataLength - nMoveDataLength ;
  457.    memmove(self->m_dataBuff, lpsz, (nDataLength + 1) * sizeof(char));
  458.    self->m_nDataLength = nDataLength;
  459.    self->m_nAllocLength -= nMoveDataLength;
  460. }   
  462. char *QStringMakeUpper(QString * self)
  463. {
  464.    char *lpsz;
  466.    assert(self);
  467.    if(!self->m_dataBuff) return "";
  468.    lpsz = self->m_dataBuff;
  469.    while (*lpsz != ''){
  470.       if(isalpha(*lpsz)&&islower(*lpsz))
  471.          *lpsz = toupper(*lpsz);
  472.       lpsz++;
  473.    }
  474.    return self->m_dataBuff;
  475. }      
  477. char *QStringMakeLower(QString * self)
  478. {
  479.    char *lpsz;
  481.    assert(self);
  483.    if(!self->m_dataBuff) return "";
  484.    lpsz = self->m_dataBuff;
  485.    while (*lpsz != '')
  486.    {
  487.       if(isalpha(*lpsz)&&isupper(*lpsz))
  488.          *lpsz = tolower(*lpsz);
  489.       lpsz++;
  490.    }
  491.    return self->m_dataBuff;
  493. }   
  495. int   QStringDelete(QString * self,int nIndex, int nCount )
  496. {
  497.    int nNewLength ;
  498.    assert(self);
  499.    
  500.    if (nIndex < 0)
  501.       nIndex = 0;
  502.    nNewLength = self->m_nDataLength;
  503.    if (nCount > 0 && nIndex < nNewLength)
  504.    {
  505.       int nBytesToCopy = nNewLength - (nIndex + nCount) + 1;
  506.       if(nBytesToCopy <0 ) {   return -1;}
  507.       memmove(self->m_dataBuff + nIndex, self->m_dataBuff + nIndex + nCount, nBytesToCopy * sizeof(char));
  508.       self->m_nDataLength = nNewLength - nCount;
  509.       self->m_nAllocLength -= nCount;
  510.    }
  511.    return nNewLength;
  512. }
  514. QList   QStringSplit(QString * self,char ch )
  515. {
  516.    QList stringlist = NewQList();
  517.    char * lookUp;
  518.    QString word = NewQString();
  519.    QString * newWord = NULL;
  520.    BOOL hasChar = FALSE;
  521.    
  522.    assert(self);   
  524.    for (lookUp = self->m_dataBuff; * lookUp; lookUp++)
  525.    {
  526.       if (* lookUp == ch)
  527.       {
  528.          hasChar = TRUE;
  529.          newWord = MallocQString();
  530.          newWord->AppendString(newWord,word.m_dataBuff);
  531.          stringlist.Add(&stringlist,newWord);
  533.          word.Release(&word);
  534.          lookUp++;
  535.          if(!*lookUp) break;
  536.       }
  537.       word.AppendChar(&word , *lookUp);
  538.    }
  539.    if(!hasChar)
  540.    {
  541.       stringlist.Clear(&stringlist);
  542.    }
  543.    else
  544.    {
  545.       if(!word.IsEmpty(&word))
  546.       {   
  547.          newWord = MallocQString();
  548.          newWord->AppendString(newWord,word.m_dataBuff);
  549.          stringlist.Add(&stringlist,newWord);   
  550.       }
  551.       
  552.    }
  553.    word.Release(&word);
  554.    return stringlist;
  555. }
  558. QStringList NewQStringList()
  559. {
  560.    QStringList self;
  561.    self.list = NewQList();
  562.    self.Release = QStringListRelease;
  563.    return self;
  564. }
  565. QStringList *MallocQStringList()
  566. {
  567.    QStringList *self = (QStringList *) KB_OSPMalloc(sizeof(QStringList));
  568.    if(!self) return NULL;
  570.    self->list = NewQList();
  571.    self->Release = QStringListRelease;
  572.    return self;
  574. }
  575. void   QStringListRelease(QStringList * self)
  576. {
  577.    QString *str;
  578.    assert(self);
  579.    if(self->list.MoveToHead(&self->list) == QLIST_OK)
  580.    {
  581.       str = (QString *)self->list.GetData(&self->list);
  582.       while(str)
  583.       {
  584.          str->Release(str);
  585.          KB_OSPFree(str);
  586.          str = NULL;
  587.          self->list.MoveNext(&self->list);   
  588.          str = (QString *)self->list.GetData(&self->list);
  589.       }
  590.    }
  591.    self->list.Clear(&self->list);
  592. }