key.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:8k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: key.cpp,v 1.7.32.3.2.1 2005/03/29 06:04:47 ehodge Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include "hlxclib/string.h"
  50. #include "hxtypes.h"
  51. #include "key.h"
  52. #include "hxheap.h"
  53. #ifdef _DEBUG
  54. #undef HX_THIS_FILE
  55. static const char HX_THIS_FILE[] = __FILE__;
  56. #endif
  57. #define MAX_NUM_LEVELS 255
  58. Key::Key(const char * s, char d)
  59.             : m_LastError(HXR_OK)
  60.             , _key_str(NULL)
  61.             , _curr_ptr(NULL)
  62.             , _curr_level(0)
  63.             , _last_sub_str(NULL)
  64.             , _delim(0)
  65.             , _size(0)
  66.             , _num_levels(0)
  67.             , _sub_strs(NULL)
  68. {
  69.     if (!s && !*s)
  70. return;
  71.     _curr_ptr = s;
  72.     // We have to go through this two step process because of a problem with
  73.     // the 16 bit compiler.
  74.     // Since xtmp_ptrs is to be used as an array of char*'s, use a
  75.     // #define (instead of just "1024") and reuse that define, below, to
  76.     // prevent going past the end of xtmp_ptrs when _num_levels >
  77.     // 1024/(sizeof(char*))
  78.     char* xtmp_ptrs = new char [(MAX_NUM_LEVELS+1) * sizeof(char*)]; /* Flawfinder: ignore */
  79.     if (!xtmp_ptrs)
  80.     {
  81.         m_LastError = HXR_OUTOFMEMORY;
  82.         return;
  83.     }
  84.     const char** tmp_ptrs = (const char**)xtmp_ptrs;
  85.     tmp_ptrs[0] = s;
  86.     /*
  87.      * loop to find out how many levels are there in this key string
  88.      * pointers in the string to the various sub-strings are stored in
  89.      * a temporary array, which will then be xferred to a dynamic array
  90.      * stored along with the key. this will speed up the sub-string 
  91.      * operations done later.
  92.      */
  93.     for (_num_levels = 1, _size = 1;
  94.             // Check to make sure _num_levels does not result in us writing
  95.             // past the end of tmp_ptrs  (Fixes PR 136246):
  96.             *_curr_ptr != ''  &&  _num_levels < MAX_NUM_LEVELS;
  97.             _curr_ptr++, _size++)
  98.     {
  99. if (*_curr_ptr == d)
  100. {
  101.     if (_curr_ptr > s)
  102.     {
  103. tmp_ptrs[_num_levels] = _curr_ptr;
  104. _num_levels++;
  105.     }
  106. }
  107.     }
  108.     if(_num_levels >= MAX_NUM_LEVELS)
  109.     {
  110.         m_LastError = HXR_UNEXPECTED;
  111.         HX_VECTOR_DELETE(xtmp_ptrs);
  112.         return;
  113.     }
  114.     tmp_ptrs[_num_levels] = _curr_ptr;
  115.     _sub_strs = new char* [_num_levels+1];
  116.     if(!_sub_strs)
  117.     {
  118.         m_LastError = HXR_OUTOFMEMORY;
  119.         HX_VECTOR_DELETE(xtmp_ptrs);
  120.         return;
  121.     }
  122.     _key_str = new char[_size];
  123.     if(!_key_str)
  124.     {
  125.         m_LastError = HXR_OUTOFMEMORY;
  126.         HX_VECTOR_DELETE(xtmp_ptrs);
  127.         HX_VECTOR_DELETE(_sub_strs);
  128.         return;
  129.     }
  130.     strcpy(_key_str, s); /* Flawfinder: ignore */
  131.     _sub_strs[0] = _key_str;
  132.     for (int i = 1; i < _num_levels+1; i++)
  133. _sub_strs[i] = _sub_strs[0] + (tmp_ptrs[i] - tmp_ptrs[0]);
  134.     _curr_ptr = _key_str;
  135.     _curr_level = 0;
  136.     _delim = d;
  137.     _last_sub_str = _sub_strs[_num_levels-1];
  138.     if (*_last_sub_str == _delim) ++_last_sub_str;
  139.     delete[] xtmp_ptrs;
  140. }
  141. /*
  142.  *  Function Name:   get_sub_str
  143.  *  Input Params:    char* delim
  144.  *  Return Value:    int
  145.  *  Description:
  146.  *   gets a sub-string of "key_str" delimited by "delim" and returns
  147.  *  the number of bytes in the sub-string.
  148.  */
  149. int
  150. Key::get_sub_str(char* buf, int buf_len, char delim)
  151. {
  152.     int c_len = 0;
  153.     char d = (delim) ? delim : _delim;
  154.     if (_curr_ptr && _curr_level >= _num_levels)
  155. return 0;
  156.     c_len = _sub_strs[_curr_level+1]-_sub_strs[_curr_level];
  157.     if (c_len >= buf_len)
  158. c_len = buf_len;
  159.     // XXXAAK -- for now use strncpy
  160.     strncpy(buf, _sub_strs[_curr_level], c_len); /* Flawfinder: ignore */
  161.     *(buf+c_len) = '';
  162.     _curr_level++;
  163.    
  164.     _curr_ptr = (_sub_strs[_curr_level]) ? _sub_strs[_curr_level]+1
  165.  : _sub_strs[_curr_level];
  166.     return c_len;
  167. }
  168. /*
  169.  *  Function Name:   Key::append_sub_str
  170.  *  Input Params:    char* buf, int buf_len, char delim
  171.  *  Return Value:    int
  172.  *  Description:
  173.  *   appends the next sub-string to the string in the buffer
  174.  *  passed as a parameter. if the buffer is empty the sub-string
  175.  *  is just copied into it, but if it is not-empty then it first
  176.  *  appends a delimiter and then the sub-string.
  177.  */
  178. int
  179. Key::append_sub_str(char* buf, int buf_len, char delim)
  180. {
  181.     int c_len = 0;
  182.     char d = (delim) ? delim : _delim;
  183.     // if we have reached the end of the key string
  184.     if (_curr_level >= _num_levels)
  185. return 0;
  186.     // loop until u reach the end of the buf before we append to it
  187.     if (*buf)
  188.     {
  189. for (; c_len < buf_len && *buf != ''; buf++, c_len++)
  190.     ;
  191. // return if no more space in the buffer
  192. if (c_len >= buf_len)
  193.     return 0;
  194. *buf = '';
  195.     }
  196.     int num_chars = _sub_strs[_curr_level+1]-_sub_strs[_curr_level];
  197.     /*
  198.      * if the combined length exceeds the buffer len then reduce
  199.      * the number of chars copied to fit the buffer
  200.      */
  201.     if ((c_len+num_chars) >= buf_len)
  202. num_chars = buf_len - c_len;
  203.     c_len += num_chars;
  204.     // XXXAAK -- for now use strncpy
  205.     strncpy(buf, _sub_strs[_curr_level], num_chars); /* Flawfinder: ignore */
  206.     *(buf+num_chars) = '';
  207.     _curr_level++;
  208.    
  209.     _curr_ptr = (_sub_strs[_curr_level]) ? _sub_strs[_curr_level]+1
  210.  : _sub_strs[_curr_level];
  211.     return c_len;
  212. }
  213. /*
  214.  *  Function Name:   Key::is_a_sub_str_of const
  215.  *  Input Params:    char* str
  216.  *  Return Value:    BOOL
  217.  *  Description:
  218.  *   check if the string "str" is a sub-string of the key string
  219.  *  if it is then return TRUE else return FALSE. one criterion for'
  220.  *  this operation is that a legal sub-string is defined as one which
  221.  *  ends with a matching delimiter of the _key_str or a '' char.
  222.  *  for example,
  223.  *      foo is a VALID sub-string of "foo.bar.shmoo"
  224.  *      and so is "foo.bar".
  225.  *      whereas "foo.b" is NOT a VALID sub-string of "foo.bar.shmoo"
  226.  */
  227. BOOL
  228. Key::is_a_sub_str_of(char* str) const
  229. {
  230.     if (!str || !*str)
  231. return FALSE;
  232.     char* tmp = _key_str;
  233.     for (; *str != ''; str++, tmp++)
  234.     {
  235. if (*str != *tmp)
  236.     return FALSE;
  237.     }
  238.     if (*tmp != _delim && *tmp != '')
  239. return FALSE;
  240.     return TRUE;
  241. }