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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ConfigValues.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

ConfigValues.cpp：源码内容
  2. #include <ndb_global.h>
  3. #include <ConfigValues.hpp>
  4. #include <NdbOut.hpp>
  5. #include <NdbTCP.h>
  7. static Uint32 hash(Uint32 key, Uint32 size);
  8. static Uint32 nextHash(Uint32 key, Uint32 size, Uint32 pos, Uint32 count);
  9. static bool findKey(const Uint32 * vals, Uint32 sz, Uint32 key, Uint32 * pos);
  11. /**
  12.  * Key
  13.  *
  14.  * t = Type      -  4 bits 0-15
  15.  * s = Section   - 14 bits 0-16383
  16.  * k = Key value - 14 bits 0-16383
  17.  *
  18.  *           1111111111222222222233
  19.  * 01234567890123456789012345678901
  20.  * kkkkkkkkkkkkkkssssssssssssssoooo
  21.  */
  22. #define KP_TYPE_MASK     (15)
  23. #define KP_TYPE_SHIFT    (28)
  24. #define KP_SECTION_MASK  (0x3FFF)
  25. #define KP_SECTION_SHIFT (14)
  26. #define KP_KEYVAL_MASK   (0x3FFF)
  27. #define KP_KEYVAL_SHIFT  (0)
  28. #define KP_MASK          (0x0FFFFFFF)
  30. static const Uint32 CFV_KEY_PARENT = (KP_KEYVAL_MASK - 1);
  31. static const Uint32 CFV_KEY_FREE   = ~0;
  33. static const char Magic[] = { 'N', 'D', 'B', 'C', 'O', 'N', 'F', 'V' };
  35. //#define DEBUG_CV
  36. #ifdef DEBUG_CV
  37. #define DEBUG
  38. #else
  39. #define DEBUG if(0)
  40. #endif
  42. inline
  43. ConfigValues::ValueType
  44. getTypeOf(Uint32 k) {
  45.   return (ConfigValues::ValueType)((k >> KP_TYPE_SHIFT) & KP_TYPE_MASK);
  46. }
  48. ConfigValues::ConfigValues(Uint32 sz, Uint32 dsz){
  49.   m_size = sz;
  50.   m_dataSize = dsz;
  51.   m_stringCount = 0;
  52.   m_int64Count = 0;
  53.   for(Uint32 i = 0; i<m_size; i++){
  54.     m_values[i << 1] = CFV_KEY_FREE;
  55.   }
  56. }
  58. ConfigValues::~ConfigValues(){
  59.   for(Uint32 i = 0; i<m_stringCount; i++){
  60.     free(* getString(i));
  61.   }
  62. }
  64. bool
  65. ConfigValues::ConstIterator::get(Uint32 key, Entry * result) const {
  66.   Uint32 pos;
  67.   if(!findKey(m_cfg.m_values, m_cfg.m_size, key | m_currentSection, &pos)){
  68.     return false;
  69.   }
  70.   
  71.   result->m_key = key;
  72.   return m_cfg.getByPos(pos, result);
  73. }
  75. bool
  76. ConfigValues::getByPos(Uint32 pos, Entry * result) const {
  77.   assert(pos < (2 * m_size));
  78.   Uint32 keypart = m_values[pos];
  79.   Uint32 val = m_values[pos+1];
  81.   switch(::getTypeOf(keypart)){
  82.   case IntType:
  83.   case SectionType:
  84.     result->m_int = val;
  85.     break;
  86.   case StringType:
  87.     result->m_string = * getString(val);
  88.     break;
  89.   case Int64Type:
  90.     result->m_int64 = * get64(val);
  91.     break;
  92.   case InvalidType: 
  93.   default:
  94.     return false;
  95.   }
  97.   result->m_type = ::getTypeOf(keypart);
  98.   
  99.   return true;
  100. }
  102. Uint64 *
  103. ConfigValues::get64(Uint32 index) const {
  104.   assert(index < m_int64Count);
  105.   const Uint32 * data = m_values + (m_size << 1);
  106.   Uint64 * ptr = (Uint64*)data;
  107.   ptr += index;
  108.   return ptr;
  109. }
  111. char **
  112. ConfigValues::getString(Uint32 index) const {
  113.   assert(index < m_stringCount); 
  114.   const Uint32 * data = m_values + (m_size << 1);
  115.   char * ptr = (char*)data;
  116.   ptr += m_dataSize; 
  117.   ptr -= (index * sizeof(char *));
  118.   return (char**)ptr;
  119. }
  121. bool
  122. ConfigValues::ConstIterator::openSection(Uint32 key, Uint32 no){
  123.   Uint32 curr = m_currentSection;
  124.   
  125.   Entry tmp;
  126.   if(get(key, &tmp) && tmp.m_type == SectionType){
  127.     m_currentSection = tmp.m_int;
  128.     if(get(no, &tmp) && tmp.m_type == IntType){
  129.       m_currentSection = tmp.m_int;
  130.       /**
  131.        * Validate
  132.        */
  133.       if(get(CFV_KEY_PARENT, &tmp)){
  134. return true;
  135.       }
  136.     }
  137.   }
  138.   
  139.   m_currentSection = curr;
  140.   return false;
  141. }
  143. bool
  144. ConfigValues::ConstIterator::closeSection() {
  145.   
  146.   Entry tmp;
  147.   if(get(CFV_KEY_PARENT, &tmp) && tmp.m_type == IntType){
  148.     m_currentSection = tmp.m_int;
  149.     return true;
  150.   }
  152.   return false;
  153. }
  155. bool
  156. ConfigValues::Iterator::set(Uint32 key, Uint32 value){
  157.   Uint32 pos;
  158.   if(!findKey(m_cfg.m_values, m_cfg.m_size, key | m_currentSection, &pos)){
  159.     return false;
  160.   }
  162.   if(::getTypeOf(m_cfg.m_values[pos]) != IntType){
  163.     return false;
  164.   }
  166.   m_cfg.m_values[pos+1] = value;
  167.   return true;
  168. }
  170. bool
  171. ConfigValues::Iterator::set(Uint32 key, Uint64 value){
  172.   Uint32 pos;
  173.   if(!findKey(m_cfg.m_values, m_cfg.m_size, key | m_currentSection, &pos)){
  174.     return false;
  175.   }
  177.   if(::getTypeOf(m_cfg.m_values[pos]) != Int64Type){
  178.     return false;
  179.   }
  180.   
  181.   * m_cfg.get64(m_cfg.m_values[pos+1]) = value;
  182.   return true;
  183. }
  185. bool
  186. ConfigValues::Iterator::set(Uint32 key, const char * value){
  187.   Uint32 pos;
  188.   if(!findKey(m_cfg.m_values, m_cfg.m_size, key | m_currentSection, &pos)){
  189.     return false;
  190.   }
  192.   if(::getTypeOf(m_cfg.m_values[pos]) != StringType){
  193.     return false;
  194.   }
  196.   char **  str = m_cfg.getString(m_cfg.m_values[pos+1]);
  197.   free(* str);
  198.   * str = strdup(value ? value : "");
  199.   return true;
  200. }
  202. static
  203. bool
  204. findKey(const Uint32 * values, Uint32 sz, Uint32 key, Uint32 * _pos){
  205.   Uint32 pos = hash(key, sz);
  206.   Uint32 count = 0;
  207.   while((values[pos] & KP_MASK) != key && count < sz){
  208.     pos = nextHash(key, sz, pos, ++count);
  209.   }
  211.   if((values[pos] & KP_MASK)== key){
  212.     *_pos = pos;
  213.     return true;
  214.   }
  215.   return false;
  216. }
  218. static
  219. Uint32
  220. hash(Uint32 key, Uint32 size){
  221.   Uint32 tmp = (key >> 16) ^ (key & 0xFFFF);
  222.   return (((tmp << 16) | tmp) % size) << 1;
  223. }
  225. static
  226. Uint32
  227. nextHash(Uint32 key, Uint32 size, Uint32 pos, Uint32 count){
  228.   Uint32 p = (pos >> 1);
  229.   if((key % size) != 0)
  230.     p += key;
  231.   else
  232.     p += 1;
  233.   return (p % size) << 1;
  234. }
  236. static
  237. Uint32
  238. directory(Uint32 sz){
  239.   const Uint32 _input = sz;
  240.   if((sz & 1) == 0)
  241.     sz ++;
  242.   
  243.   bool prime = false;
  244.   while(!prime){
  245.     prime = true;
  246.     for(Uint32 n = 3; n*n <= sz; n += 2){
  247.       if((sz % n) == 0){
  248. prime = false;
  249. sz += 2;
  250. break;
  251.       }
  252.     }
  253.   }
  254.   DEBUG printf("directory %d -> %dn", _input, sz);
  255.   return sz;
  256. }
  258. ConfigValuesFactory::ConfigValuesFactory(Uint32 keys, Uint32 data){
  259.   m_sectionCounter = (1 << KP_SECTION_SHIFT);
  260.   m_freeKeys = directory(keys);
  261.   m_freeData = (data + 7) & ~7;
  262.   m_currentSection = 0;
  263.   m_cfg = create(m_freeKeys, m_freeData);
  264. }
  266. ConfigValuesFactory::ConfigValuesFactory(ConfigValues * cfg){
  267.   m_cfg = cfg;
  268.   m_freeKeys = 0;
  269.   m_freeData = m_cfg->m_dataSize;
  270.   m_sectionCounter = (1 << KP_SECTION_SHIFT);  
  271.   m_currentSection = 0;
  272.   const Uint32 sz = 2 * m_cfg->m_size;
  273.   for(Uint32 i = 0; i<sz; i += 2){
  274.     const Uint32 key = m_cfg->m_values[i];
  275.     if(key == CFV_KEY_FREE){
  276.       m_freeKeys++;
  277.     } else {
  278.       switch(::getTypeOf(key)){
  279.       case ConfigValues::IntType:
  280.       case ConfigValues::SectionType:
  281. break;
  282.       case ConfigValues::Int64Type:
  283. m_freeData -= sizeof(Uint64);
  284. break;
  285.       case ConfigValues::StringType:
  286. m_freeData -= sizeof(char *);
  287. break;
  288.       case ConfigValues::InvalidType:
  289. abort();
  290.       }
  291.       Uint32 sec = key & (KP_SECTION_MASK << KP_SECTION_SHIFT);
  292.       m_sectionCounter = (sec > m_sectionCounter ? sec : m_sectionCounter);
  293.     }
  294.   }
  295. }
  297. ConfigValues *
  298. ConfigValuesFactory::create(Uint32 keys, Uint32 data){
  299.   Uint32 sz = sizeof(ConfigValues);
  300.   sz += (2 * keys * sizeof(Uint32)); 
  301.   sz += data;
  302.   
  303.   void * tmp = malloc(sz);
  304.   return new (tmp) ConfigValues(keys, data);
  305. }
  307. void
  308. ConfigValuesFactory::expand(Uint32 fk, Uint32 fs){
  309.   if(m_freeKeys >= fk && m_freeData >= fs){
  310.     return ;
  311.   }
  313.   m_freeKeys = (m_freeKeys >= fk ? m_cfg->m_size : fk + m_cfg->m_size);
  314.   m_freeData = (m_freeData >= fs ? m_cfg->m_dataSize : fs + m_cfg->m_dataSize);
  315.   m_freeKeys = directory(m_freeKeys);
  316.   m_freeData = (m_freeData + 7) & ~7;
  317.  
  318.   ConfigValues * m_tmp = m_cfg;
  319.   m_cfg = create(m_freeKeys, m_freeData);
  320.   put(* m_tmp);
  321.   m_tmp->~ConfigValues();
  322.   free(m_tmp);
  323. }
  325. void
  326. ConfigValuesFactory::shrink(){
  327.   if(m_freeKeys == 0 && m_freeData == 0){
  328.     return ;
  329.   }
  331.   m_freeKeys = m_cfg->m_size - m_freeKeys;
  332.   m_freeData = m_cfg->m_dataSize - m_freeData;
  333.   m_freeKeys = directory(m_freeKeys);
  334.   m_freeData = (m_freeData + 7) & ~7;
  336.   ConfigValues * m_tmp = m_cfg;
  337.   m_cfg = create(m_freeKeys, m_freeData);
  338.   put(* m_tmp);
  339.   m_tmp->~ConfigValues();
  340.   free(m_tmp);
  341. }
  343. bool
  344. ConfigValuesFactory::openSection(Uint32 key, Uint32 no){
  345.   ConfigValues::Entry tmp;
  346.   const Uint32 parent = m_currentSection;
  348.   ConfigValues::ConstIterator iter(* m_cfg);
  349.   iter.m_currentSection = m_currentSection;
  350.   if(!iter.get(key, &tmp)){
  352.     tmp.m_key  = key;
  353.     tmp.m_type = ConfigValues::SectionType;
  354.     tmp.m_int  = m_sectionCounter;
  355.     m_sectionCounter += (1 << KP_SECTION_SHIFT);
  357.     if(!put(tmp)){
  358.       return false;
  359.     }
  360.   }
  362.   if(tmp.m_type != ConfigValues::SectionType){
  363.     return false;
  364.   }
  366.   m_currentSection = tmp.m_int;
  368.   tmp.m_key = no;
  369.   tmp.m_type = ConfigValues::IntType;
  370.   tmp.m_int = m_sectionCounter;
  371.   if(!put(tmp)){
  372.     m_currentSection = parent;
  373.     return false;
  374.   }
  375.   m_sectionCounter += (1 << KP_SECTION_SHIFT);
  376.   
  377.   m_currentSection = tmp.m_int;
  378.   tmp.m_type = ConfigValues::IntType;
  379.   tmp.m_key = CFV_KEY_PARENT;
  380.   tmp.m_int = parent;
  381.   if(!put(tmp)){
  382.     m_currentSection = parent;
  383.     return false;
  384.   }
  386.   return true;
  387. }
  389. bool
  390. ConfigValuesFactory::closeSection(){
  391.   ConfigValues::ConstIterator iter(* m_cfg);
  392.   iter.m_currentSection = m_currentSection;
  393.   const bool b = iter.closeSection();
  394.   m_currentSection = iter.m_currentSection;
  395.   return b;
  396. }
  397.   
  398. bool
  399. ConfigValuesFactory::put(const ConfigValues::Entry & entry){
  400.   
  401.   if(m_freeKeys == 0 ||
  402.      (entry.m_type == ConfigValues::StringType && m_freeData < sizeof(char *))
  403.      || (entry.m_type == ConfigValues::Int64Type && m_freeData < 8 )){ 
  404.     
  405.     DEBUG ndbout_c("m_freeKeys = %d, m_freeData = %d -> expand",
  406.    m_freeKeys, m_freeData);
  407.     
  408.     expand(31, 20);
  409.   }
  410.   
  411.   const Uint32 tmp = entry.m_key | m_currentSection;
  412.   const Uint32 sz = m_cfg->m_size;
  413.   Uint32 pos = hash(tmp, sz);
  414.   Uint32 count = 0;
  415.   Uint32 val = m_cfg->m_values[pos];
  417.   while((val & KP_MASK) != tmp && val != CFV_KEY_FREE && count < sz){
  418.     pos = nextHash(tmp, sz, pos, ++count);
  419.     val = m_cfg->m_values[pos];
  420.   }
  422.   if((val & KP_MASK) == tmp){
  423.     DEBUG ndbout_c("key %x already found at pos: %d", tmp, pos);
  424.     return false;
  425.   }
  427.   if(count >= sz){
  428.     pos = hash(tmp, sz);    
  429.     count = 0;
  430.     Uint32 val = m_cfg->m_values[pos];
  431.    
  432.     printf("key: %d, (key %% size): %dn", entry.m_key, (entry.m_key % sz));
  433.     printf("pos: %d", pos);
  434.     while((val & KP_MASK) != tmp && val != CFV_KEY_FREE && count < sz){
  435.       pos = nextHash(tmp, sz, pos, ++count);
  436.       val = m_cfg->m_values[pos];
  437.       printf(" %d", pos);
  438.     }
  439.     printf("n");
  441.     abort();
  442.     printf("Fulln");
  443.     return false;
  444.   }
  446.   assert(pos < (sz << 1));
  448.   Uint32 key = tmp;
  449.   key |= (entry.m_type << KP_TYPE_SHIFT);
  450.   m_cfg->m_values[pos] = key;
  451.   switch(entry.m_type){
  452.   case ConfigValues::IntType:
  453.   case ConfigValues::SectionType:
  454.     m_cfg->m_values[pos+1] = entry.m_int;    
  455.     m_freeKeys--;
  456.     DEBUG printf("Putting at: %d(%d) (loop = %d) key: %d value: %dn", 
  457.    pos, sz, count, 
  458.    (key >> KP_KEYVAL_SHIFT) & KP_KEYVAL_MASK,
  459.    entry.m_int);
  460.     return true;
  461.   case ConfigValues::StringType:{
  462.     Uint32 index = m_cfg->m_stringCount++;
  463.     m_cfg->m_values[pos+1] = index;
  464.     char **  ref = m_cfg->getString(index);
  465.     * ref = strdup(entry.m_string ? entry.m_string : "");
  466.     m_freeKeys--;
  467.     m_freeData -= sizeof(char *);
  468.     DEBUG printf("Putting at: %d(%d) (loop = %d) key: %d value(%d): %sn", 
  469.    pos, sz, count, 
  470.    (key >> KP_KEYVAL_SHIFT) & KP_KEYVAL_MASK,
  471.    index,
  472.    entry.m_string);
  473.     return true;
  474.   }
  475.   case ConfigValues::Int64Type:{
  476.     Uint32 index = m_cfg->m_int64Count++;
  477.     m_cfg->m_values[pos+1] = index;
  478.     * m_cfg->get64(index) = entry.m_int64;
  479.     m_freeKeys--;
  480.     m_freeData -= 8;
  481.     DEBUG printf("Putting at: %d(%d) (loop = %d) key: %d value64(%d): %lldn", 
  482.    pos, sz, count, 
  483.    (key >> KP_KEYVAL_SHIFT) & KP_KEYVAL_MASK,
  484.    index,
  485.    entry.m_int64);
  486.     return true;
  487.   }
  488.   case ConfigValues::InvalidType:
  489.   default:
  490.     return false;
  491.   }
  492.   return false;
  493. }
  495. void
  496. ConfigValuesFactory::put(const ConfigValues & cfg){
  497.   
  498.   Uint32 curr = m_currentSection;
  499.   m_currentSection = 0;
  501.   ConfigValues::Entry tmp;
  502.   for(Uint32 i = 0; i < 2 * cfg.m_size; i += 2){
  503.     if(cfg.m_values[i] != CFV_KEY_FREE){
  504.       tmp.m_key = cfg.m_values[i];
  505.       cfg.getByPos(i, &tmp);
  506.       put(tmp);
  507.     }
  508.   }
  510.   m_currentSection = curr;
  511. }
  513. ConfigValues *
  514. ConfigValuesFactory::extractCurrentSection(const ConfigValues::ConstIterator & cfg){
  515.   ConfigValuesFactory * fac = new ConfigValuesFactory(20, 20);
  516.   Uint32 curr = cfg.m_currentSection;
  517.  
  518.   ConfigValues::Entry tmp;
  519.   for(Uint32 i = 0; i < 2 * cfg.m_cfg.m_size; i += 2){
  520.     Uint32 keypart = cfg.m_cfg.m_values[i];
  521.     const Uint32 sec = keypart & (KP_SECTION_MASK << KP_SECTION_SHIFT);
  522.     const Uint32 key = keypart & KP_KEYVAL_MASK;
  523.     if(sec == curr && key != CFV_KEY_PARENT){
  524.       tmp.m_key = cfg.m_cfg.m_values[i];
  525.       cfg.m_cfg.getByPos(i, &tmp);
  526.       tmp.m_key = key;
  527.       fac->put(tmp);
  528.     }
  529.   }
  530.   
  531.   ConfigValues * ret = fac->m_cfg;
  532.   delete fac;
  533.   return ret;
  534. }
  536. ConfigValues *
  537. ConfigValuesFactory::getConfigValues(){
  538.   ConfigValues * ret = m_cfg;
  539.   m_cfg = create(10, 10);
  540.   return ret;
  541. }
  543. static int
  544. mod4(unsigned int i){
  545.   int res = i + (4 - (i % 4));
  546.   return res;
  547. }
  549. Uint32
  550. ConfigValues::getPackedSize() const {
  552.   Uint32 size = 0;
  553.   for(Uint32 i = 0; i < 2 * m_size; i += 2){
  554.     Uint32 key = m_values[i];
  555.     if(key != CFV_KEY_FREE){
  556.       switch(::getTypeOf(key)){
  557.       case IntType:
  558.       case SectionType:
  559. size += 8;
  560. break;
  561.       case Int64Type:
  562. size += 12;
  563. break;
  564.       case StringType:
  565. size += 8; // key + len
  566. size += mod4(strlen(* getString(m_values[i+1])) + 1);
  567. break;
  568.       case InvalidType:
  569.       default:
  570. abort();
  571.       }
  572.     }
  573.   }
  575.   return size + sizeof(Magic) + 4; // checksum also
  576. }
  578. Uint32
  579. ConfigValues::pack(void * _dst, Uint32 _len) const {
  580.   Uint32 i;
  581.   char * dst = (char*)_dst;
  582.   memcpy(dst, Magic, sizeof(Magic)); dst += sizeof(Magic);
  584.   for(i = 0; i < 2 * m_size; i += 2){
  585.     Uint32 key = m_values[i];
  586.     Uint32 val = m_values[i+1];
  587.     if(key != CFV_KEY_FREE){
  588.       switch(::getTypeOf(key)){
  589.       case IntType:
  590.       case SectionType:
  591. * (Uint32*)dst = htonl(key); dst += 4;
  592. * (Uint32*)dst = htonl(val); dst += 4;
  593. break;
  594.       case Int64Type:{
  595. Uint64 i64 = * get64(val); 
  596. Uint32 hi = (i64 >> 32);
  597. Uint32 lo = (i64 & 0xFFFFFFFF);
  598. * (Uint32*)dst = htonl(key); dst += 4;
  599. * (Uint32*)dst = htonl(hi); dst += 4;
  600. * (Uint32*)dst = htonl(lo); dst += 4;
  601.       }
  602. break;
  603.       case StringType:{
  604. const char * str = * getString(val);
  605. Uint32 len = strlen(str) + 1;
  606. * (Uint32*)dst = htonl(key); dst += 4;
  607. * (Uint32*)dst = htonl(len); dst += 4;
  608. memcpy(dst, str, len); 
  609. memset(dst+len, 0, mod4(len) - len);
  610. dst += mod4(len);
  611.       }
  612. break;
  613.       case InvalidType:
  614.       default:
  615. abort();
  616.       }
  617.     }
  618.   }
  620.   const Uint32 * sum = (Uint32*)_dst;
  621.   const Uint32 len = ((Uint32*)dst) - sum;
  622.   Uint32 chk = 0;
  623.   for(i = 0; i<len; i++){
  624.     chk ^= htonl(sum[i]);
  625.   }
  627.   * (Uint32*)dst = htonl(chk); dst += 4;
  628.   return 4 * (len + 1);
  629. }
  631. bool
  632. ConfigValuesFactory::unpack(const void * _src, Uint32 len){
  634.   if(len < sizeof(Magic) + 4){
  635.     DEBUG abort();
  636.     return false;
  637.   }
  639.   if(memcmp(_src, Magic, sizeof(Magic)) != 0){
  640.     DEBUG abort();
  641.     return false;
  642.   }
  644.   const char * src = (const char *)_src;
  646.   {
  647.     Uint32 len32 = (len >> 2);
  648.     const Uint32 * tmp = (const Uint32*)_src;
  649.     Uint32 chk = 0;
  650.     for(Uint32 i = 0; (i+1)<len32; i++){
  651.       chk ^= ntohl(tmp[i]);
  652.     }
  654.     if(chk != ntohl(tmp[len32-1])){
  655.       DEBUG abort();
  656.       return false;
  657.     }
  658.   }
  660.   const char * end = src + len - 4;
  661.   src += sizeof(Magic);
  662.  
  663.   ConfigValues::Entry entry;
  664.   while(end - src > 4){
  665.     Uint32 tmp = ntohl(* (const Uint32 *)src); src += 4;
  666.     entry.m_key = tmp  & KP_MASK;
  667.     entry.m_type = ::getTypeOf(tmp);
  668.     switch(entry.m_type){
  669.     case ConfigValues::IntType:
  670.     case ConfigValues::SectionType:
  671.       entry.m_int = ntohl(* (const Uint32 *)src); src += 4;
  672.       break;
  673.     case ConfigValues::Int64Type:{
  674.       Uint64 hi = ntohl(* (const Uint32 *)src); src += 4;
  675.       Uint64 lo = ntohl(* (const Uint32 *)src); src += 4;
  676.       entry.m_int64 = (hi <<32) | lo;
  677.     }
  678.       break;
  679.     case ConfigValues::StringType:{
  680.       Uint32 s_len = ntohl(* (const Uint32 *)src); src += 4;
  681.       size_t s_len2 = strlen((const char*)src);
  682.       if(s_len2 + 1 != s_len){
  683. DEBUG abort();
  684. return false;
  685.       }
  687.       entry.m_string = (const char*)src; src+= mod4(s_len);
  688.     }
  689.       break;
  690.     case ConfigValues::InvalidType:
  691.     default:
  692.       DEBUG abort();
  693.       return false;
  694.     }
  695.     if(!put(entry)){
  696.       DEBUG abort();
  697.       return false;
  698.     }
  699.   }
  700.   if(src != end){
  701.     DEBUG abort();
  702.     return false;
  703.   }
  704.   return true;
  705. }
  707. #ifdef __TEST_CV_HASH_HPP
  709. int
  710. main(void){
  711.   srand(time(0));
  712.   for(int t = 0; t<100; t++){
  713.     const size_t len = directory(rand() % 1000);
  715.     printf("size = %dn", len);
  716.     unsigned * buf = new unsigned[len];
  717.     for(size_t key = 0; key<len; key++){
  718.       Uint32 p = hash(key, len);
  719.       for(size_t j = 0; j<len; j++){
  720. buf[j] = p;
  721. p = nextHash(key, len, p, j+1);
  722.       }
  723.     
  724.       for(size_t j = 0; j<len; j++){
  725. Uint32 pos = buf[j];
  726. int unique = 0;
  727. for(size_t k = j + 1; k<len; k++){
  728.   if(pos == buf[k]){
  729.     if(unique > 0)
  730.       printf("size=%d key=%d pos(%d)=%d buf[%d]=%dn", len, key, j, pos, k, buf[k]);
  731.     unique ++;
  732.   }
  733. }
  734. if(unique > 1){
  735.   printf("key = %d size = %d not uniqe!!n", key, len);
  736.   for(size_t k = 0; k<len; k++){
  737.     printf("%d ", buf[k]);
  738.   }
  739.   printf("n");
  740. }
  741.       }
  742.     }
  743.     delete[] buf;
  744.   }
  745.   return 0;
  746. }
  748. #endif