Changeset 166

Show
Ignore:
Timestamp:
07/18/08 17:15:56 (6 months ago)
Author:
zork
Message:

added support for bindings non collection members to xml elements (only)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/dba/dba/xmlarchive.cpp

    r154 r166  
    2020  : Archive(), 
    2121    mDocument(NULL), 
    22     mRootNode(NULL) 
     22    mRootNode(NULL), 
     23    mUseElements(false) 
    2324{ 
    2425  mConvSpecs.mTimestampFormat = "%Y-%m-%dZ%H:%M:%S"; 
     
    9091  if (mRootNodeName != NULL) 
    9192    root = root->children; 
    92   return new XMLIStream(mDocument,root,mConvSpecs); 
     93  return new XMLIStream(mDocument,root,mConvSpecs,mUseElements); 
    9394}; 
    9495 
    9596OStream*  
    9697XMLArchive::getOutputStream() { 
    97   return new XMLOStream(mDocument,mRootNode,mRootNodeName != NULL,mConvSpecs); 
     98  return new XMLOStream(mDocument,mRootNode,mRootNodeName != NULL,mConvSpecs,mUseElements); 
    9899}; 
    99100 
     
    103104  if (mRootNodeName != NULL) 
    104105    root = root->children; 
    105   return XMLIStream(mDocument,root,mConvSpecs); 
     106  return XMLIStream(mDocument,root,mConvSpecs,mUseElements); 
    106107}; 
    107108 
    108109XMLOStream  
    109110XMLArchive::getOStream() { 
    110   XMLOStream ret(mDocument,mRootNode,mRootNodeName == NULL,mConvSpecs); 
     111  XMLOStream ret(mDocument,mRootNode,mRootNodeName == NULL,mConvSpecs,mUseElements); 
    111112  return ret; 
    112113}; 
  • trunk/dba/dba/xmlarchive.h

    r154 r166  
    4747    void close(); 
    4848    virtual bool isOpen() const { return mDocument != NULL; } 
     49    void useElements(bool pFlag = true) { mUseElements = pFlag; } 
    4950    XMLOStream getOStream(); 
    5051    XMLIStream getIStream(); 
     
    6869    */ 
    6970    std::string mFilename; 
     71    /** 
     72      should archive store/load members data from elements or attributes 
     73    */ 
     74    bool mUseElements; 
    7075     
    7176    /** 
  • trunk/dba/dba/xmlistream.cpp

    r165 r166  
    1717namespace dba { 
    1818 
    19 XMLIStream::XMLIStream(xmlDocPtr pDocument, xmlNodePtr pNode, const ConvSpec& pSpecs
     19XMLIStream::XMLIStream(xmlDocPtr pDocument, xmlNodePtr pNode, const ConvSpec& pSpecs, bool pUseElements
    2020  : IStream(), 
    2121    ConvSpecContainer(pSpecs), 
     
    2323    mParentNode(pNode), 
    2424    mIgnoreNonMappedNodes(false), 
    25     mIgnoreOrder(false) 
     25    mIgnoreOrder(false), 
     26    mUseElements(pUseElements) 
    2627{ 
    2728  mCurrentNode = findNonTextNode(mParentNode); 
     
    193194    if (!xmlNodeIsText(node) && !xmlStrcmp(name,node->name)) 
    194195      break; 
    195     if (!xmlNodeIsText(node)) debug("findNode: ignoring node %s", node->name != NULL ? (const char*)node->name : "(null)"); 
     196    //if (!xmlNodeIsText(node)) debug("findNode: ignoring node %s", node->name != NULL ? (const char*)node->name : "(null)"); 
    196197  }; 
    197198 
     
    225226      dba::StoreableFilterBase* filter(member->getFilter()); 
    226227      setFilterPtr(*filter,(char*)pObject + (int)(member->getMemberOffset() + tbl->getClassOffset())); 
    227       xmlAttrPtr attr = findAttribute(pNode,member->getMemberName()); 
    228       if (attr != NULL) { 
    229         xmlChar* xmldata = xmlNodeGetContent(attr->children); 
    230         if (xmldata == NULL) { 
    231           filter->fromNull(); 
    232         } else { 
    233           std::string data((const char*)xmldata); 
    234           filter->fromString(mConvSpecs, data); 
    235         }; 
     228      xmlChar* xmldata = NULL; 
     229      if (mUseElements) { 
     230        xmlNodePtr node = findNode(pNode->children, member->getMemberName()); 
     231        if (node != NULL) { 
     232          debug("member %s: using child node",(const char*)node->name); 
     233          xmldata = xmlNodeGetContent(node); 
     234        }; 
     235      }; 
     236      if (xmldata == NULL) { 
     237        xmlAttrPtr attr = findAttribute(pNode,member->getMemberName()); 
     238        if (attr != NULL) { 
     239          debug("member %s: using attribute",(const char*)attr->name); 
     240          xmldata = xmlNodeGetContent(attr->children); 
     241        }; 
     242      }; 
     243      if (xmldata != NULL) { 
     244        std::string data((const char*)xmldata); 
     245        filter->fromString(mConvSpecs, data); 
    236246      } else { 
    237247        filter->fromNull(); 
  • trunk/dba/dba/xmlistream.h

    r164 r166  
    2424class XMLIStream : public IStream, public XMLErrorHandler, public ConvSpecContainer { 
    2525  public: 
    26     XMLIStream(xmlDocPtr pDocument, xmlNodePtr pNode, const ConvSpec& pSpecs); 
     26    XMLIStream(xmlDocPtr pDocument, xmlNodePtr pNode, const ConvSpec& pSpecs, bool pUseElements); 
    2727    /** 
    2828      If set to true, then stream will igore all nodes that are not mapped to class 
     
    5353    bool mIgnoreNonMappedNodes; 
    5454    bool mIgnoreOrder; 
     55    bool mUseElements; 
    5556     
    5657    virtual void setIdsCondition(const char* pFKeyName, id pRelationId, const std::vector<id>& pIds); 
  • trunk/dba/dba/xmlostream.cpp

    r154 r166  
    1717namespace dba { 
    1818 
    19 XMLOStream::XMLOStream(xmlDocPtr pDocument, xmlNodePtr pNode, bool pReplaceParentNode, const ConvSpec& pSpecs
     19XMLOStream::XMLOStream(xmlDocPtr pDocument, xmlNodePtr pNode, bool pReplaceParentNode, const ConvSpec& pSpecs, bool pUseElements
    2020  : OStream(), 
    2121    ConvSpecContainer(pSpecs), 
    2222    mDocument(pDocument), 
    2323    mParentNode(pNode), 
    24     mReplaceParentNode(pReplaceParentNode) 
     24    mReplaceParentNode(pReplaceParentNode), 
     25    mUseElements(pUseElements) 
    2526{ 
    2627} 
     
    105106    if (!filter.isNull()) { 
    106107      std::string strdata(filter.toString(getConversionSpecs())); 
    107       setAttribute(pNode,member->name,(xmlChar*)strdata.c_str()); 
     108      updateNodeData(pNode,member->name,strdata.c_str()); 
    108109    }; 
    109110    member = member->next; 
     
    116117XMLOStream::updateNodeFromVars(xmlNodePtr pNode, mt_class* pTable) { 
    117118  for (VarMap::const_iterator it = mBindings.begin(); it != mBindings.end(); it++) { 
    118     std::string data; 
    119119    if (!strcmp(it->mTable,pTable->name)) { 
    120120      dba::StoreableFilterBase& filter = *(it->mFilter); 
    121       data = filter.toString(mConvSpecs); 
     121      std::string data(filter.toString(mConvSpecs)); 
    122122      if (!data.empty()) { 
    123         setAttribute(pNode,it->mField,(xmlChar*)data.c_str()); 
    124       }; 
    125     }; 
     123        updateNodeData(pNode,it->mField,data.c_str()); 
     124      }; 
     125    }; 
     126  }; 
     127}; 
     128 
     129void 
     130XMLOStream::updateNodeData(xmlNodePtr pNode, const char* pName, const char* pContent) { 
     131  if (mUseElements) { 
     132    xmlNodePtr node(createNode(pName)); 
     133    xmlChar* encoded_data = xmlEncodeEntitiesReentrant(NULL,(xmlChar*)pContent); 
     134    xmlNodeSetContent(node,encoded_data); 
     135    xmlFree(encoded_data); 
     136    xmlAddChild(pNode,node); 
     137  } else { 
     138    setAttribute(pNode,pName,(xmlChar*)pContent); 
    126139  }; 
    127140}; 
  • trunk/dba/dba/xmlostream.h

    r154 r166  
    2424class XMLOStream  : public OStream, public XMLErrorHandler, public ConvSpecContainer { 
    2525  public: 
    26     XMLOStream(xmlDocPtr pDocument, xmlNodePtr pNode, bool pReplaceParentNode, const ConvSpec& pSpecs); 
     26    XMLOStream(xmlDocPtr pDocument, xmlNodePtr pNode, bool pReplaceParentNode, const ConvSpec& pSpecs, bool pUseElements); 
    2727    virtual void close(); 
    2828    virtual void destroy(); 
     
    4646    xmlNodePtr mParentNode; 
    4747    bool mReplaceParentNode; 
     48    bool mUseElements; 
    4849     
    4950    void updateNodeFromVars(xmlNodePtr pNode, mt_class* pTable); 
     
    5152    void setAttribute(xmlNodePtr pNode, const char* pName, const xmlChar* pData); 
    5253    xmlNodePtr createNode(const char* pName); 
     54    void updateNodeData(xmlNodePtr pNode, const char* pName, const char* pContent); 
    5355}; 
    5456 
  • trunk/dba/test/xmltestcase.cpp

    r165 r166  
    775775}; 
    776776 
     777void 
     778XMLTestCase::loadFromElements() { 
     779  const char* data =  
     780"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 
     781"<test_objects>\n" 
     782"  <i_value>1</i_value>\n" 
     783"  <f_value>1.1</f_value>\n" 
     784"  <s_value>test</s_value>\n" 
     785"  <d_value>2008-01-01Z00:00:00</d_value>\n" 
     786"</test_objects>\n" 
     787; 
     788  {  
     789    std::ofstream file("loadfromelements.xml"); 
     790    file << data; 
     791  }; 
     792  { 
     793    dba::XMLArchive ar; 
     794    ar.setRootNodeName(NULL); 
     795    ar.useElements(); 
     796    ar.open("loadfromelements.xml"); 
     797    TestObject obj1; 
     798    dba::XMLIStream stream(ar.getIStream()); 
     799    stream.enableDebug(); 
     800    stream.open(obj1); 
     801    CPPUNIT_ASSERT(stream.getNext(&obj1)); 
     802 
     803    TestObject expected(1,1.1,"test",Utils::getDate(2008,1,1,0,0,0)); 
     804    CPPUNIT_ASSERT(obj1 == expected); 
     805  }; 
     806}; 
     807 
     808void 
     809XMLTestCase::storeToElements() { 
     810  const char* result =  
     811"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" 
     812"<test_objects>\n" 
     813"  <i_value>1</i_value>\n" 
     814"  <f_value>1.1</f_value>\n" 
     815"  <s_value>test</s_value>\n" 
     816"  <d_value>2008-01-01Z00:00:00</d_value>\n" 
     817"</test_objects>\n" 
     818; 
     819  { 
     820    dba::XMLArchive ar; 
     821    ar.setRootNodeName(NULL); 
     822    ar.useElements(); 
     823    unlink("storetoelements.xml"); 
     824    ar.open("storetoelements.xml"); 
     825    TestObject obj1(1,1.1,"test",Utils::getDate(2008,1,1,0,0,0)); 
     826    dba::XMLOStream stream(ar.getOStream()); 
     827    stream.open(); 
     828    stream.put(&obj1); 
     829  } 
     830  CPPUNIT_ASSERT(compareXML("storetoelements.xml",result)); 
     831}; 
     832 
    777833 
    778834} //namespace 
  • trunk/dba/test/xmltestcase.h

    r154 r166  
    5151      CPPUNIT_TEST(store_ns); 
    5252      CPPUNIT_TEST(load_two); 
     53      CPPUNIT_TEST(loadFromElements); 
     54      CPPUNIT_TEST(storeToElements); 
    5355    CPPUNIT_TEST_SUITE_END(); 
    5456  public: 
     
    8587    void load_two_inverted(); 
    8688    void store_two(); 
     89    void loadFromElements(); 
     90    void storeToElements(); 
    8791  private: 
    8892    bool compareXML(const char* pFilename, const char* pData);