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

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

MySQL数据库

开发平台：

Visual C++

SimpleProperties.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. #include <ndb_global.h>
  18. #include <SimpleProperties.hpp>
  19. #include <NdbOut.hpp>
  20. #include <NdbTCP.h>
  21. #include <UtilBuffer.hpp>
  23. bool
  24. SimpleProperties::Writer::first(){
  25.   return reset();
  26. }
  28. bool 
  29. SimpleProperties::Writer::add(Uint16 key, Uint32 value){
  30.   Uint32 head = Uint32Value;  
  31.   head <<= 16;
  32.   head += key;
  33.   if(!putWord(htonl(head)))
  34.     return false;
  35.   
  36.   return putWord(htonl(value));
  37. }
  39. bool
  40. SimpleProperties::Writer::add(Uint16 key, const char * value){
  41.   Uint32 head = StringValue;
  42.   head <<= 16;
  43.   head += key;
  44.   if(!putWord(htonl(head)))
  45.     return false;
  46.   Uint32 strLen = strlen(value) + 1; // Including NULL-byte
  47.   if(!putWord(htonl(strLen)))
  48.     return false;
  49.   
  50.   const Uint32 valLen = (strLen + 3) / 4;
  51.   return putWords((Uint32*)value, valLen);
  52. }
  54. bool
  55. SimpleProperties::Writer::add(Uint16 key, const void* value, int len){
  56.   Uint32 head = BinaryValue;
  57.   head <<= 16;
  58.   head += key;
  59.   if(!putWord(htonl(head)))
  60.     return false;
  61.   if(!putWord(htonl(len)))
  62.     return false;
  63.   
  64.   const Uint32 valLen = (len + 3) / 4;
  65.   return putWords((Uint32*)value, valLen);
  66. }
  68. SimpleProperties::Reader::Reader(){
  69.   m_itemLen = 0;
  70. }
  72. bool 
  73. SimpleProperties::Reader::first(){
  74.   reset();
  75.   m_itemLen = 0;
  76.   return readValue();
  77. }
  79. bool
  80. SimpleProperties::Reader::next(){
  81.   return readValue();
  82. }
  83.     
  84. bool
  85. SimpleProperties::Reader::valid() const {
  86.   return m_type != InvalidValue;
  87. }
  89. Uint16
  90. SimpleProperties::Reader::getKey() const{
  91.   return m_key;
  92. }
  94. Uint16
  95. SimpleProperties::Reader::getValueLen() const {
  96.   switch(m_type){
  97.   case Uint32Value:
  98.     return 4;
  99.   case StringValue:
  100.   case BinaryValue:
  101.     return m_strLen;
  102.   case InvalidValue:
  103.     return 0;
  104.   }
  105.   return 0;
  106. }
  108. SimpleProperties::ValueType
  109. SimpleProperties::Reader::getValueType() const {
  110.   return m_type;
  111. }
  112.     
  113. Uint32
  114. SimpleProperties::Reader::getUint32() const {
  115.   return m_ui32_value;
  116. }
  118. char * 
  119. SimpleProperties::Reader::getString(char * dst) const {
  120.   if(peekWords((Uint32*)dst, m_itemLen))
  121.     return dst;
  122.   return 0;
  123. }
  125. bool
  126. SimpleProperties::Reader::readValue(){
  127.   if(!step(m_itemLen)){
  128.     m_type = InvalidValue;
  129.     return false;
  130.   }
  131.   
  132.   Uint32 tmp;
  133.   if(!getWord(&tmp)){
  134.     m_type = InvalidValue;
  135.     return false;
  136.   }
  138.   tmp = ntohl(tmp);
  139.   m_key = tmp & 0xFFFF;
  140.   m_type = (SimpleProperties::ValueType)(tmp >> 16);
  141.   switch(m_type){
  142.   case Uint32Value:
  143.     m_itemLen = 1;
  144.     if(!peekWord(&m_ui32_value))
  145.       return false;
  146.     m_ui32_value = ntohl(m_ui32_value);
  147.     return true;
  148.   case StringValue:
  149.   case BinaryValue:
  150.     if(!getWord(&tmp))
  151.       return false;
  152.     m_strLen = ntohl(tmp);
  153.     m_itemLen = (m_strLen + 3)/4;
  154.     return true;
  155.   default:
  156.     m_itemLen = 0;
  157.     m_type = InvalidValue;
  158.     return false;
  159.   }
  160. }
  162. SimpleProperties::UnpackStatus 
  163. SimpleProperties::unpack(Reader & it, void * dst, 
  164.  const SP2StructMapping _map[], Uint32 mapSz,
  165.  bool ignoreMinMax,
  166.  bool ignoreUnknownKeys){
  167.   do {
  168.     if(!it.valid())
  169.       break;
  170.     
  171.     bool found = false;
  172.     Uint16 key = it.getKey();
  173.     for(Uint32 i = 0; i<mapSz; i++){
  174.       if(key == _map[i].Key){
  175. found = true;
  176. if(_map[i].Type == InvalidValue)
  177.   return Break;
  178. if(_map[i].Type != it.getValueType())
  179.   return TypeMismatch;
  181. char * _dst = (char *)dst;
  182. _dst += _map[i].Offset;
  184. switch(it.getValueType()){
  185. case Uint32Value:{
  186.   const Uint32 val = it.getUint32();
  187.   if(!ignoreMinMax){
  188.     if(val < _map[i].minValue)
  189.       return ValueTooLow;
  190.     if(val > _map[i].maxValue)
  191.       return ValueTooHigh;
  192.   }
  193.   * ((Uint32 *)_dst) = val;
  194.   break;
  195.         }
  196. case BinaryValue:
  197.         case StringValue:{
  198.   unsigned len = it.getValueLen();
  199.   if(len < _map[i].minValue)
  200.     return ValueTooLow;
  201.   if(len > _map[i].maxValue)
  202.     return ValueTooHigh;
  203.           it.getString(_dst);
  204.           break;
  205. }
  206. default:
  207.   abort();
  208. }
  209. break;
  210.       }
  211.     }
  212.     if(!found && !ignoreUnknownKeys)
  213.       return UnknownKey;
  214.   } while(it.next());
  215.   
  216.   return Eof;
  217. }
  219. SimpleProperties::UnpackStatus 
  220. SimpleProperties::pack(Writer & it, const void * __src, 
  221.        const SP2StructMapping _map[], Uint32 mapSz,
  222.        bool ignoreMinMax){
  224.   const char * _src = (const char *)__src;
  226.   for(Uint32 i = 0; i<mapSz; i++){
  227.     bool ok = false;
  228.     const char * src = _src + _map[i].Offset;
  229.     switch(_map[i].Type){
  230.     case SimpleProperties::InvalidValue:
  231.       ok = true;
  232.       break;
  233.     case SimpleProperties::Uint32Value:{
  234.       Uint32 val = * ((Uint32*)src);
  235.       if(!ignoreMinMax){
  236. if(val < _map[i].minValue)
  237.   return ValueTooLow;
  238. if(val > _map[i].maxValue)
  239.   return ValueTooHigh;
  240.       }
  241.       ok = it.add(_map[i].Key, val);
  242.     }
  243.       break;
  244.     case SimpleProperties::BinaryValue:{
  245.       const char * src_len = _src + _map[i].Length_Offset;
  246.       Uint32 len = *((Uint32*)src_len);
  247.       if(!ignoreMinMax){
  248. if(len == _map[i].maxValue)
  249.   return ValueTooHigh;
  250.       }
  251.       ok = it.add(_map[i].Key, src, len);
  252.       break;
  253.     }
  254.     case SimpleProperties::StringValue:
  255.       if(!ignoreMinMax){
  256. size_t len = strlen(src);
  257. if(len == _map[i].maxValue)
  258.   return ValueTooHigh;
  259.       }
  260.       ok = it.add(_map[i].Key, src);
  261.       break;
  262.     }
  263.     if(!ok)
  264.       return OutOfMemory;
  265.   }
  266.   
  267.   return Eof;
  268. }
  270. void
  271. SimpleProperties::Reader::printAll(NdbOut& ndbout){
  272.   char tmp[1024];
  273.   for(first(); valid(); next()){
  274.     switch(getValueType()){
  275.     case SimpleProperties::Uint32Value:
  276.       ndbout << "Key: " << getKey()
  277.              << " value(" << getValueLen() << ") : " 
  278.              << getUint32() << endl;
  279.       break;
  280.     case SimpleProperties::BinaryValue:
  281.     case SimpleProperties::StringValue:
  282.       if(getValueLen() < 1024){
  283. getString(tmp);
  284. ndbout << "Key: " << getKey()
  285.        << " value(" << getValueLen() << ") : " 
  286.        << """ << tmp << """ << endl;
  287.       } else {
  288. ndbout << "Key: " << getKey()
  289.        << " value(" << getValueLen() << ") : " 
  290.        << """ << "<TOO LONG>" << """ << endl;
  292.       }
  293.       break;
  294.     default:
  295.       ndbout << "Unknown type for key: " << getKey() 
  296.              << " type: " << (Uint32)getValueType() << endl;
  297.     }
  298.   }
  299. }
  301. SimplePropertiesLinearReader::SimplePropertiesLinearReader
  302. (const Uint32 * src, Uint32 len){
  303.   m_src = src;
  304.   m_len = len;
  305.   m_pos = 0;
  306.   first();
  307. }
  309. void 
  310. SimplePropertiesLinearReader::reset() { 
  311.   m_pos = 0;
  312. }
  314. bool 
  315. SimplePropertiesLinearReader::step(Uint32 len){
  316.   m_pos += len;
  317.   return m_pos < m_len;
  318. }
  319.   
  320. bool
  321. SimplePropertiesLinearReader::getWord(Uint32 * dst) { 
  322.   if(m_pos<m_len){
  323.     * dst = m_src[m_pos++];
  324.     return true;
  325.   } 
  326.   return false;
  327. }
  329. bool 
  330. SimplePropertiesLinearReader::peekWord(Uint32 * dst) const {
  331.   if(m_pos<m_len){
  332.     * dst = m_src[m_pos];
  333.     return true;
  334.   } 
  335.   return false;
  336. }
  338. bool 
  339. SimplePropertiesLinearReader::peekWords(Uint32 * dst, Uint32 len) const {
  340.   if(m_pos + len <= m_len){
  341.     memcpy(dst, &m_src[m_pos], 4 * len);
  342.     return true;
  343.   }
  344.   return false;
  345. }
  347. LinearWriter::LinearWriter(Uint32 * src, Uint32 len){
  348.   m_src = src;
  349.   m_len = len;
  350.   reset();
  351. }
  353. bool LinearWriter::reset() { m_pos = 0; return m_len > 0;}
  355. bool 
  356. LinearWriter::putWord(Uint32 val){
  357.   if(m_pos < m_len){
  358.     m_src[m_pos++] = val;
  359.     return true;
  360.   }
  361.   return false;
  362. }
  364. bool 
  365. LinearWriter::putWords(const Uint32 * src, Uint32 len){
  366.   if(m_pos + len <= m_len){
  367.     memcpy(&m_src[m_pos], src, 4 * len);
  368.     m_pos += len;
  369.     return true;
  370.   }
  371.   return false;
  372. }
  374. Uint32
  375. LinearWriter::getWordsUsed() const { return m_pos;}
  377. UtilBufferWriter::UtilBufferWriter(UtilBuffer & b)
  378.   : m_buf(b)
  379. {
  380.   reset();
  381. }
  383. bool UtilBufferWriter::reset() { m_buf.clear(); return true;}
  385. bool 
  386. UtilBufferWriter::putWord(Uint32 val){
  387.   return (m_buf.append(&val, 4) == 0);
  388. }
  390. bool 
  391. UtilBufferWriter::putWords(const Uint32 * src, Uint32 len){
  392.   return (m_buf.append(src, 4 * len) == 0);
  393. }
  395. Uint32
  396. UtilBufferWriter::getWordsUsed() const { return m_buf.length() / 4;}
  398. #if 0
  399. LinearPagesReader::LinearPagesReader(const Uint32 * base, 
  400.      Uint32 pageSize, 
  401.      Uint32 headerSize,
  402.      Uint32 noOfPages, 
  403.      Uint32 len){
  404.   m_base = base;
  405.   m_pageSz = pageSize;
  406.   m_noOfPages = noOfPages;
  407.   m_pageHeaderSz = headerSize;
  408.   m_len = len;
  409.   reset();
  410. }
  412. void 
  413. LinearPagesReader::reset() { m_pos = 0;}
  415. bool 
  416. LinearPagesReader::step(Uint32 len){
  417.   m_pos += len;
  418.   return m_pos < m_len;
  419. }
  421. bool 
  422. LinearPagesReader::getWord(Uint32 * dst) { 
  423.   if(m_pos<m_len){
  424.     * dst = m_base[getPos(m_pos++)];
  425.     return true;
  426.   } 
  427.   return false;
  428. }
  430. bool 
  431. LinearPagesReader::peekWord(Uint32 * dst) const {
  432.   if(m_pos<m_len){
  433.     * dst = m_base[getPos(m_pos)];
  434.     return true;
  435.   } 
  436.   return false;
  437. }
  439. bool 
  440. LinearPagesReader::peekWords(Uint32 * dst, Uint32 len) const {
  441.   if(m_pos + len <= m_len){
  442.     for(Uint32 i = 0; i<len; i++)
  443.       * (dst + i) = m_base[getPos(m_pos + i)];
  444.     return true;
  445.   }
  446.   return false;
  447. }
  449. Uint32 
  450. LinearPagesReader::getPos(Uint32 pos) const {
  451.   const Uint32 sz = (m_pageSz - m_pageHeaderSz);
  452.   Uint32 no = pos / sz;
  453.   Uint32 in = pos % sz;
  454.   return no * m_pageSz + m_pageHeaderSz + in;
  455. }
  457. LinearPagesWriter::LinearPagesWriter(Uint32 * base, 
  458.      Uint32 pageSize, 
  459.      Uint32 noOfPages, 
  460.      Uint32 headerSize){
  461.   m_base = base;
  462.   m_pageSz = pageSize;
  463.   m_noOfPages = noOfPages;
  464.   m_pageHeaderSz = headerSize;
  465.   m_len = noOfPages * (pageSize - headerSize);
  466.   reset();
  467. }
  469. bool 
  470. LinearPagesWriter::putWord(Uint32 val){
  471.   if(m_pos < m_len){
  472.     m_base[getPos(m_pos++)] = val;
  473.     return true;
  474.   }
  475.   return false;
  476. }
  478. bool 
  479. LinearPagesWriter::putWords(const Uint32 * src, Uint32 len){
  480.   if(m_pos + len <= m_len){
  481.     for(Uint32 i = 0; i<len; i++)
  482.       m_base[getPos(m_pos++)] = src[i];
  483.     return true;
  484.   }
  485.   return false;
  486. }
  488. #if 0
  489. Uint32 
  490. LinearPagesWriter::getWordsUsed() const { 
  491.   return getPos(m_pos);
  492. }
  493. #endif
  495. Uint32 
  496. LinearPagesWriter::getPagesUsed() const { 
  497.   return m_pos / (m_pageSz - m_pageHeaderSz);
  498. }
  500. Uint32 
  501. LinearPagesWriter::getPos(Uint32 pos) const {
  502.   const Uint32 sz = (m_pageSz - m_pageHeaderSz);
  503.   Uint32 no = pos / sz;
  504.   Uint32 in = pos % sz;
  505.   return no * m_pageSz + m_pageHeaderSz + in;
  506. }
  507. #endif