예제 #1
0
bool CVideoExchange::AddElement(LPCTSTR strName, LPCTSTR strValue)
{
    MSXML::IXMLDOMElementPtr pRoot;
    MSXML::IXMLDOMElementPtr pElem;

    pRoot = m_pDocument->getElementsByTagName(L"CARDVIDEO")->item[0];
    pElem = m_pDocument->createElement(_bstr_t(strName));
    pElem->text = (LPCTSTR)strValue;
    pRoot->appendChild(pElem);
    pElem.Release();
    return true;
}
예제 #2
0
void CArc::Save(MSXML::IXMLDOMElementPtr pRoot)
{
	MSXML::IXMLDOMElementPtr pGO;
	MSXML::IXMLDOMElementPtr pStatic;
	MSXML::IXMLDOMElementPtr pDynamic;
	MSXML::IXMLDOMElementPtr pAttr;
    _variant_t val;

	MSXML::IXMLDOMDocumentPtr pDoc=pRoot->ownerDocument;
    
    //add a graphy object
    pGO=pDoc->createElement(L"go");    
    val.vt=VT_BSTR;
    val.bstrVal=::SysAllocString(L"arc");
    pGO->setAttribute(L"type",val);
    pRoot->appendChild(pGO);

    //add a group static attribution
    pStatic=pDoc->createElement(L"static");
    pGO->appendChild(pStatic);
    
    //position
    pAttr=pDoc->createElement(L"position");
    pStatic->appendChild(pAttr);
    //x1
    val.vt=VT_I4;
    val.lVal=m_lx1;
    pAttr->setAttribute(L"x1",val);
    //y1
    val.vt=VT_I4;
    val.lVal=m_ly1;
    pAttr->setAttribute(L"y1",val);
    //x2
    val.vt=VT_I4;
    val.lVal=m_lx2;
    pAttr->setAttribute(L"x2",val);
    //y2
    val.vt=VT_I4;
    val.lVal=m_ly2;
    pAttr->setAttribute(L"y2",val);
    //x3
    val.vt=VT_I4;
    val.lVal=m_lx3;
    pAttr->setAttribute(L"x3",val);
    //y3
    val.vt=VT_I4;
    val.lVal=m_ly1;
    pAttr->setAttribute(L"y3",val);
    //x4
    val.vt=VT_I4;
    val.lVal=m_lx4;
    pAttr->setAttribute(L"x4",val);
    //y4
    val.vt=VT_I4;
    val.lVal=m_ly4;
    pAttr->setAttribute(L"y4",val);

    //pen
    pAttr=pDoc->createElement("pen");
    pStatic->appendChild(pAttr);
    //style
    val.vt=VT_UI4;
    val.ulVal=m_pen.lopnStyle;
    pAttr->setAttribute(L"s",val);
    //width
    val.vt=VT_I4;
    val.lVal=m_pen.lopnWidth.x;
    pAttr->setAttribute(L"w",val);
    //color
    val.vt=VT_UI4;
    val.ulVal=m_pen.lopnColor;
    pAttr->setAttribute(L"c",val);

    //if linked then save dynamic attribution
    pDynamic=pDoc->createElement("dynamic");
    pGO->appendChild(pDynamic);
    if(m_DnyAttr.m_Linked){
        //linked
        val.vt=VT_BOOL;
        val.boolVal=-1;
        pDynamic->setAttribute(L"linked",val);
        //save dynamic attribution
        m_DnyAttr.Save(pDoc,pDynamic);
    }else{
        //unlinked
        val.vt=VT_BOOL;
        val.boolVal=FALSE;
        pDynamic->setAttribute(L"linked",val);
    }
}
예제 #3
0
void CText::Save(MSXML::IXMLDOMElementPtr pRoot)
{
    MSXML::IXMLDOMElementPtr pGO;
    MSXML::IXMLDOMElementPtr pStatic;
    MSXML::IXMLDOMElementPtr pDynamic;
    MSXML::IXMLDOMElementPtr pAttr;
    _variant_t val;

    MSXML::IXMLDOMDocumentPtr pDoc=pRoot->ownerDocument;

    //add a graphy object
    pGO=pDoc->createElement(L"go");
    val.vt=VT_BSTR;
    val.bstrVal=::SysAllocString(L"text");
    pGO->setAttribute(L"type",val);
    pRoot->appendChild(pGO);

    //add a group static attribution
    pStatic=pDoc->createElement(L"static");
    pGO->appendChild(pStatic);

    //position
    pAttr=pDoc->createElement(L"position");
    pStatic->appendChild(pAttr);
    //x1
    val.vt=VT_I4;
    val.lVal=m_lx1;
    pAttr->setAttribute(L"x1",val);
    //y1
    val.vt=VT_I4;
    val.lVal=m_ly1;
    pAttr->setAttribute(L"y1",val);
    //x2
    val.vt=VT_I4;
    val.lVal=m_lx2;
    pAttr->setAttribute(L"x2",val);
    //y2
    val.vt=VT_I4;
    val.lVal=m_ly2;
    pAttr->setAttribute(L"y2",val);

    //face color
    pAttr=pDoc->createElement("color");
    pStatic->appendChild(pAttr);
    //color
    val.vt=VT_UI4;
    val.ulVal=m_FaceColor;
    pAttr->setAttribute(L"c",val);

    //font
    pAttr=pDoc->createElement("font");
    pStatic->appendChild(pAttr);
    //lfHeight
    val.vt=VT_I4;
    val.lVal=m_font.lfHeight;
    pAttr->setAttribute(L"h",val);
    //lfWidth
    val.vt=VT_I4;
    val.lVal=m_font.lfWidth;
    pAttr->setAttribute(L"wd",val);
    //lfEscapement
    val.vt=VT_I4;
    val.lVal=m_font.lfEscapement;
    pAttr->setAttribute(L"e",val);
    //lfOrientation
    val.vt=VT_I4;
    val.lVal=m_font.lfOrientation;
    pAttr->setAttribute(L"o",val);
    //lfWeight
    val.vt=VT_I4;
    val.lVal=m_font.lfWeight;
    pAttr->setAttribute(L"wg",val);
    //lfItalic
    val.vt=VT_UI1;
    val.bVal=m_font.lfItalic;
    pAttr->setAttribute(L"i",val);
    //lfUnderline
    val.vt=VT_UI1;
    val.bVal=m_font.lfUnderline;
    pAttr->setAttribute(L"u",val);
    //lfStrikeOut
    val.vt=VT_UI1;
    val.bVal=m_font.lfStrikeOut;
    pAttr->setAttribute(L"so",val);
    //lfCharSet
    val.vt=VT_UI1;
    val.bVal=m_font.lfCharSet;
    pAttr->setAttribute(L"cs",val);
    //lfOutPrecision
    val.vt=VT_UI1;
    val.bVal=m_font.lfOutPrecision;
    pAttr->setAttribute(L"op",val);
    //lfClipPrecision
    val.vt=VT_UI1;
    val.bVal=m_font.lfClipPrecision;
    pAttr->setAttribute(L"cp",val);
    //lfQuality
    val.vt=VT_UI1;
    val.bVal=m_font.lfQuality;
    pAttr->setAttribute(L"q",val);
    //lfPitchAndFamily
    val.vt=VT_UI1;
    val.bVal=m_font.lfPitchAndFamily;
    pAttr->setAttribute(L"paf",val);
    //lfFaceName
    CString strFaceName=m_font.lfFaceName;
    //strFaceName.Format("%s",m_font.lfFaceName);
    val.vt=VT_BSTR;
    val.bstrVal=strFaceName.AllocSysString();
    pAttr->setAttribute(L"fn",val);

    //text
    pAttr=pDoc->createElement("text");
    pStatic->appendChild(pAttr);
    val.vt=VT_BSTR;
    val.bstrVal=m_text.AllocSysString();
    pAttr->setAttribute(L"t",val);

    //if linked then save dynamic attribution
    pDynamic=pDoc->createElement("dynamic");
    pGO->appendChild(pDynamic);
    if(m_DnyAttr.m_Linked) {
        //linked
        val.vt=VT_BOOL;
        val.boolVal=-1;
        pDynamic->setAttribute(L"linked",val);
        //save dynamic attribution
        m_DnyAttr.Save(pDoc,pDynamic);
    } else {
        //unlinked
        val.vt=VT_BOOL;
        val.boolVal=FALSE;
        pDynamic->setAttribute(L"linked",val);
    }
}
예제 #4
0
bool CVideoExchange::Dehydrate(void)
{
    if (m_pDocument)
        m_pDocument.Release();
    MSXML::IXMLDOMElementPtr pRoot;
    MSXML::IXMLDOMElementPtr pElem;
    TCHAR chBuffer[255];

    HRESULT hr = m_pDocument.CreateInstance(L"MSXML.FreeThreadedDOMDocument");
    ASSERT(ERROR_SUCCESS == hr);

    pElem = m_pDocument->createElement(L"CARDVIDEO");
    pRoot = m_pDocument->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"BITRATE");
    pElem->text = (LPCTSTR)m_sBitRate;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"FILENAME");
    pElem->text = (LPCTSTR)m_sFileName;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"MPEGFORMAT");
    pElem->text = (LPCTSTR)m_sMPEGFormat;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"CARDID");
    pElem->text = (LPCTSTR)m_sCardId;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"ROOMID");
    pElem->text = _ltot(m_nRoomId,chBuffer,10);
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"TIMESTART");
    pElem->text = (LPCTSTR)m_odtStart.Format(_T("%m-%d-%Y %H:%M:%S"));
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"TIMESTOP");
    pElem->text = (LPCTSTR)m_odtStop.Format(_T("%m-%d-%Y %H:%M:%S"));
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"DURATION");
    pElem->text = _ltot(m_nDuration,chBuffer,10);
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"VIDEOSTORAGESERVERID");
    pElem->text = _ltot(m_nVideoStorageServerId,chBuffer,10);
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"STREAMINGENCODERID");
    pElem->text = _ltot(m_nStreamingEncoderId,chBuffer,10);
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"SESSIONID");
    pElem->text = (LPCTSTR)m_sSessionId;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"SESSIONNAME");
    pElem->text = (LPCTSTR)m_sSessionName;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"DISPLAYNAME");
    pElem->text = (LPCTSTR)m_sDisplayName;
    pRoot->appendChild(pElem);
    pElem.Release();

    pElem = m_pDocument->createElement(L"FILETITLE");
    pElem->text = (LPCTSTR)m_sFileTitle;
    pRoot->appendChild(pElem);
    pElem.Release();
    return false;
}
예제 #5
0
void CMeta::Save(MSXML::IXMLDOMElementPtr pRoot)
{
	MSXML::IXMLDOMElementPtr pGO;
	MSXML::IXMLDOMElementPtr pStatic;
	MSXML::IXMLDOMElementPtr pDynamic;
	MSXML::IXMLDOMElementPtr pAttr;
    _variant_t val;

	MSXML::IXMLDOMDocumentPtr pDoc=pRoot->ownerDocument;
    
    //add a graphy object
    pGO=pDoc->createElement(L"go");    
    val.vt=VT_BSTR;
    val.bstrVal=::SysAllocString(L"meta");
    pGO->setAttribute(L"type",val);
    pRoot->appendChild(pGO);

    //add a group static attribution
    pStatic=pDoc->createElement(L"static");
    pGO->appendChild(pStatic);
    
    //position
    pAttr=pDoc->createElement(L"position");
    pStatic->appendChild(pAttr);
    //x1
    val.vt=VT_I4;
    val.lVal=m_lx1;
    pAttr->setAttribute(L"x1",val);
    //y1
    val.vt=VT_I4;
    val.lVal=m_ly1;
    pAttr->setAttribute(L"y1",val);
    //x2
    val.vt=VT_I4;
    val.lVal=m_lx2;
    pAttr->setAttribute(L"x2",val);
    //y2
    val.vt=VT_I4;
    val.lVal=m_ly2;
    pAttr->setAttribute(L"y2",val);

    //picture file
    pAttr=pDoc->createElement("file");
    pStatic->appendChild(pAttr);
    val.vt=VT_BSTR;
    val.bstrVal=m_sPicFile.AllocSysString();
    pAttr->setAttribute(L"path",val);

    //if linked then save dynamic attribution
    pDynamic=pDoc->createElement("dynamic");
    pGO->appendChild(pDynamic);
    if(m_DnyAttr.m_Linked){
        //linked
        val.vt=VT_BOOL;
        val.boolVal=-1;
        pDynamic->setAttribute(L"linked",val);
        //save dynamic attribution
        m_DnyAttr.Save(pDoc,pDynamic);
    }else{
        //unlinked
        val.vt=VT_BOOL;
        val.boolVal=FALSE;
        pDynamic->setAttribute(L"linked",val);
    }
}
HRESULT touchmind::converter::NodeModelXMLEncoder::Encode(IN std::shared_ptr<touchmind::model::node::NodeModel> node,
                                                          IN MSXML::IXMLDOMDocumentPtr pXMLDoc,
                                                          OUT MSXML::IXMLDOMElementPtr &xmlNodeElement) {
  HRESULT hr = S_OK;
  try {
    // id
    std::wstring ws_idValue;
    touchmind::NodeIdToString(node->GetId(), ws_idValue);
    _variant_t v_idValue(ws_idValue.c_str());
    xmlNodeElement->setAttribute(s_id, v_idValue);

    // position
    if (node->GetPosition() == NODE_SIDE_LEFT) {
      xmlNodeElement->setAttribute(s_position, v_positionLeftValue);
    } else if (node->GetPosition() == NODE_SIDE_RIGHT) {
      xmlNodeElement->setAttribute(s_position, v_positionRightValue);
    }

    // created time
    std::wstring ws_createdTime;
    touchmind::SystemtimeToString(&node->GetCreatedTime(), ws_createdTime);
    _variant_t v_createdTimeValue(ws_createdTime.c_str());
    xmlNodeElement->setAttribute(s_createdTime, v_createdTimeValue);

    // modified time
    std::wstring ws_modifiedTime;
    touchmind::SystemtimeToString(&node->GetModifiedTime(), ws_modifiedTime);
    _variant_t v_modifiedTimeValue(ws_modifiedTime.c_str());
    xmlNodeElement->setAttribute(s_modifiedTime, v_modifiedTimeValue);

    // width
    std::wstring ws_width;
    touchmind::SizeToString(node->GetWidth(), ws_width);
    _variant_t v_width(ws_width.c_str());
    xmlNodeElement->setAttribute(s_width, v_width);

    // height
    std::wstring ws_height;
    touchmind::SizeToString(node->GetHeight(), ws_height);
    _variant_t v_height(ws_height.c_str());
    xmlNodeElement->setAttribute(s_height, v_height);

    // background color
    if (!touchmind::util::ColorUtil::Equal(node->GetBackgroundColor(), D2D1::ColorF(D2D1::ColorF::White))) {
      std::wstring ws_backgroundColorValue;
      // touchmind::ColorrefToString(touchmind::util::ColorUtil::ToColorref(node->GetBackgroundColor()),
      // ws_backgroundColorValue);
      touchmind::ColorFToString(node->GetBackgroundColor(), ws_backgroundColorValue);
      _variant_t v_backgroundColorValue(ws_backgroundColorValue.c_str());
      xmlNodeElement->setAttribute(s_backgroundColor, v_backgroundColorValue);
    }

    // shape
    if (node->GetNodeShape() != prop::NodeShape::GetDefaultNodeShape()) {
      std::wstring ws_nodeShape = prop::NodeShape::ToString(node->GetNodeShape());
      _variant_t v_nodeShape(ws_nodeShape.c_str());
      xmlNodeElement->setAttribute(s_shape, v_nodeShape);
    }

    xmlNodeElement->setAttribute(s_height, v_height);
    // text element
    MSXML::IXMLDOMElementPtr xmlTextElement = pXMLDoc->createElement(s_text);
    xmlNodeElement->appendChild(xmlTextElement);

    // text
    _bstr_t s_textValue(node->GetText().c_str());
    MSXML::IXMLDOMTextPtr pText = pXMLDoc->createTextNode(s_textValue);
    xmlTextElement->appendChild(pText);

    if (node->GetFontAttributeCount() > 0) {
      // fontAttriutes element
      MSXML::IXMLDOMElementPtr xmlFontAttributesElement = pXMLDoc->createElement(s_fontAttributes);
      xmlTextElement->appendChild(xmlFontAttributesElement);

      for (size_t i = 0; i < node->GetFontAttributeCount(); ++i) {
        // fontAttribute
        MSXML::IXMLDOMElementPtr xmlFontAttributeElement = pXMLDoc->createElement(s_fontAttribute);
        xmlFontAttributesElement->appendChild(xmlFontAttributeElement);

        // start position
        wchar_t buf[1024];
        _ltow_s(node->GetFontAttribute(i).startPosition, buf, 1024, 10);
        _variant_t v_startPositionValue(buf);
        xmlFontAttributeElement->setAttribute(s_startPosition, v_startPositionValue);

        // length
        _ltow_s(node->GetFontAttribute(i).length, buf, 1024, 10);
        _variant_t v_lengthValue(buf);
        xmlFontAttributeElement->setAttribute(s_length, v_lengthValue);

        // font family
        if (node->GetFontAttribute(i).fontFamilyName.length() > 0) {
          _variant_t v_fontFamilyValue(node->GetFontAttribute(i).fontFamilyName.c_str());
          xmlFontAttributeElement->setAttribute(s_fontFamily, v_fontFamilyValue);
        }

        // font size
        if (node->GetFontAttribute(i).fontSize > 0.0f) {
          std::wstring ws_fontSizeValue;
          touchmind::FontSizeToString(node->GetFontAttribute(i).fontSize, ws_fontSizeValue);
          _variant_t v_fontSizeValue(ws_fontSizeValue.c_str());
          xmlFontAttributeElement->setAttribute(s_fontSize, v_fontSizeValue);
        }

        // bold
        if (node->GetFontAttribute(i).bold) {
          xmlFontAttributeElement->setAttribute(s_bold, v_boolTrueValue);
        }

        // italic
        if (node->GetFontAttribute(i).italic) {
          xmlFontAttributeElement->setAttribute(s_italic, v_boolTrueValue);
        }

        // underline
        if (node->GetFontAttribute(i).underline) {
          xmlFontAttributeElement->setAttribute(s_underline, v_boolTrueValue);
        }

        // strikethrough
        if (node->GetFontAttribute(i).strikethrough) {
          xmlFontAttributeElement->setAttribute(s_strikethrough, v_boolTrueValue);
        }

        // foreground color
        if (node->GetFontAttribute(i).foregroundColor
            != static_cast<LONG>(touchmind::text::FontAttributeCommand::DEFAULT_FONT_COLOR)) {
          std::wstring ws_foregroundColorValue;
          touchmind::ColorrefToString(node->GetFontAttribute(i).foregroundColor, ws_foregroundColorValue);
          _variant_t v_foregroundColorValue(ws_foregroundColorValue.c_str());
          xmlFontAttributeElement->setAttribute(s_foregroundColor, v_foregroundColorValue);
        }
      }
    }

    {
      bool hasOutput = false;
      // ***** path *****
      auto path = node->GetPathModel();
      // path
      MSXML::IXMLDOMElementPtr xmlPathElement = pXMLDoc->createElement(s_path);

      // path width
      if (path->GetWidth() != LINE_WIDTH_1) {
        std::wstring ws_pathWidth = prop::LineWidth::ToString(path->GetWidth());
        _variant_t v_pathWidth(ws_pathWidth.c_str());
        xmlPathElement->setAttribute(s_width, v_pathWidth);
        hasOutput = true;
      }

      // path color
      if (!touchmind::util::ColorUtil::Equal(path->GetColor(), D2D1::ColorF(D2D1::ColorF::Black))) {
        std::wstring ws_colorValue;
        touchmind::ColorFToString(path->GetColor(), ws_colorValue);
        _variant_t v_colorValue(ws_colorValue.c_str());
        xmlPathElement->setAttribute(s_color, v_colorValue);
        hasOutput = true;
      }

      // path style
      if (path->GetStyle() != LINE_STYLE_SOLID) {
        std::wstring ws_pathStyle = prop::LineStyle::ToString(path->GetStyle());
        _variant_t v_pathStyle(ws_pathStyle.c_str());
        xmlPathElement->setAttribute(s_style, v_pathStyle);
        hasOutput = true;
      }

      if (hasOutput) {
        xmlNodeElement->appendChild(xmlPathElement);
      }
    }

    for (size_t i = 0; i < node->GetNumberOfLinks(); ++i) {
      auto wlink = node->GetLink(i);
      if (!wlink.expired()) {
        auto link = wlink.lock();
        if (link->GetNode(EDGE_ID_1) == node) {
          MSXML::IXMLDOMElementPtr xmlLinkElement = pXMLDoc->createElement(s_link);
          xmlNodeElement->appendChild(xmlLinkElement);

          // destination
          std::wstring ws_idValue;
          touchmind::NodeIdToString(link->GetNode(EDGE_ID_2)->GetId(), ws_idValue);
          _variant_t v_idValue(ws_idValue.c_str());
          xmlLinkElement->setAttribute(s_destination, v_idValue);

          // link width
          std::wstring ws_linkWidth = prop::LineWidth::ToString(link->GetLineWidth());
          _variant_t v_linkWidth(ws_linkWidth.c_str());
          xmlLinkElement->setAttribute(s_width, v_linkWidth);

          // link color
          if (!touchmind::util::ColorUtil::Equal(link->GetLineColor(), D2D1::ColorF(D2D1::ColorF::Black))) {
            std::wstring ws_colorValue;
            touchmind::ColorFToString(link->GetLineColor(), ws_colorValue);
            _variant_t v_colorValue(ws_colorValue.c_str());
            xmlLinkElement->setAttribute(s_color, v_colorValue);
          }

          // link style
          std::wstring ws_lineStyle = prop::LineStyle::ToString(link->GetLineStyle());
          _variant_t v_lineStyle(ws_lineStyle.c_str());
          xmlLinkElement->setAttribute(s_style, v_lineStyle);

          // link edge style 1
          std::wstring ws_edgeStyle1 = prop::LineEdgeStyle::ToString(link->GetEdge(EDGE_ID_1)->GetStyle());
          _variant_t v_edgeStyle1(ws_edgeStyle1.c_str());
          xmlLinkElement->setAttribute(s_startStyle, v_edgeStyle1);

          // link edge style 2
          std::wstring ws_edgeStyle2 = prop::LineEdgeStyle::ToString(link->GetEdge(EDGE_ID_2)->GetStyle());
          _variant_t v_edgeStyle2(ws_edgeStyle2.c_str());
          xmlLinkElement->setAttribute(s_endStyle, v_edgeStyle2);

          // handle 1
          std::wstring ws_handle1;
          HandleToString(link->GetEdge(EDGE_ID_1)->GetAngle(), link->GetEdge(EDGE_ID_1)->GetLength(), ws_handle1);
          _variant_t v_handle1(ws_handle1.c_str());
          xmlLinkElement->setAttribute(s_startHandle, v_handle1);

          // handle 2
          std::wstring ws_handle2;
          HandleToString(link->GetEdge(EDGE_ID_2)->GetAngle(), link->GetEdge(EDGE_ID_2)->GetLength(), ws_handle2);
          _variant_t v_handle2(ws_handle2.c_str());
          xmlLinkElement->setAttribute(s_endHandle, v_handle2);
        }
      }
    }

    for (size_t i = 0; i < node->GetActualChildrenCount(); ++i) {
      std::shared_ptr<touchmind::model::node::NodeModel> child = node->GetChild(i);
      MSXML::IXMLDOMElementPtr xmlChildNodeElement = pXMLDoc->createElement(s_node);
      xmlNodeElement->appendChild(xmlChildNodeElement);
      Encode(child, pXMLDoc, xmlChildNodeElement);
    }

  } catch (_com_error &errorObject) {
    LOG(SEVERITY_LEVEL_ERROR) << "Exception thrown, HRESULT: " << errorObject.Error();
    return errorObject.Error();
  }

  return hr;
}