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

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

MySQL数据库

开发平台：

Visual C++

Properties.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>
  19. #include <Properties.hpp>
  21. #include <NdbTCP.h>
  22. #include <NdbOut.hpp>
  24. static
  25. char * f_strdup(const char * s){
  26.   if(!s) return 0;
  27.   return strdup(s);
  28. }
  30. /**
  31.  * Note has to be a multiple of 4 bytes
  32.  */
  33. const char Properties::version[] = { 2, 0, 0, 1, 1, 1, 1, 4 };
  34. const char Properties::delimiter = ':';
  36. /**
  37.  * PropertyImpl
  38.  */
  39. struct PropertyImpl{
  40.   PropertiesType valueType;
  41.   const char * name;
  42.   void * value;
  44.   ~PropertyImpl();
  45.   PropertyImpl(const char * name, Uint32 value);
  46.   PropertyImpl(const char * name, Uint64 value);
  47.   PropertyImpl(const char * name, const char * value);
  48.   PropertyImpl(const char * name, const Properties * value);
  49.   
  50.   static PropertyImpl * copyPropertyImpl(const PropertyImpl &);
  51. };
  53. /**
  54.  * PropertiesImpl
  55.  */
  56. class PropertiesImpl {
  57.   PropertiesImpl(const PropertiesImpl &);           // Not implemented
  58.   PropertiesImpl& operator=(const PropertiesImpl&); // Not implemented
  59. public:
  60.   PropertiesImpl(Properties *, bool case_insensitive);
  61.   PropertiesImpl(Properties *, const PropertiesImpl &);
  62.   ~PropertiesImpl();
  64.   Properties * properties;
  65.   
  66.   Uint32 size;
  67.   Uint32 items;
  68.   PropertyImpl **content;
  70.   bool m_insensitive;
  71.   int (* compare)(const char *s1, const char *s2);
  72.   
  73.   void setCaseInsensitiveNames(bool value);
  74.   void grow(int sizeToAdd);
  75.   
  76.   PropertyImpl * get(const char * name) const;
  77.   PropertyImpl * put(PropertyImpl *);
  78.   void remove(const char * name);
  79.   
  80.   Uint32 getPackedSize(Uint32 pLen) const;
  81.   bool pack(Uint32 *& buf, const char * prefix, Uint32 prefixLen) const;
  82.   bool unpack(const Uint32 * buf, Uint32 &bufLen, Properties * top, int items);
  83.   
  84.   Uint32 getTotalItems() const;
  86.   void setErrno(Uint32 pErr, Uint32 osErr = 0){
  87.     properties->setErrno(pErr, osErr);
  88.   }
  90.   const char * getProps(const char * name, const PropertiesImpl ** impl) const;
  91.   const char * getPropsPut(const char * name, PropertiesImpl ** impl);
  92. };
  94. /**
  95.  * Methods for Property
  96.  */
  97. Property::Property(const char * name, Uint32 value){
  98.   impl = new PropertyImpl(name, value);
  99. }
  101. Property::Property(const char * name, const char * value){
  102.   impl = new PropertyImpl(name, value);
  103. }
  105. Property::Property(const char * name, const class Properties * value){
  106.   impl = new PropertyImpl(name, value);
  108.   ((Properties*)impl->value)->setCaseInsensitiveNames(value->getCaseInsensitiveNames());
  109. }
  111. Property::~Property(){
  112.   delete impl;
  113. }
  115. /**
  116.  * Methods for Properties
  117.  */
  118. Properties::Properties(bool case_insensitive){
  119.   parent = 0;
  120.   impl = new PropertiesImpl(this, case_insensitive);
  121. }
  123. Properties::Properties(const Properties & org){
  124.   parent = 0;
  125.   impl = new PropertiesImpl(this, * org.impl);
  126. }
  128. Properties::Properties(const Property * anArray, int arrayLen){
  129.   impl = new PropertiesImpl(this, false);
  131.   put(anArray, arrayLen);
  132. }
  134. Properties::~Properties(){
  135.   clear();
  136.   delete impl;
  137. }
  139. void
  140. Properties::put(const Property * anArray, int arrayLen){
  141.   if(anArray == 0)
  142.     return;
  143.   for(int i = 0; i<arrayLen; i++)
  144.     impl->put(anArray[i].impl);
  145. }
  147. template <class T>
  148. bool
  149. put(PropertiesImpl * impl, const char * name, T value, bool replace){
  150.   if(name == 0){
  151.     impl->setErrno(E_PROPERTIES_INVALID_NAME);
  152.     return false;
  153.   }
  155.   PropertiesImpl * tmp = 0;
  156.   const char * short_name = impl->getPropsPut(name, &tmp);
  158.   if(tmp == 0){
  159.     impl->setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  160.     return false;
  161.   }
  162.   
  163.   if(tmp->get(short_name) != 0){
  164.     if(replace){
  165.       tmp->remove(short_name);
  166.     } else {
  167.       impl->setErrno(E_PROPERTIES_ELEMENT_ALREADY_EXISTS);
  168.       return false;
  169.     }
  170.   }
  171.   return tmp->put(new PropertyImpl(short_name, value));  
  172. }
  175. bool
  176. Properties::put(const char * name, Uint32 value, bool replace){
  177.   return ::put(impl, name, value, replace);
  178. }
  180. bool
  181. Properties::put64(const char * name, Uint64 value, bool replace){
  182.   return ::put(impl, name, value, replace);
  183. }
  185. bool 
  186. Properties::put(const char * name, const char * value, bool replace){
  187.   return ::put(impl, name, value, replace);
  188. }
  190. bool 
  191. Properties::put(const char * name, const Properties * value, bool replace){
  192.   return ::put(impl, name, value, replace);
  193. }
  195. bool
  196. Properties::getTypeOf(const char * name, PropertiesType * type) const {
  197.   PropertyImpl * nvp = impl->get(name);
  198.   if(nvp == 0){
  199.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  200.     return false;
  201.   }
  202.   setErrno(E_PROPERTIES_OK);
  203.   * type = nvp->valueType;
  204.   return true;
  205. }
  207. bool
  208. Properties::contains(const char * name) const {
  209.   PropertyImpl * nvp = impl->get(name);
  210.   return nvp != 0;
  211. }
  213. bool
  214. Properties::get(const char * name, Uint32 * value) const {
  215.   PropertyImpl * nvp = impl->get(name);
  216.   if(nvp == 0){
  217.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  218.     return false;
  219.   }
  220.   
  221.   if(nvp->valueType == PropertiesType_Uint32){
  222.     * value = * (Uint32 *)nvp->value;
  223.     setErrno(E_PROPERTIES_OK);
  224.     return true;
  225.   }
  227.   if(nvp->valueType == PropertiesType_Uint64){
  228.     Uint64 tmp = * (Uint64 *)nvp->value;
  229.     Uint64 max = 1; max <<= 32;
  230.     if(tmp < max){
  231.       * value = (Uint32)tmp;
  232.       setErrno(E_PROPERTIES_OK);
  233.       return true;
  234.     }
  235.   }
  236.   setErrno(E_PROPERTIES_INVALID_TYPE);
  237.   return false;
  238. }
  240. bool
  241. Properties::get(const char * name, Uint64 * value) const {
  242.   PropertyImpl * nvp = impl->get(name);
  243.   if(nvp == 0){
  244.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  245.     return false;
  246.   }
  247.   
  248.   if(nvp->valueType == PropertiesType_Uint32){
  249.     Uint32 tmp = * (Uint32 *)nvp->value;
  250.     * value = (Uint64)tmp;
  251.     setErrno(E_PROPERTIES_OK);
  252.     return true;
  253.   }
  255.   if(nvp->valueType == PropertiesType_Uint64){
  256.     * value = * (Uint64 *)nvp->value;
  257.     setErrno(E_PROPERTIES_OK);
  258.     return true;
  259.   }
  260.   setErrno(E_PROPERTIES_INVALID_TYPE);
  261.   return false;
  262. }
  264. bool
  265. Properties::get(const char * name, const char ** value) const {
  266.   PropertyImpl * nvp = impl->get(name);
  267.   if(nvp == 0){
  268.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  269.     return false;
  270.   }
  272.   if(nvp->valueType == PropertiesType_char){
  273.     * value = (const char *)nvp->value;
  274.     setErrno(E_PROPERTIES_OK);
  275.     return true;
  276.   }
  277.   setErrno(E_PROPERTIES_INVALID_TYPE);
  278.   return false;
  279. }
  281. bool
  282. Properties::get(const char * name, BaseString& value) const {
  283.   const char *tmp = "";
  284.   bool ret;
  285.   ret = get(name, &tmp);
  286.   value.assign(tmp);
  287.   return ret;
  288. }
  290. bool
  291. Properties::get(const char * name, const Properties ** value) const {
  292.   PropertyImpl * nvp = impl->get(name);
  293.   if(nvp == 0){
  294.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  295.     return false;
  296.   }
  297.   if(nvp->valueType == PropertiesType_Properties){
  298.     * value = (const Properties *)nvp->value;
  299.     setErrno(E_PROPERTIES_OK);
  300.     return true;
  301.   }
  302.   setErrno(E_PROPERTIES_INVALID_TYPE);
  303.   return false;
  304. }
  306. bool
  307. Properties::getCopy(const char * name, char ** value) const {
  308.   PropertyImpl * nvp = impl->get(name);
  309.   if(nvp == 0){
  310.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  311.     return false;
  312.   }
  314.   if(nvp->valueType == PropertiesType_char){
  315.     * value = f_strdup((const char *)nvp->value);
  316.     setErrno(E_PROPERTIES_OK);
  317.     return true;
  318.   }
  319.   setErrno(E_PROPERTIES_INVALID_TYPE);
  320.   return false;
  321. }
  323. bool
  324. Properties::getCopy(const char * name, Properties ** value) const {
  325.   PropertyImpl * nvp = impl->get(name);
  326.   if(nvp == 0){
  327.     setErrno(E_PROPERTIES_NO_SUCH_ELEMENT);
  328.     return false;
  329.   }
  330.   
  331.   if(nvp->valueType == PropertiesType_Properties){
  332.     * value = new Properties(* (const Properties *)nvp->value);
  333.     setErrno(E_PROPERTIES_OK);
  334.     return true;
  335.   }
  336.   setErrno(E_PROPERTIES_INVALID_TYPE);
  337.   return false;
  338. }
  340. void 
  341. Properties::clear(){
  342.   while(impl->items > 0)
  343.     impl->remove(impl->content[0]->name);
  344. }
  346. void
  347. Properties::remove(const char * name) {
  348.   impl->remove(name);
  349. }
  351. void
  352. Properties::print(FILE * out, const char * prefix) const{
  353.   char buf[1024];
  354.   if(prefix == 0)
  355.     buf[0] = 0;
  356.   else
  357.     strncpy(buf, prefix, 1024);
  358.   
  359.   for(unsigned int i = 0; i<impl->items; i++){
  360.     switch(impl->content[i]->valueType){
  361.     case PropertiesType_Uint32:
  362.       fprintf(out, "%s%s = (Uint32) %dn", buf, impl->content[i]->name,
  363.       *(Uint32 *)impl->content[i]->value);
  364.       break;
  365.     case PropertiesType_Uint64:
  366.       fprintf(out, "%s%s = (Uint64) %lldn", buf, impl->content[i]->name,
  367.       *(Uint64 *)impl->content[i]->value);
  368.       break;
  369.     case PropertiesType_char:
  370.       fprintf(out, "%s%s = (char*) "%s"n", buf, impl->content[i]->name,
  371.       (char *)impl->content[i]->value);
  372.       break;
  373.     case PropertiesType_Properties:
  374.       char buf2 [1024];
  375.       BaseString::snprintf(buf2, sizeof(buf2), "%s%s%c",buf, impl->content[i]->name, 
  376.       Properties::delimiter);
  377.       ((Properties *)impl->content[i]->value)->print(out, buf2);
  378.       break;
  379.     }
  380.   }
  381. }
  383. Properties::Iterator::Iterator(const Properties* prop) :
  384.   m_prop(prop),
  385.   m_iterator(0) {
  386. }
  388. const char*
  389. Properties::Iterator::first() {
  390.   m_iterator = 0;
  391.   return next();
  392. }
  394. const char*
  395. Properties::Iterator::next() {
  396.   if (m_iterator < m_prop->impl->items) 
  397.     return m_prop->impl->content[m_iterator++]->name;
  398.   else
  399.     return NULL;
  400. }
  402. Uint32
  403. Properties::getPackedSize() const {
  404.   Uint32 sz = 0;
  405.   
  406.   sz += sizeof(version); // Version id of properties object
  407.   sz += 4;               // No Of Items
  408.   sz += 4;               // Checksum
  410.   return sz + impl->getPackedSize(0);
  411. }
  413. static
  414. Uint32
  415. computeChecksum(const Uint32 * buf, Uint32 words){
  416.   Uint32 sum = 0;
  417.   for(unsigned int i = 0; i<words; i++)
  418.     sum ^= htonl(buf[i]);
  419.   
  420.   return sum;
  421. }
  423. bool
  424. Properties::pack(Uint32 * buf) const {
  425.   Uint32 * bufStart = buf;
  426.   
  427.   memcpy(buf, version, sizeof(version));
  428.   
  429.   // Note that version must be a multiple of 4
  430.   buf += (sizeof(version) / 4); 
  431.   
  432.   * buf = htonl(impl->getTotalItems());
  433.   buf++;
  434.   bool res = impl->pack(buf, "", 0);
  435.   if(!res)
  436.     return res;
  438.   * buf = htonl(computeChecksum(bufStart, (buf - bufStart)));
  440.   return true;
  441. }
  443. bool
  444. Properties::unpack(const Uint32 * buf, Uint32 bufLen){
  445.   const Uint32 * bufStart = buf;
  446.   Uint32 bufLenOrg = bufLen;
  447.   
  448.   if(bufLen < sizeof(version)){
  449.     setErrno(E_PROPERTIES_INVALID_BUFFER_TO_SHORT);
  450.     return false;
  451.   }
  452.   
  453.   if(memcmp(buf, version, sizeof(version)) != 0){
  454.     setErrno(E_PROPERTIES_INVALID_VERSION_WHILE_UNPACKING);
  455.     return false;
  456.   }
  457.   bufLen -= sizeof(version);
  458.   
  459.   // Note that version must be a multiple of 4
  460.   buf += (sizeof(version) / 4); 
  461.   
  462.   if(bufLen < 4){
  463.     setErrno(E_PROPERTIES_INVALID_BUFFER_TO_SHORT);
  464.     return false;
  465.   }
  467.   Uint32 totalItems = ntohl(* buf);
  468.   buf++; bufLen -= 4;
  469.   bool res = impl->unpack(buf, bufLen, this, totalItems);
  470.   if(!res)
  471.     return res;
  473.   Uint32 sum = computeChecksum(bufStart, (bufLenOrg-bufLen)/4);
  474.   if(sum != ntohl(bufStart[(bufLenOrg-bufLen)/4])){
  475.     setErrno(E_PROPERTIES_INVALID_CHECKSUM);
  476.     return false;
  477.   }
  478.   return true;
  479. }
  481. /**
  482.  * Methods for PropertiesImpl
  483.  */
  484. PropertiesImpl::PropertiesImpl(Properties * p, bool case_insensitive){
  485.   this->properties = p;
  486.   items = 0;
  487.   size  = 25;
  488.   content = new PropertyImpl * [size];
  489.   setCaseInsensitiveNames(case_insensitive);
  490. }
  492. PropertiesImpl::PropertiesImpl(Properties * p, const PropertiesImpl & org){
  493.   this->properties = p;
  494.   this->size  = org.size;
  495.   this->items = org.items;
  496.   this->m_insensitive = org.m_insensitive;
  497.   this->compare = org.compare;
  498.   content = new PropertyImpl * [size];
  499.   for(unsigned int i = 0; i<items; i++){
  500.     content[i] = PropertyImpl::copyPropertyImpl(* org.content[i]);
  501.   }
  502. }
  504. PropertiesImpl::~PropertiesImpl(){
  505.   for(unsigned int i = 0; i<items; i++)
  506.     delete content[i];
  507.   delete [] content;
  508. }
  510. void
  511. PropertiesImpl::setCaseInsensitiveNames(bool value){
  512.   m_insensitive = value;
  513.   if(value)
  514.     compare = strcasecmp;
  515.   else
  516.     compare = strcmp;
  517. }
  519. void 
  520. PropertiesImpl::grow(int sizeToAdd){
  521.   PropertyImpl ** newContent = new PropertyImpl * [size + sizeToAdd];
  522.   memcpy(newContent, content, items * sizeof(PropertyImpl *));
  523.   delete [] content;
  524.   content = newContent;
  525.   size   += sizeToAdd;
  526. }
  528. PropertyImpl *
  529. PropertiesImpl::get(const char * name) const {
  530.   const PropertiesImpl * tmp = 0;
  531.   const char * short_name = getProps(name, &tmp);
  532.   if(tmp == 0){
  533.     return 0;
  534.   }
  536.   for(unsigned int i = 0; i<tmp->items; i++) {
  537.     if((* compare)(tmp->content[i]->name, short_name) == 0)
  538.       return tmp->content[i];
  539.   }
  541.   return 0;
  542. }
  544. PropertyImpl *
  545. PropertiesImpl::put(PropertyImpl * nvp){
  546.   if(items == size)
  547.     grow(size);
  548.   content[items] = nvp;
  550.   items ++;
  552.   if(nvp->valueType == PropertiesType_Properties){
  553.     ((Properties*)nvp->value)->parent = properties;
  554.   }
  555.   return nvp;
  556. }
  558. void
  559. PropertiesImpl::remove(const char * name){
  560.   for(unsigned int i = 0; i<items; i++){
  561.     if((* compare)(content[i]->name, name) == 0){
  562.       delete content[i];
  563.       memmove(&content[i], &content[i+1], (items-i-1)*sizeof(PropertyImpl *));
  564.       items --;
  565.       return;
  566.     }
  567.   }
  568. }
  570. Uint32 
  571. PropertiesImpl::getTotalItems() const {
  572.   int ret = 0;
  573.   for(unsigned int i = 0; i<items; i++)
  574.     if(content[i]->valueType == PropertiesType_Properties){
  575.       ret += ((Properties*)content[i]->value)->impl->getTotalItems();
  576.     } else {
  577.       ret ++;
  578.     }
  579.   return ret;
  580. }
  582. const char * 
  583. PropertiesImpl::getProps(const char * name, 
  584.  const PropertiesImpl ** impl) const {
  585.   const char * ret = name;
  586.   const char * tmp = strchr(name, Properties::delimiter);
  587.   if(tmp == 0){
  588.     * impl = this;
  589.     return ret;
  590.   } else {
  591.     Uint32 sz = tmp - name;
  592.     char * tmp2 = (char*)malloc(sz + 1);
  593.     memcpy(tmp2, name, sz);
  594.     tmp2[sz] = 0;
  596.     PropertyImpl * nvp = get(tmp2);
  598.     free(tmp2);
  600.     if(nvp == 0){
  601.       * impl = 0;
  602.       return 0;
  603.     }
  604.     if(nvp->valueType != PropertiesType_Properties){
  605.       * impl = 0;
  606.       return name;
  607.     }
  608.     return ((Properties*)nvp->value)->impl->getProps(tmp+1, impl);
  609.   }
  610. }
  612. const char * 
  613. PropertiesImpl::getPropsPut(const char * name, 
  614.     PropertiesImpl ** impl) {
  615.   const char * ret = name;
  616.   const char * tmp = strchr(name, Properties::delimiter);
  617.   if(tmp == 0){
  618.     * impl = this;
  619.     return ret;
  620.   } else {
  621.     Uint32 sz = tmp - name;
  622.     char * tmp2 = (char*)malloc(sz + 1);
  623.     memcpy(tmp2, name, sz);
  624.     tmp2[sz] = 0;
  625.     
  626.     PropertyImpl * nvp = get(tmp2);
  628.     if(nvp == 0){
  629.       Properties   * tmpP  = new Properties();
  630.       PropertyImpl * tmpPI = new PropertyImpl(tmp2, tmpP);
  631.       PropertyImpl * nvp = put(tmpPI);
  633.       delete tmpP;
  634.       free(tmp2);
  635.       return ((Properties*)nvp->value)->impl->getPropsPut(tmp+1, impl);
  636.     }
  637.     free(tmp2);
  638.     if(nvp->valueType != PropertiesType_Properties){
  639.       * impl = 0;
  640.       return name;
  641.     }
  642.     return ((Properties*)nvp->value)->impl->getPropsPut(tmp+1, impl);
  643.   }
  644. }
  646. int
  647. mod4(unsigned int i){
  648.   int res = i + (4 - (i % 4));
  649.   return res;
  650. }
  652. Uint32
  653. PropertiesImpl::getPackedSize(Uint32 pLen) const {
  654.   Uint32 sz = 0;
  655.   for(unsigned int i = 0; i<items; i++){
  656.     if(content[i]->valueType == PropertiesType_Properties){
  657.       Properties * p = (Properties*)content[i]->value;
  658.       sz += p->impl->getPackedSize(pLen+strlen(content[i]->name)+1);
  659.     } else { 
  660.       sz += 4; // Type
  661.       sz += 4; // Name Len
  662.       sz += 4; // Value Len
  663.       sz += mod4(pLen + strlen(content[i]->name)); // Name
  664.       switch(content[i]->valueType){
  665.       case PropertiesType_char:
  666. sz += mod4(strlen((char *)content[i]->value));
  667. break;
  668.       case PropertiesType_Uint32:
  669. sz += mod4(4);
  670. break;
  671.       case PropertiesType_Uint64:
  672. sz += mod4(8);
  673. break;
  674.       case PropertiesType_Properties:
  675.       default:
  676. assert(0);
  677.       }
  678.     }
  679.   }
  680.   return sz;
  681. }
  683. struct CharBuf {
  684.   char * buffer;
  685.   Uint32 bufLen;
  686.   Uint32 contentLen;
  688.   CharBuf(){
  689.     buffer     = 0;
  690.     bufLen     = 0;
  691.     contentLen = 0;
  692.   }
  694.   ~CharBuf(){
  695.     free(buffer);
  696.   }
  697.   
  698.   void clear() { contentLen = 0;}
  699.   bool add(const char * str, Uint32 strLen){
  700.     if(!expand(contentLen + strLen + 1))
  701.       return false;
  702.     memcpy(&buffer[contentLen], str, strLen);
  703.     contentLen += strLen;
  704.     buffer[contentLen] = 0;
  705.     return true;
  706.   }
  707.   
  708.   bool add(char c){
  709.     return add(&c, 1);
  710.   }
  712.   bool expand(Uint32 newSize){
  713.     if(newSize >= bufLen){
  714.       
  715.       char * tmp = (char*)malloc(newSize + 1024);
  716.       memset(tmp, 0, newSize + 1024);
  717.       if(tmp == 0)
  718. return false;
  719.       if(contentLen > 0)
  720. memcpy(tmp, buffer, contentLen);
  721.       if(buffer != 0)
  722. free(buffer);
  723.       buffer = tmp;
  724.       bufLen = newSize + 1024;
  725.     }
  726.     return true;
  727.   }
  728. };
  730. bool
  731. PropertiesImpl::pack(Uint32 *& buf, const char * prefix, Uint32 pLen) const {
  732.   CharBuf charBuf;
  733.   
  734.   for(unsigned int i = 0; i<items; i++){
  735.     const int strLenName      = strlen(content[i]->name);
  736.     
  737.     if(content[i]->valueType == PropertiesType_Properties){
  738.       charBuf.clear();
  739.       if(!charBuf.add(prefix, pLen)){
  740. properties->setErrno(E_PROPERTIES_ERROR_MALLOC_WHILE_PACKING,
  741.      errno);
  742. return false;
  743.       }
  744.       
  745.       if(!charBuf.add(content[i]->name, strLenName)){
  746. properties->setErrno(E_PROPERTIES_ERROR_MALLOC_WHILE_PACKING,
  747.      errno);
  748. return false;
  749.       }
  751.       if(!charBuf.add(Properties::delimiter)){
  752. properties->setErrno(E_PROPERTIES_ERROR_MALLOC_WHILE_PACKING,
  753.      errno);
  754. return false;
  755.       }
  756.       
  757.       if(!((Properties*)(content[i]->value))->impl->pack(buf, 
  758.  charBuf.buffer,
  759.  charBuf.contentLen)){
  761. return false;
  762.       }
  763.       continue;
  764.     }
  765.     
  766.     Uint32 valLenData  = 0;
  767.     Uint32 valLenWrite = 0;
  768.     Uint32 sz = 4 + 4 + 4 + mod4(pLen + strLenName);
  769.     switch(content[i]->valueType){
  770.     case PropertiesType_Uint32:
  771.       valLenData  = 4;
  772.       break;
  773.     case PropertiesType_Uint64:
  774.       valLenData  = 8;
  775.       break;
  776.     case PropertiesType_char:
  777.       valLenData  = strlen((char *)content[i]->value);
  778.       break;
  779.     case PropertiesType_Properties:
  780.       assert(0);
  781.     }
  782.     valLenWrite = mod4(valLenData);
  783.     sz += valLenWrite;
  784.     
  785.     * (buf + 0) = htonl(content[i]->valueType);
  786.     * (buf + 1) = htonl(pLen + strLenName);
  787.     * (buf + 2) = htonl(valLenData);
  789.     char * valBuf  = (char*)(buf + 3);
  790.     char * nameBuf = (char*)(buf + 3 + (valLenWrite / 4));
  791.     
  792.     memset(valBuf, 0, sz-12);
  794.     switch(content[i]->valueType){
  795.     case PropertiesType_Uint32:
  796.       * (Uint32 *)valBuf = htonl(* (Uint32 *)content[i]->value);
  797.       break;
  798.     case PropertiesType_Uint64:{
  799.       Uint64 val =  * (Uint64 *)content[i]->value;
  800.       Uint32 hi = (val >> 32);
  801.       Uint32 lo = (val & 0xFFFFFFFF);
  802.       * (Uint32 *)valBuf = htonl(hi);
  803.       * (Uint32 *)(valBuf + 4) = htonl(lo);
  804.     }
  805.       break;
  806.     case PropertiesType_char:
  807.       memcpy(valBuf, content[i]->value, strlen((char*)content[i]->value));
  808.       break;
  809.     case PropertiesType_Properties:
  810.       assert(0);
  811.     }
  812.     if(pLen > 0)
  813.       memcpy(nameBuf, prefix, pLen);
  814.     memcpy(nameBuf + pLen, content[i]->name, strLenName);
  815.     
  816.     buf += (sz / 4);
  817.   }
  819.   return true;
  820. }
  822. bool
  823. PropertiesImpl::unpack(const Uint32 * buf, Uint32 &bufLen, Properties * top,
  824.        int _items){
  825.   CharBuf charBuf;
  826.   while(_items > 0){
  827.     Uint32 tmp[3]; 
  828.     
  829.     if(bufLen <= 12){
  830.       top->setErrno(E_PROPERTIES_BUFFER_TO_SMALL_WHILE_UNPACKING);
  831.       return false;
  832.     }
  834.     tmp[0] = ntohl(buf[0]);
  835.     tmp[1] = ntohl(buf[1]);
  836.     tmp[2] = ntohl(buf[2]);
  837.     buf    += 3;
  838.     bufLen -= 12;
  840.     PropertiesType pt   = (PropertiesType)tmp[0];
  841.     Uint32 nameLen      = tmp[1];
  842.     Uint32 valueLen     = tmp[2];
  843.     Uint32 nameLenRead  = mod4(nameLen);
  844.     Uint32 valueLenRead = mod4(valueLen);
  846.     Uint32 sz = nameLenRead + valueLenRead;
  847.     if(bufLen < sz){
  848.       top->setErrno(E_PROPERTIES_BUFFER_TO_SMALL_WHILE_UNPACKING);
  849.       return false;
  850.     }
  852.     if(!charBuf.expand(sz)){
  853.       top->setErrno(E_PROPERTIES_ERROR_MALLOC_WHILE_UNPACKING, errno);
  854.       return false;
  855.     }
  857.     memcpy(charBuf.buffer, buf, sz);
  858.     buf    += (sz / 4);
  859.     bufLen -= sz ;
  861.     char * valBuf  = charBuf.buffer;
  862.     char * nameBuf = charBuf.buffer + valueLenRead;
  863.     
  864.     nameBuf[nameLen] = 0;
  865.     valBuf[valueLen] = 0;
  866.     
  867.     bool res3 = false;
  868.     switch(pt){
  869.     case PropertiesType_Uint32:
  870.       res3 = top->put(nameBuf, ntohl(* (Uint32 *)valBuf), true);
  871.       break;
  872.     case PropertiesType_Uint64:{
  873.       Uint64 hi = ntohl(* (Uint32 *)valBuf);
  874.       Uint64 lo = ntohl(* (Uint32 *)(valBuf + 4));
  875.       res3 = top->put64(nameBuf, (hi << 32) + lo, true);
  876.     }
  877.       break;
  878.     case PropertiesType_char:
  879.       res3 = top->put(nameBuf, valBuf, true);
  880.       break;
  881.     case PropertiesType_Properties:
  882.       assert(0);
  883.     }
  884.     if(!res3){
  885.       return false;
  886.     }
  887.     _items--;
  888.   }
  889.   return true;
  890. }
  892. PropertyImpl::~PropertyImpl(){
  893.   free((char*)name);
  894.   switch(valueType){
  895.   case PropertiesType_Uint32:
  896.     delete (Uint32 *)value;
  897.     break;
  898.   case PropertiesType_Uint64:
  899.     delete (Uint64 *)value;
  900.     break;
  901.   case PropertiesType_char:
  902.     free((char *)value);
  903.     break;
  904.   case PropertiesType_Properties:
  905.     delete (Properties *)value;
  906.     break;
  907.   }
  908. }
  910. PropertyImpl *
  911. PropertyImpl::copyPropertyImpl(const PropertyImpl & org){
  912.   switch(org.valueType){
  913.   case PropertiesType_Uint32:
  914.     return new PropertyImpl(org.name, * (Uint32 *)org.value);
  915.   case PropertiesType_Uint64:
  916.     return new PropertyImpl(org.name, * (Uint64 *)org.value);
  917.     break;
  918.   case PropertiesType_char:
  919.     return new PropertyImpl(org.name, (char *)org.value);
  920.     break;
  921.   case PropertiesType_Properties:
  922.     return new PropertyImpl(org.name, (Properties *)org.value);
  923.     break;
  924.   default:
  925.     assert(0);
  926.   }
  927.   return 0;
  928. }
  930. PropertyImpl::PropertyImpl(const char * _name, Uint32 _value){
  931.   this->name = f_strdup(_name);
  932.   this->value = new Uint32;
  933.   * ((Uint32 *)this->value) = _value;
  934.   this->valueType = PropertiesType_Uint32;
  935. }
  937. PropertyImpl::PropertyImpl(const char * _name, Uint64 _value){
  938.   this->name = f_strdup(_name);
  939.   this->value = new Uint64;
  940.   * ((Uint64 *)this->value) = _value;
  941.   this->valueType = PropertiesType_Uint64;
  942. }
  944. PropertyImpl::PropertyImpl(const char * _name, const char * _value){
  945.   this->name = f_strdup(_name);
  946.   this->value = f_strdup(_value);
  947.   this->valueType = PropertiesType_char;
  949. }
  951. PropertyImpl::PropertyImpl(const char * _name, const Properties * _value){
  952.   this->name = f_strdup(_name);
  953.   this->value = new Properties(* _value);
  954.   this->valueType = PropertiesType_Properties;
  955. }
  957. const Uint32 E_PROPERTIES_OK                                      = 0;
  958. const Uint32 E_PROPERTIES_INVALID_NAME                            = 1;
  959. const Uint32 E_PROPERTIES_NO_SUCH_ELEMENT                         = 2;
  960. const Uint32 E_PROPERTIES_INVALID_TYPE                            = 3;
  961. const Uint32 E_PROPERTIES_ELEMENT_ALREADY_EXISTS                  = 4;
  963. const Uint32 E_PROPERTIES_ERROR_MALLOC_WHILE_PACKING              = 5;
  964. const Uint32 E_PROPERTIES_INVALID_VERSION_WHILE_UNPACKING         = 6;
  965. const Uint32 E_PROPERTIES_INVALID_BUFFER_TO_SHORT                 = 7;
  966. const Uint32 E_PROPERTIES_ERROR_MALLOC_WHILE_UNPACKING            = 8;
  967. const Uint32 E_PROPERTIES_INVALID_CHECKSUM                        = 9;
  968. const Uint32 E_PROPERTIES_BUFFER_TO_SMALL_WHILE_UNPACKING         = 10;
  970. /**
  971.  * These are methods that used to be inline
  972.  *
  973.  * But Diab 4.1f could not compile -release with to many inlines
  974.  */
  975. void
  976. Properties::setErrno(Uint32 pErr, Uint32 osErr) const {
  977.   if(parent != 0){
  978.     parent->setErrno(pErr, osErr);
  979.     return ;
  980.   }
  981.   
  982.   /**
  983.    * propErrno & osErrno used to be mutable,
  984.    * but diab didn't know what mutable meant.
  985.    */
  986.   *((Uint32*)&propErrno) = pErr;
  987.   *((Uint32*)&osErrno)   = osErr;
  988. }
  990. /**
  991.  * Inlined get/put(name, no, ...) - methods
  992.  */
  993.  
  994. bool
  995. Properties::put(const char * name, Uint32 no, Uint32 val, bool replace){
  996.   size_t tmp_len = strlen(name)+20;
  997.   char * tmp = (char*)malloc(tmp_len);
  998.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  999.   bool res = put(tmp, val, replace);
  1000.   free(tmp);
  1001.   return res;
  1002. }
  1004. bool
  1005. Properties::put64(const char * name, Uint32 no, Uint64 val, bool replace){
  1006.   size_t tmp_len = strlen(name)+20;
  1007.   char * tmp = (char*)malloc(tmp_len);
  1008.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1009.   bool res = put(tmp, val, replace);
  1010.   free(tmp);
  1011.   return res;
  1012. }
  1015. bool 
  1016. Properties::put(const char * name, Uint32 no, const char * val, bool replace){
  1017.   size_t tmp_len = strlen(name)+20;
  1018.   char * tmp = (char*)malloc(tmp_len);
  1019.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1020.   bool res = put(tmp, val, replace);
  1021.   free(tmp);
  1022.   return res;
  1023. }
  1026. bool 
  1027. Properties::put(const char * name, Uint32 no, const Properties * val, 
  1028. bool replace){
  1029.   size_t tmp_len = strlen(name)+20;
  1030.   char * tmp = (char*)malloc(tmp_len);
  1031.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1032.   bool res = put(tmp, val, replace);
  1033.   free(tmp);
  1034.   return res;
  1035. }
  1038. bool 
  1039. Properties::getTypeOf(const char * name, Uint32 no, 
  1040.       PropertiesType * type) const {
  1041.   size_t tmp_len = strlen(name)+20;
  1042.   char * tmp = (char*)malloc(tmp_len);
  1043.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1044.   bool res = getTypeOf(tmp, type);
  1045.   free(tmp);
  1046.   return res;
  1047. }
  1049. bool 
  1050. Properties::contains(const char * name, Uint32 no) const {
  1051.   size_t tmp_len = strlen(name)+20;
  1052.   char * tmp = (char*)malloc(tmp_len);
  1053.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1054.   bool res = contains(tmp);
  1055.   free(tmp);
  1056.   return res;
  1057. }
  1059. bool 
  1060. Properties::get(const char * name, Uint32 no, Uint32 * value) const{
  1061.   size_t tmp_len = strlen(name)+20;
  1062.   char * tmp = (char*)malloc(tmp_len);
  1063.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1064.   bool res = get(tmp, value);
  1065.   free(tmp);
  1066.   return res;
  1067. }
  1069. bool 
  1070. Properties::get(const char * name, Uint32 no, Uint64 * value) const{
  1071.   size_t tmp_len = strlen(name)+20;
  1072.   char * tmp = (char*)malloc(tmp_len);
  1073.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1074.   bool res = get(tmp, value);
  1075.   free(tmp);
  1076.   return res;
  1077. }
  1080. bool 
  1081. Properties::get(const char * name, Uint32 no, const char ** value) const {
  1082.   size_t tmp_len = strlen(name)+20;
  1083.   char * tmp = (char*)malloc(tmp_len);
  1084.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1085.   bool res = get(tmp, value);
  1086.   free(tmp);
  1087.   return res;
  1088. }
  1091. bool 
  1092. Properties::get(const char * name, Uint32 no, const Properties ** value) const{
  1093.   size_t tmp_len = strlen(name)+20;
  1094.   char * tmp = (char*)malloc(tmp_len);
  1095.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1096.   bool res = get(tmp, value);
  1097.   free(tmp);
  1098.   return res;
  1099. }
  1102. bool 
  1103. Properties::getCopy(const char * name, Uint32 no, char ** value) const {
  1104.   size_t tmp_len = strlen(name)+20;
  1105.   char * tmp = (char*)malloc(tmp_len);
  1106.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1107.   bool res = getCopy(tmp, value);
  1108.   free(tmp);
  1109.   return res;
  1110. }
  1113. bool 
  1114. Properties::getCopy(const char * name, Uint32 no, Properties ** value) const {
  1115.   size_t tmp_len = strlen(name)+20;
  1116.   char * tmp = (char*)malloc(tmp_len);
  1117.   BaseString::snprintf(tmp, tmp_len, "%s_%d", name, no);
  1118.   bool res = getCopy(tmp, value);
  1119.   free(tmp);
  1120.   return res;
  1121. }
  1123. void
  1124. Properties::setCaseInsensitiveNames(bool value){
  1125.   impl->setCaseInsensitiveNames(value);
  1126. }
  1128. bool
  1129. Properties::getCaseInsensitiveNames() const {
  1130.   return impl->m_insensitive;
  1131. }
  1133. template bool put(PropertiesImpl *, const char *, Uint32, bool);
  1134. template bool put(PropertiesImpl *, const char *, Uint64, bool);
  1135. template bool put(PropertiesImpl *, const char *, const char *, bool);
  1136. template bool put(PropertiesImpl *, const char *, const Properties*, bool);