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

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: id.h,v 1.5.32.3 2004/07/09 01:48:00 hubbe 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. #ifndef CHXID_H
  50. #define CHXID_H
  51. #include "hlxclib/string.h" //for memset/memcpy
  52. #include "hxassert.h"
  53. /*
  54.  *  The whole table now is zero based and we return id+1 when they ask
  55.  *  for a new id, and return table[id-1] when they want the data.
  56.  *  In this way this class will actually WORK and all of the code using this
  57.  *  can still think a 0 return is bad.
  58.  *                                                 -paulm
  59.  */
  60. class CHXID
  61. {
  62. public:
  63.     enum {
  64.       DEFAULT_VALUE =0,
  65.       TABLE_START_SIZE = 10000
  66.     };
  67.     CHXID(u_long32 size = TABLE_START_SIZE);
  68.     ~CHXID();
  69.     u_long32  create(void* ptr = (void*)DEFAULT_VALUE);
  70.     void*     destroy(u_long32 id);
  71.     void*     get(u_long32 id);
  72.     void      set(u_long32 id, void* ptr);
  73.     u_long32  get_size();
  74.     HX_RESULT m_LastError;
  75. private:
  76.     u_long32  table_size;
  77.     u_long32  increment_factor;
  78.     u_long32  slots_used;
  79.     u_long32  last_id;
  80.     void** table_ptr;
  81. };
  82. inline
  83. CHXID::CHXID(u_long32 size)
  84. : m_LastError(HXR_OK)
  85. {
  86.     ASSERT(size > 0);
  87.     table_size = size;
  88.     increment_factor = (table_size / 2) + 1;
  89.     slots_used = 0;
  90.     last_id    = table_size-1;
  91.     table_ptr = new void* [table_size];
  92.     if(!table_ptr)
  93.     {
  94.         m_LastError = HXR_OUTOFMEMORY;
  95.         return;
  96.     }
  97.     memset (table_ptr, DEFAULT_VALUE, table_size * sizeof(void*));
  98. }
  99. inline
  100. CHXID::~CHXID()
  101. {
  102.     delete [] table_ptr;
  103. }
  104. inline void*
  105. CHXID::get(u_long32 id)
  106. {
  107. // This assert has been disabled to prevent udp resend packets
  108. // from killing the server. If a player has a bug in it and sends
  109. // a corrupted udp_packet it could return an id larger than the
  110. // table_size here. The udp_accept logic needs the DEFAULT_VALUE to
  111. // toss the bad packet.
  112. //    ASSERT(id < table_size);
  113.     id--;
  114.     if (id < table_size)
  115.         return table_ptr[id];
  116.     else
  117.         return (void*)DEFAULT_VALUE;
  118. }
  119. inline void
  120. CHXID::set(u_long32 id, void* ptr)
  121. {
  122.     id--;
  123.     ASSERT(id < table_size);
  124.     
  125.     if (id < table_size)
  126.         table_ptr[id] = ptr;
  127. }
  128. inline u_long32
  129. CHXID::create(void* ptr)
  130. {
  131.     if (slots_used > table_size * 0.7)
  132.     {
  133.         void** tmp_table_ptr = new void* [table_size + increment_factor];
  134.         memcpy (tmp_table_ptr, table_ptr, table_size * sizeof(void*)); /* Flawfinder: ignore */
  135.         memset (tmp_table_ptr + table_size, DEFAULT_VALUE, increment_factor * sizeof(void*));
  136.         delete [] table_ptr;
  137.         table_ptr = tmp_table_ptr;
  138.         
  139.         table_size += increment_factor;
  140. increment_factor = table_size / 2;
  141.     }
  142.     u_long32 new_id = (last_id + 1) % table_size;
  143.     while(table_ptr[new_id] != (void*)DEFAULT_VALUE) 
  144. new_id = (new_id + 1) % table_size;
  145.     last_id = new_id;
  146.     table_ptr[new_id] = ptr;
  147.     slots_used++;
  148.     return new_id+1;
  149. }
  150. inline void*
  151. CHXID::destroy(u_long32 id)
  152. {
  153.     id--;
  154.     ASSERT(id < table_size);
  155.     if (id > table_size)
  156.     {
  157.         return 0;
  158.     }
  159.     void* ptr = table_ptr[id];
  160.     if (ptr == (void*)DEFAULT_VALUE)
  161.         return 0;
  162.     table_ptr[id] = (void*)DEFAULT_VALUE;
  163.     slots_used--;
  164.     return ptr;
  165. }
  166. inline u_long32
  167. CHXID::get_size()
  168. {
  169.     return table_size;
  170. }
  171. #endif