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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
PropertyList.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：21k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

PropertyList.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. #include "PropertyList.hpp"
  25. #include "CommonExceptions.hpp"       // for VXIException class
  26. #include "VXIinet.h"
  27. #include "VXML.h"
  28. #include "SimpleLogger.hpp"           // for SimpleLogger
  29. #include "DocumentParser.hpp"         // for string constants
  30. #include "DocumentModel.hpp"
  31. #include <sstream>
  33. // ------*---------*---------*---------*---------*---------*---------*---------
  35. // The use of spaces here creates identifiers which cannot be specified
  36. // within the property or meta tags.
  37. const VXIchar * const PropertyList::BaseURI     = L" base";
  38. const VXIchar * const PropertyList::Language    = L" lang";
  39. const VXIchar * const PropertyList::AbsoluteURI = L" absoluteURI";
  40. const VXIchar * const PropertyList::SourceEncoding = L" encoding";
  43. static vxistring toString(const VXIString * s)
  44. {
  45.   if (s == NULL) return L"";
  46.   const VXIchar * temp = VXIStringCStr(s);
  47.   if (temp == NULL) return L"";
  48.   return temp;
  49. }
  51. static vxistring toString(const VXIchar * s)
  52. {
  53.   if (s == NULL) return L"";
  54.   return s;
  55. }
  57. // ------*---------*---------*---------*---------*---------*---------*---------
  59. PropertyList::PropertyList(const SimpleLogger & l) : log(l)
  60. {
  61.   properties.reserve(LAST_PROP);
  62.   while (properties.size() < LAST_PROP)
  63.     properties.push_back(STRINGMAP());
  64. }
  67. PropertyList::PropertyList(const PropertyList & p) : log(p.log)
  68. {
  69.   properties = p.properties;
  70. }
  73. PropertyList& PropertyList::operator=(const PropertyList & x)
  74. {
  75.   if (this != &x) {
  76.     properties = x.properties;
  77.   }
  79.   return *this;
  80. }
  83. const VXIchar* PropertyList::GetProperty(const VXIchar * key,
  84.                                          PropertyLevel L) const
  85. {
  86.   int pos = L;
  87.   do {
  88.     if (pos == LAST_PROP) --pos;
  89.     STRINGMAP::const_iterator i = properties[pos].find(key);
  90.     if (i != properties[pos].end()) return (*i).second.c_str();
  91.   } while (--pos >= 0);
  93.   return NULL;
  94. }
  97. bool PropertyList::SetProperty(const VXIchar * key, const VXIchar * value,
  98.                                PropertyLevel level)
  99. {
  100.   if (level == LAST_PROP || key == NULL || value == NULL) return false;
  102.   STRINGMAP & propmap = properties[level];
  103.   propmap[key] = value;
  105.   return true;
  106. }
  109. void PropertyList::SetProperties(const VXMLElement & doc, PropertyLevel level,
  110.                                  const VXIMapHolder & docProps)
  111. {
  112.   // (0) Check the arguments
  114.   if (doc == 0) return;
  116.   if (properties.size() != LAST_PROP) {
  117.     log.LogError(999, SimpleLogger::MESSAGE,
  118.                  L"internal property list corrupted");
  119.     throw VXIException::Fatal();
  120.   }
  122.   // (1) Clear all properties at this level and above.
  123.   properties[level].clear();
  124.   STRINGMAP & propmap = properties[level];
  126.   // (2) Add document properties.
  128.   if (docProps.GetValue() != NULL) {
  129.     const VXIValue * val;
  130.     const VXIString * str;
  132.     // (2.1) Handle document base URI.
  133.     val = VXIMapGetProperty(docProps.GetValue(), PropertyList::BaseURI);
  134.     str = reinterpret_cast<const VXIString *>(val);
  135.     if (VXIStringLength(str) != 0)
  136.       propmap.insert(propmap.end(),
  137.                      STRINGMAP::value_type(PropertyList::BaseURI,
  138.                                            toString(str)));
  140.     // (2.2) Handle document language.  If the document property is not
  141.     // specified, the value of the xml:lang property will be used.
  143.     val = VXIMapGetProperty(docProps.GetValue(), PropertyList::Language);
  144.     str = reinterpret_cast<const VXIString *>(val);
  145.     if (VXIStringLength(str) != 0)
  146.       propmap.insert(propmap.end(),
  147.                      STRINGMAP::value_type(PropertyList::Language,
  148.                                            toString(str)));
  149.     else {
  150.       const VXIchar * lang = GetProperty(L"xml:lang");
  151.       if (lang != NULL)
  152.         propmap.insert(propmap.end(),
  153.                        STRINGMAP::value_type(PropertyList::Language,
  154.                                              toString(lang)));
  155.     }
  156.     
  157.     // (2.3) Handle document absolute URI.
  158.     val = VXIMapGetProperty(docProps.GetValue(), PropertyList::AbsoluteURI);
  159.     str = reinterpret_cast<const VXIString *>(val);
  160.     if (VXIStringLength(str) != 0)
  161.       propmap.insert(propmap.end(),
  162.                      STRINGMAP::value_type(PropertyList::AbsoluteURI,
  163.                                            toString(str)));
  165. // (2.4) Handle document encoding.
  166.     val = VXIMapGetProperty(docProps.GetValue(), PropertyList::SourceEncoding);
  167.     str = reinterpret_cast<const VXIString *>(val);
  168.     if (VXIStringLength(str) != 0)
  169.       propmap.insert(propmap.end(),
  170.                      STRINGMAP::value_type(PropertyList::SourceEncoding,
  171.                                            toString(str)));
  172.   }
  174.   // (3) Walk through this level.  Find all <property> nodes and set the
  175.   // corresponding values.
  176.   for (VXMLNodeIterator it(doc); it; ++it) {
  177.     VXMLNode child = *it;
  179.     if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  180.     const VXMLElement & elem = reinterpret_cast<const VXMLElement &>(child);
  181.     VXMLElementType nodeName = elem.GetName();
  182.     if (nodeName == NODE_PROPERTY) {
  183.       vxistring name;
  184.       vxistring value;
  185.       elem.GetAttribute(ATTRIBUTE_NAME, name);
  186.       elem.GetAttribute(ATTRIBUTE_VALUE, value);
  187.       
  188.       // This added the name / value pair, converting to vxistrings.
  189.   propmap[name] = value;
  190.     }
  191.   }
  192. }
  195. //****************************************************************
  196. //* Fetchobj building routines
  197. //****************************************************************
  199. bool PropertyList::ConvertTimeToMilliseconds(const SimpleLogger & log,
  200.                                              const vxistring & time,
  201.                                              VXIint & result)
  202. {
  203.   result = 0;
  204.   double final = 0.0, fraction = -1.0;
  205.   bool fflag = false;
  206.   
  207.   if (time.empty()) {
  208.     log.LogDiagnostic(0, L"PropertyList::ConvertTimeToMilliseconds - empty");
  209.     return false;
  210.   }
  212.   for (unsigned int i = 0; i < time.length(); ++i) {
  213.     char c;
  214.     switch (time[i]) {
  215.     // ignore white spaces and plus sign
  216.     case L' ': case L't': case L'n': case L'r':
  217.     case L'+':  continue;
  218.     case L'-': // do not allow negative conversion
  219.       log.StartDiagnostic(0) << L"PropertyList::ConvertTimeToMilliseconds - "
  220.           L"Illegal negative time designation number "" << time << L"".";
  221.       log.EndDiagnostic();
  222.       return false;      
  223.     case L'0':  c = 0;  break;
  224.     case L'1':  c = 1;  break;
  225.     case L'2':  c = 2;  break;
  226.     case L'3':  c = 3;  break;
  227.     case L'4':  c = 4;  break;
  228.     case L'5':  c = 5;  break;
  229.     case L'6':  c = 6;  break;
  230.     case L'7':  c = 7;  break;
  231.     case L'8':  c = 8;  break;
  232.     case L'9':  c = 9;  break;
  233.     case L'.': 
  234.       // disallow illegal fraction number
  235.       if( fflag ) {
  236.         log.StartDiagnostic(0) << L"PropertyList::ConvertTimeToMilliseconds - "
  237.           L"Invalid fraction number "" << time << L"".";
  238.         log.EndDiagnostic();
  239.         return false;
  240.       }
  241.       fflag = true;  
  242.       continue;      
  243.     default:
  244.       const vxistring units = time.substr(i, time.length() - i);
  245.       if (units == L"ms") {
  246.         result = (VXIint) final;
  247.         return true;
  248.       }
  249.       if (units == L"s") {
  250.         result = (VXIint) (final * 1000);
  251.         return true;
  252.       }
  254.       // Otherwise the unit type is not recognized.
  256.       log.StartDiagnostic(0) << L"PropertyList::ConvertTimeToMilliseconds - "
  257.         L"Invalid units in value "" << time << L"".";
  258.       log.EndDiagnostic();
  260.       return false;
  261.     }
  263.     if( fflag ) {
  264.       fraction = fraction < 0 ? 0.1 : fraction / 10;
  265.       final += (fraction * c );
  266.     } 
  267.     else
  268.       final = 10.0*final + c;
  269.   }
  271.   // No units were specified. Signal VXI to throw semantic error
  272.   log.StartDiagnostic(0) << L"PropertyList::ConvertTimeToMilliseconds - "
  273.       L"Missing unit in value "" << time << L"".";
  274.   log.EndDiagnostic();
  276.   return false;
  277. }
  280. bool PropertyList::ConvertValueToFraction(const SimpleLogger & log,
  281.                                           const vxistring & value,
  282.                                           VXIflt32& result)
  283. {
  284. #if defined(__GNUC__)
  285.   // The G++ 2.95/3.0 implementation of basic_stringstream is faulty.
  286.   VXIchar * temp;
  287.   result = VXIflt32(wcstod(value.c_str(), &temp));
  288.   if (*temp) {
  289.     result = -1.0;
  290.     return false;
  291.   }
  292. #else
  293.   std::basic_stringstream<VXIchar> attrStream(value);
  294.   attrStream >> result;
  295.   if (attrStream.bad()) {
  296.     result = -1.0;
  297.     return false;
  298.   }
  299. #endif
  301.   return true;
  302. }
  305. void PropertyList::GetFetchobjCacheAttrs(const VXMLElement & elem,
  306.                                          PropertyList::CacheAttrType type,
  307.                                          VXIMapHolder & fetchobj) const
  308. {
  309.   vxistring attr;
  310.   const VXIchar * propName;
  312.   // (1) Attribute: maxage
  314.   // (1.1) Get the attribute - first locally, then from the defaults.
  315.   elem.GetAttribute(ATTRIBUTE_MAXAGE, attr); 
  316.   if (attr.empty()) {
  317.     switch (type) {
  318.     case PropertyList::Audio:      propName = L"audiomaxage";     break;
  319.     case PropertyList::Document:   propName = L"documentmaxage";  break;
  320.     case PropertyList::Grammar:    propName = L"grammarmaxage";   break;
  321.     case PropertyList::Object:     propName = L"objectmaxage";    break;
  322.     case PropertyList::Script:     propName = L"scriptmaxage";    break;
  323.     case PropertyList::Data:       propName = L"datamaxage";      break;
  324.     }
  326.     attr = toString(GetProperty(propName));
  327.   }
  329.   // (1.2) Process the value.
  330.   if (!attr.empty()) {
  331.     VXIint value = -1;
  333. #if defined(__GNUC__)
  334.   // The G++ 2.95/3.0 implementation of basic_stringstream is faulty.
  335.     VXIchar * temp;
  336.     value = VXIint(wcstol(attr.c_str(), &temp, 10));
  337.     if (*temp) value = -1;
  338. #else
  339.     std::basic_stringstream<VXIchar> attrStream(attr);
  340.     attrStream >> value;
  341.     if (attrStream.bad()) value = -1;
  342. #endif
  344.     if (value < 0) {
  345.       log.StartDiagnostic(0) << L"PropertyList::GetFetchobjCacheAttrs - "
  346.         L"Invalid value for " << propName << L" of " << attr << L".";
  347.       log.EndDiagnostic();
  348.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC,
  349.                                            L"invalid maxage value");
  350.     }
  352.     // (1.3) Add value to fetchobj
  353.     VXIInteger * val = VXIIntegerCreate(value);
  354.     if (val == NULL) throw VXIException::OutOfMemory();
  355.     VXIvalueResult r = VXIMapSetProperty(fetchobj.GetValue(),
  356.                                          INET_CACHE_CONTROL_MAX_AGE,
  357.                                          reinterpret_cast<VXIValue*>(val));
  358.   }
  360.   // (2) Attribute: maxstale
  362.   // (2.1) Get the attribute - first locally, then from the defaults.
  363.   attr.erase();
  364.   elem.GetAttribute(ATTRIBUTE_MAXSTALE, attr);
  365.   if (attr.empty()) {
  366.     switch (type) {
  367.     case PropertyList::Audio:      propName = L"audiomaxstale";     break;
  368.     case PropertyList::Document:   propName = L"documentmaxstale";  break;
  369.     case PropertyList::Grammar:    propName = L"grammarmaxstale";   break;
  370.     case PropertyList::Object:     propName = L"objectmaxstale";    break;
  371.     case PropertyList::Script:     propName = L"scriptmaxstale";    break;
  372.     case PropertyList::Data:       propName = L"datamaxstale";      break;
  373.     }
  375.     attr = toString(GetProperty(propName));
  376.   }
  378.   // (2.2) Process the value.
  379.   if (!attr.empty()) {
  380.     VXIint value = -1;
  382. #if defined(__GNUC__)
  383.   // The G++ 2.95/3.0 implementation of basic_stringstream is faulty.
  384.     VXIchar * temp;
  385.     value = VXIint(wcstol(attr.c_str(), &temp, 10));
  386.     if (*temp) value = -1;
  387. #else
  388.     std::basic_stringstream<VXIchar> attrStream(attr);
  389.     attrStream >> value;
  390.     if (attrStream.bad()) value = -1;
  391. #endif
  393.     if (value < 0) {
  394.       log.StartDiagnostic(0) << L"PropertyList::GetFetchobjCacheAttrs - "
  395.         L"Invalid value for " << propName << L" of " << attr << L".";
  396.       log.EndDiagnostic();
  397.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC,
  398.                                            L"invalid maxstale value");
  399.     }
  401.     // (2.3) Add value to fetchobj
  402.     VXIInteger * val = VXIIntegerCreate(value);
  403.     if (val == NULL) throw VXIException::OutOfMemory();
  404.     VXIvalueResult r = VXIMapSetProperty(fetchobj.GetValue(),
  405.                                          INET_CACHE_CONTROL_MAX_STALE,
  406.                                          reinterpret_cast<VXIValue*>(val));
  407.   }
  409.   // (3) Attribute: fetchtimeout
  411.   // (3.1) Get the attribute - first locally, then from the defaults.
  412.   attr.erase();
  413.   elem.GetAttribute(ATTRIBUTE_FETCHTIMEOUT, attr);
  414.   if (attr.empty())
  415.     attr = toString(GetProperty(L"fetchtimeout"));
  417.   // (3.2) Process the value.
  418.   if (!attr.empty()) {
  419.     VXIint value;
  420.     if (!ConvertTimeToMilliseconds(log, attr, value)) {
  421.       log.StartDiagnostic(0) << L"PropertyList::GetFetchobjTimeout - "
  422.         L"Invalid value for fetchtimeout of " << attr << L".";
  423.       log.EndDiagnostic();
  424.       throw VXIException::InterpreterEvent(EV_ERROR_SEMANTIC,
  425.                                            L"invalid fetchtimeout value");
  426.     }
  427.     
  428.     // throw an bad.fetch if the fetchtimeout = 0
  429.     if( value == 0 )
  430.       throw VXIException::InterpreterEvent(EV_ERROR_BADFETCH,
  431.                                            L"fetchtimeout value is 0s");  
  432.     
  433.     // (3.3) Add value to fetchobj
  434.     VXIInteger * str = VXIIntegerCreate(value);
  435.     if (str == NULL) throw VXIException::OutOfMemory();
  436.     VXIvalueResult r = VXIMapSetProperty(fetchobj.GetValue(),INET_TIMEOUT_DOWNLOAD,
  437.                                          reinterpret_cast<VXIValue*>(str));
  438.   }
  440.   // (4) Base uri from inet
  441.   attr.erase();
  442.   elem.GetAttribute(ATTRIBUTE_BASE, attr);
  443.   if (attr.empty()) {
  444.     const VXIchar* tmp = GetProperty(PropertyList::BaseURI);
  445.     if( tmp ) attr = tmp;
  446.   }
  447.   
  448.   if( !attr.empty() ) { 
  449.     VXIString * base = VXIStringCreate(attr.c_str());
  450.     if (base == NULL) throw VXIException::OutOfMemory();
  452.     VXIMapSetProperty(fetchobj.GetValue(), INET_URL_BASE,
  453.                     reinterpret_cast<VXIValue*>(base));
  454.   }
  455.   
  456. #pragma message ("PropertyList::GetFetchobjCacheAttrs - ignoring fetchhint")
  457. }
  460. bool PropertyList::GetFetchobjSubmitAttributes(const VXMLElement & elem,
  461.                                                VXIMapHolder & submitData,
  462.                                                VXIMapHolder & fetchobj) const
  463. {
  464.   // (1) Get encoding for the submit.
  465.   vxistring enctype;
  466.   bool hasenc;
  468.   // (1.1) Get the attribute.
  469.   hasenc = elem.GetAttribute(ATTRIBUTE_ENCTYPE, enctype);
  470.   if (!hasenc )
  471.     enctype = L"application/x-www-form-urlencoded";
  473.   // (1.2) Add value to fetchobj
  474.   VXIvalueResult r;
  475.   VXIString * str = VXIStringCreate(enctype.c_str());
  476.   if (str == NULL) throw VXIException::OutOfMemory();
  477.   r = VXIMapSetProperty(fetchobj.GetValue(), INET_SUBMIT_MIME_TYPE,
  478.                         reinterpret_cast<VXIValue*>(str));
  479.   if (r != VXIvalue_RESULT_SUCCESS) return false;
  482.   // (2) Set submit method.
  483.   // (2.1) Get the attribute - first locally, then from the defaults.
  484.   vxistring method;
  485.   elem.GetAttribute(ATTRIBUTE_METHOD, method);
  487.   // (2.2) Process the value.
  488.   const VXIchar * value = NULL;
  489.   if (method == L"get" || method.empty())
  490.   {
  491.     value = INET_SUBMIT_METHOD_GET;
  493.     if( hasenc )
  494.     {
  495.       log.StartDiagnostic(0) << L"PropertyList::GetFetchobjSubmitMethod - "
  496.       L"Ignoring Attribute 'enctype' for method 'GET'.";
  497.       log.EndDiagnostic();
  498.     }
  500.   }
  501.   else if (method == L"post")
  502.     value = INET_SUBMIT_METHOD_POST;
  503.   else {
  504.     log.StartDiagnostic(0) << L"PropertyList::GetFetchobjSubmitMethod - "
  505.       L"Bad value (" << ATTRIBUTE_METHOD << L" = "" << method << L""), "
  506.       L"defaulting to " << INET_SUBMIT_METHOD_DEFAULT << L".";
  507.     log.EndDiagnostic();
  508.     value = INET_SUBMIT_METHOD_DEFAULT;
  509.   }
  511.   // (2.3) Add value to fetchobj
  512.   str = VXIStringCreate(value);
  513.   if (str == NULL) throw VXIException::OutOfMemory();
  514.   r = VXIMapSetProperty(fetchobj.GetValue(), INET_SUBMIT_METHOD,
  515.                                        reinterpret_cast<VXIValue*>(str));
  516.   if (r != VXIvalue_RESULT_SUCCESS) return false;
  519.   // (3) Set the submit data.
  520.   r = VXIMapSetProperty(fetchobj.GetValue(), INET_URL_QUERY_ARGS,
  521.                         reinterpret_cast<VXIValue*>(submitData.Release()));
  523.   return r == VXIvalue_RESULT_SUCCESS;
  524. }
  527. bool PropertyList::GetFetchobjBase(VXIMapHolder & fetchobj) const
  528. {
  529.   const VXIchar * base = GetProperty(PropertyList::BaseURI);
  530.   if (base != NULL)
  531.     AddParamValue(fetchobj, INET_URL_BASE, base);
  533.   return true;
  534. }
  537. bool PropertyList::GetFetchobjURIs(const VXMLElement & elem,
  538.                                    VXIMapHolder & fetchobj,
  539.                                    vxistring & url,
  540.                                    vxistring & fragment) const
  541. {
  542.   fragment = L"";
  544.   // The URI may be decomposed into three elements - the base, a relative
  545.   // address, and a fragment corresponding to a dialog within that module.
  547.   // (1) First the base.
  548.   GetFetchobjBase(fetchobj);
  550.   // (2) Then determine if there is a fragment at all.
  551.   if (url.empty()) return false;
  553.   vxistring::size_type pos = url.find('#');
  554.   if (pos == vxistring::npos) return true;
  556.   // (3) There was a fragment.
  557.   if (pos + 1 < url.length())
  558.     fragment = url.substr(pos + 1, url.length() - pos - 1);
  560.   url.erase(pos);
  562.   return true;
  563. }
  565. //****************************************************************
  566. //* Recognition & Grammar property related.
  567. //****************************************************************
  569. bool PropertyList::PushProperties(const VXMLElement & doc)
  570. {
  571.   // (1) Find the last non-empty level.
  572.   unsigned int i;
  573.   for (i = LAST_PROP - 1; i > 0; --i)
  574.     if (!properties[i].empty()) break;
  576.   STRINGMAP & propmap = properties[ (i == LAST_PROP - 1 ? i : i + 1) ];  // This is the first empty level.
  578.   // (2) Add properties at that point.
  580.   bool foundSomething = false;
  582.   for (VXMLNodeIterator it(doc); it; ++it) {
  583.     VXMLNode child = *it;
  585.     if (child.GetType() != VXMLNode::Type_VXMLElement) continue;
  586.     const VXMLElement & elem = reinterpret_cast<const VXMLElement &>(child);
  587.     VXMLElementType nodeName = elem.GetName();
  588.     if (nodeName == NODE_PROPERTY) {
  589.       vxistring name;
  590.       vxistring value;
  591.       elem.GetAttribute(ATTRIBUTE_NAME, name);
  592.       elem.GetAttribute(ATTRIBUTE_VALUE, value);
  594.       // This added the name / value pair, converting to vxistrings.
  595.       propmap.insert(propmap.end(), STRINGMAP::value_type(name, value));
  597.       foundSomething = true;
  598.     }
  599.   }
  601.   return foundSomething;
  602. }
  605. void PropertyList::PopProperties()
  606. {
  607.   // Find the last non-empty level.
  608.   unsigned int i;
  609.   for (i = LAST_PROP - 1; i > 0; --i)
  610.     if (!properties[i].empty()) break;
  612.   // Clear it.
  613.   properties[i].clear();
  614. }
  616. void PropertyList::PopPropertyLevel(PropertyLevel l)
  617. {
  618.   if( l < LAST_PROP && !properties[l].empty()) {
  619.     properties[l].clear();
  620.   }
  621. }
  623. // This starts at the lowest level, inserting entries into a newly created map.
  624. // Values at higher levels will overwrite keys with identical names.
  625. //
  626. void PropertyList::GetProperties(VXIMapHolder & m) const
  627. {
  628.   // (1) Collapse the values down into a single map.
  629.   STRINGMAP collapsed;
  630.   PROPERTIES::const_iterator i;
  631.   for (i = properties.begin(); i != properties.end(); ++i) {
  632.     for (STRINGMAP::const_iterator j = (*i).begin(); j != (*i).end(); ++j) {
  633.       collapsed[(*j).first] = (*j).second;
  634.     }
  635.   }
  637.   // (2) Create a new map & copy the values over.
  638.   STRINGMAP::const_iterator j;
  639.   for (j = collapsed.begin(); j != collapsed.end(); ++j) {
  640.     VXIString * value = VXIStringCreate((*j).second.c_str());
  641.     if (value == NULL) throw VXIException::OutOfMemory();
  643.     // Set this key.
  644.     VXIMapSetProperty(m.GetValue(), (*j).first.c_str(),
  645.                       reinterpret_cast<VXIValue *>(value));
  646.   }
  647. }