TnbXml.h

[詳解]

#pragma once
#include "TnbStr.h"
#ifndef _TnbDOXYGEN //Document作成用シンボル
  #ifndef _TnbXML_MsXml6_ENABLE
    #import <msxml.dll> rename("value", "Value")
  #else
    #include "TnbDynamicFunc.h"
    #import "msxml6.dll" rename("value", "Value")
    #define MSXML MSXML2
  #endif
#endif
 
#if ! defined(__MSVCPP6__) && ! defined(_UNICODE)
 #pragma comment(lib,"comsuppw.lib")
 #pragma comment(lib,"comsuppwd.lib")
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
typedef MSXML::IXMLDOMNodePtr CXmlNodePtr;
 
 
 
class CXmlNodeList
{
public:
 
    enum ENodeType
    {
        ELEMENT,    
        TEXT,       
        COMMENT,    
    };
 
private:
 
    MSXML::IXMLDOMNodeListPtr   m_pNodes;   
    CXmlNodePtr                 m_pParent;  
    MSXML::IXMLDOMDocumentPtr   m_pDoc;     
 
    CXmlNodePtr m_MakeNewNode(ENodeType type, LPCTSTR text)
    {
        if ( m_pDoc == NULL )
        {
            m_pDoc = m_pParent->GetownerDocument();
        }
        CXmlNodePtr n = NULL;
        _bstr_t str = text;
        switch ( type )
        {
        case ELEMENT:
            n = m_pDoc->createElement(str);
            break;
        case TEXT:
            n = m_pDoc->createTextNode(str);
            break;
        case COMMENT:
        default:
            n = m_pDoc->createComment(str);
            break;
        }
        return n;
    }
 
public:
 
    CXmlNodeList(MSXML::IXMLDOMNodeListPtr na, CXmlNodePtr pp, MSXML::IXMLDOMDocumentPtr dc = NULL)
        : m_pNodes(na), m_pParent(pp), m_pDoc(dc)
    {
    }
 
    bool IsValid(void) const
    {
        return m_pNodes != NULL;
    }
 
    MSXML::IXMLDOMNodeListPtr operator->(void)
    {
        return m_pNodes;
    }
 
    size_t GetLength(void) const
    {
        return m_pNodes->Getlength();
    }
 
    CXmlNodePtr GetNode(INDEX index) const
    {
        return m_pNodes->Getitem(static_cast<long>(index));
    }
 
    MSXML::DOMNodeType GetNodeType(INDEX index) const
    {
        return GetNode(index)->GetnodeType();
    }
 
    CXmlNodePtr AppendNode(CXmlNodePtr newItem)
    {
        return m_pParent->appendChild(newItem);
    }
 
    CXmlNodePtr AppendNode(ENodeType type, LPCTSTR text)
    {
        return AppendNode(m_MakeNewNode(type, text));
    }
 
    CXmlNodePtr InsertNode(INDEX index, CXmlNodePtr newItem)
    {
        if ( GetLength() > index )
        {
            return m_pParent->insertBefore(newItem, GetNode(index).GetInterfacePtr());
        }
        return m_pParent->appendChild(newItem);
    }
 
    CXmlNodePtr InsertNode(INDEX index, ENodeType type, LPCTSTR text)
    {
        return InsertNode(index, m_MakeNewNode(type, text));
    }
 
    void ReplaceNode(INDEX index1, INDEX index2)
    {
        m_pParent->replaceChild(GetNode(index1), GetNode(index2));
    }
 
    void RemoveNode(INDEX index)
    {
        m_pParent->removeChild(GetNode(index));
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlAttribute
{
    MSXML::IXMLDOMAttributePtr m_pAttr; 
 
public:
 
    CXmlAttribute(MSXML::IXMLDOMAttributePtr p) : m_pAttr(p)
    {
    }
 
    bool IsValid(void) const
    {
        return m_pAttr != NULL;
    }
 
    MSXML::IXMLDOMAttributePtr operator->(void)
    {
        return m_pAttr;
    }
 
    CStr GetName(void) const
    {
        _bstr_t r = m_pAttr->Getname();
        return CStr(LPCTSTR(r));
    }
 
    CStr GetValue(void) const
    {
        _bstr_t r = m_pAttr->GetValue();
        return CStr(LPCTSTR(r));
    }
 
    void PutValue(LPCTSTR text)
    {
        m_pAttr->PutValue(text);
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CAbstractXmlNode
{
    HRESULT     m_initRes;  
protected:
 
    CXmlNodePtr m_pNode;    
 
    CAbstractXmlNode(CXmlNodePtr p) : m_pNode(p)
    {
        m_initRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
    }
 
    virtual ~CAbstractXmlNode(void)
    {
        if ( m_initRes == S_OK )
        {
            ::CoUninitialize();
        }
    }
 
public:
 
    CXmlNodePtr operator->(void)
    {
        return m_pNode;
    }
 
    bool IsValid(void) const
    {
        return m_pNode != NULL;
    }
 
    void Invalid(void)
    {
        m_pNode = NULL;
    }
 
    CStr GetNodeName(void) const
    {
        if ( ! IsValid() ) { return CStr(); }
        _bstr_t r = m_pNode->GetnodeName();
        return LPCTSTR(r);
    }
 
    CStr GetNodeValue(void) const
    {
        if ( ! IsValid() ) { return CStr(); }
        _bstr_t r = m_pNode->GetnodeValue();
        return LPCTSTR(r);
    }
 
    void Remove(void)
    {
        m_pNode->GetparentNode()->removeChild(m_pNode);
        m_pNode = NULL;
    }
 
    CXmlNodePtr GetParentNode(void) const
    {
        return IsValid() ? m_pNode->GetparentNode() : NULL;
    }   
 
    CXmlNodePtr GetNextSibling(void) const
    {
        return IsValid() ? m_pNode->GetnextSibling() : NULL;
    }   
 
    CStr GetElementFullPath(void) const
    {
        CStr str;
        if ( IsValid() ) 
        {
            CXmlNodePtr n = m_pNode->GetparentNode();
            while ( n != NULL )
            {
                if ( n->GetnodeType() == MSXML::NODE_DOCUMENT )
                {
                    break;
                }
                str = CStr::Fmt(_T("/%s%s"), LPCTSTR(n->GetnodeName()), str);
                n = n->GetparentNode();
            }
        }
        return str;
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlNode : public CAbstractXmlNode
{
    DEFSUPER(CAbstractXmlNode);
public:
 
    CXmlNode(CXmlNodePtr p) : _super(p)
    {
    }
 
    MSXML::DOMNodeType GetNodeType(void) const
    {
        return IsValid() ? m_pNode->GetnodeType() : MSXML::DOMNodeType(MSXML::NODE_INVALID);
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlText : public CAbstractXmlNode
{
    DEFSUPER(CAbstractXmlNode);
public:
 
    CXmlText(void) : _super(NULL)
    {
    }
 
    CXmlText(CXmlNode n) : _super(NULL)
    {
        if ( n.GetNodeType() == MSXML::NODE_TEXT )
        {
            m_pNode = n.operator ->();
        }
    }
 
    CXmlText& operator=(CXmlNode n)
    {
        if ( n.GetNodeType() == MSXML::NODE_TEXT )
        {
            m_pNode = n.operator ->();
        }
        else
        {
            m_pNode = NULL;
        }
        return *this;
    }
 
    CStr GetText(void) const
    {
        return GetNodeValue();
    }
 
    void Rename(LPCTSTR newName)
    {
        if ( GetText().IsEqual(newName) )
        {
            return;
        }
        CXmlNodePtr n = m_pNode->GetownerDocument()->createTextNode(newName);
        m_pNode->GetparentNode()->replaceChild(n, m_pNode);
        m_pNode = n;
    }
 
    CXmlText Clone(void) const
    {
        return m_pNode->cloneNode(VARIANT_FALSE);
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlComment : public CAbstractXmlNode
{
    DEFSUPER(CAbstractXmlNode);
public:
 
    CXmlComment(void) : _super(NULL)
    {
    }
 
    CXmlComment(CXmlNode n) : _super(NULL)
    {
        if ( n.GetNodeType() == MSXML::NODE_COMMENT )
        {
            m_pNode = n.operator ->();
        }
    }
 
    CXmlComment& operator=(CXmlNode n)
    {
        if ( n.GetNodeType() == MSXML::NODE_COMMENT )
        {
            m_pNode = n.operator ->();
        }
        else
        {
            m_pNode = NULL;
        }
        return *this;
    }
 
    CStr GetComment(void) const
    {
        return GetNodeValue();
    }
 
    void Rename(LPCTSTR newName)
    {
        if ( GetComment().IsEqual(newName) )
        {
            return;
        }
        CXmlNodePtr n = m_pNode->GetownerDocument()->createComment(newName);
        m_pNode->GetparentNode()->replaceChild(n, m_pNode);
        m_pNode = n;
    }
 
    CXmlComment Clone(void) const
    {
        return m_pNode->cloneNode(VARIANT_FALSE);
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlProcessingInstruction : public CAbstractXmlNode
{
    DEFSUPER(CAbstractXmlNode);
protected:
 
    MSXML::IXMLDOMNamedNodeMapPtr   m_pAttr;    
 
public:
 
    CXmlProcessingInstruction(void) : _super(NULL), m_pAttr(NULL)
    {
    }
 
    CXmlProcessingInstruction(CXmlNode n) : _super(NULL), m_pAttr(NULL)
    {
        if ( n.GetNodeType() == MSXML::NODE_PROCESSING_INSTRUCTION )
        {
            m_pNode = n.operator ->();
            m_pAttr = m_pNode->Getattributes();
        }
    }
 
    CXmlProcessingInstruction& operator=(CXmlNode n)
    {
        if ( n.GetNodeType() == MSXML::NODE_PROCESSING_INSTRUCTION )
        {
            m_pNode = n.operator ->();
            m_pAttr = m_pNode->Getattributes();
        }
        else
        {
            m_pNode = NULL;
            m_pAttr = NULL;
        }
        return *this;
    }
 
    long GetAttributeLength(void) const
    {
        if ( m_pAttr != NULL )
        {
            return m_pAttr->Getlength();
        }
        return 0;
    }
 
    CXmlAttribute GetAttribute(INDEX index) const
    {
        if ( m_pAttr != NULL )
        {
            return m_pAttr->Getitem(static_cast<long>(index));
        }
        return CXmlAttribute(NULL);
    }
 
    CXmlAttribute GetAttributeByName(LPCTSTR name) const
    {
        if ( m_pAttr != NULL )
        {
            return m_pAttr->getNamedItem(name);
        }
        return CXmlAttribute(NULL);
    }
 
    CStr GetAttributeValue(LPCTSTR name) const
    {
        CXmlAttribute a = GetAttributeByName(name);
        return a.IsValid() ? a.GetValue() : CStr();
    }
 
    CXmlAttribute SetAttribute(LPCTSTR name, LPCTSTR value)
    {
        if ( IsValid() && m_pAttr != NULL )
        {
            MSXML::IXMLDOMDocumentPtr pDoc = m_pNode->GetownerDocument();
            MSXML::IXMLDOMAttributePtr p = pDoc->createAttribute(name);
            p->PutValue(value);
            return m_pAttr->setNamedItem(p);
        }
        return CXmlAttribute(NULL);
    }
 
    bool RemoveAttribute(LPCTSTR name)
    {
        if ( m_pAttr != NULL )
        {
            CXmlNodePtr p = m_pAttr->removeNamedItem(name);
            return p != NULL;
        }
        return false;
    }
 
private:
    friend class CXmlTest;
};
 
 
 
class CXmlElement : public CXmlProcessingInstruction
{
    DEFSUPER(CXmlProcessingInstruction);
public:
 
    CXmlElement(void) : _super()
    {
    }
 
    CXmlElement(CXmlNode n) : _super()
    {
        if ( n.GetNodeType() == MSXML::NODE_ELEMENT )
        {
            m_pNode = n.operator ->();
            m_pAttr = m_pNode->Getattributes();
        }
    }
 
    CXmlElement& operator=(CXmlNode n)
    {
        if ( n.GetNodeType() == MSXML::NODE_ELEMENT )
        {
            m_pNode = n.operator ->();
            m_pAttr = m_pNode->Getattributes();
        }
        else
        {
            m_pNode = NULL;
            m_pAttr = NULL;
        }
        return *this;
    }
 
    void Rename(LPCTSTR newName)
    {
        if ( GetNodeName().IsEqual(newName) )
        {
            return;
        }
        CXmlNodePtr n = m_pNode->GetownerDocument()->createElement(newName);
        // 属性引越し
        MSXML::IXMLDOMNamedNodeMapPtr pOldAttrList = m_pNode->Getattributes();
        if ( NULL != pOldAttrList )             
        {
            MSXML::IXMLDOMNamedNodeMapPtr pNewAttrList = n->Getattributes();
            MSXML::IXMLDOMAttributePtr pAttr;
            while ( (pAttr = pOldAttrList->nextNode()) != NULL )
            {
                pNewAttrList->setNamedItem(pAttr->cloneNode(VARIANT_TRUE));
            }
        }
        // ノード引越し
        MSXML::IXMLDOMNodePtr pChild;
        while ( (pChild = m_pNode->GetfirstChild()) != NULL )
        {
            n->appendChild(pChild);
        }
        // 入れ替え
        MSXML::IXMLDOMNodePtr p = m_pNode->GetparentNode();
        p->replaceChild(n, m_pNode);
        m_pNode = n;
    }
 
    bool HasChildNodes(void) const
    {
        if ( ! IsValid() ) { return false; }
        return VARIANT_FALSE != m_pNode->hasChildNodes();
    }
 
    CXmlNode GetFirstChild(void) const
    {
        return m_pNode->GetfirstChild();
    }
 
    CXmlNodeList GetChildNodes(void) const
    {
        return CXmlNodeList(m_pNode->GetchildNodes(), m_pNode);
    }
 
    CXmlNodeList SelectNodes(LPCTSTR expression) const
    {
        return CXmlNodeList(m_pNode->selectNodes(expression), m_pNode);
    }
 
    CXmlNode SelectSingleNode(LPCTSTR expression) const
    {
        return CXmlNode(m_pNode->selectSingleNode(expression));
    }
    
    CXmlElement GetParentNode(void) const
    {
        return m_pNode->GetparentNode();
    }
 
    CXmlNode Clone(bool boIsDeep = true) const
    {
        return m_pNode->cloneNode(boIsDeep ? VARIANT_TRUE : VARIANT_FALSE);
    }
 
    CXmlComment AppendChildComment(LPCTSTR text)
    {
        return GetChildNodes().AppendNode(CXmlNodeList::COMMENT, text);
    }
 
    CXmlText AppendChildText(LPCTSTR text)
    {
        return GetChildNodes().AppendNode(CXmlNodeList::TEXT, text);
    }
 
    CXmlElement AppendChildElement(LPCTSTR text)
    {
        return GetChildNodes().AppendNode(CXmlNodeList::ELEMENT, text);
    }
 
    CXmlNode AppendChildNode(CAbstractXmlNode& a)
    {
        return m_pNode->appendChild(a.operator ->());
    }
 
private:
    friend class CXmlTest;
};
    
    
    
class CXmlDocumentFragment : public CXmlElement
{
    DEFSUPER(CXmlElement);
public:
 
    CXmlDocumentFragment(MSXML::IXMLDOMDocumentFragmentPtr n) : _super()
    {
        if ( n->GetnodeType() == MSXML::NODE_DOCUMENT_FRAGMENT )
        {
            m_pNode = n;
            m_pAttr = m_pNode->Getattributes();
        }
    }
};
 
 
 
class CXmlDocument
{
    MSXML::IXMLDOMDocumentPtr   m_pDoc;     
    HRESULT                     m_initRes;  
    void m_Release(void)
    {
        m_pDoc = NULL;
    }
    void m_Init(void)
    {
        m_Release();
#ifndef _TnbXML_MsXml6_ENABLE
        MSXML::IXMLDOMDocumentPtr p(__uuidof(MSXML::DOMDocument));
#else
        MSXML::IXMLDOMDocumentPtr p(__uuidof(MSXML::DOMDocument60));
#endif
        m_pDoc = p;
        p->put_async(VARIANT_FALSE);
    }
    bool m_Load(LPCTSTR text, bool isFile)
    {
        m_Init();
        _bstr_t bstr = text;
        VARIANT_BOOL varResult;
        if ( isFile )
        {
            varResult = m_pDoc->load(_variant_t(bstr));
        }
        else
        {
            varResult = m_pDoc->loadXML(bstr);
        }
        bool r = ( VARIANT_FALSE != varResult );
        if ( ! r )
        {
            Invalid();
        }
        return r;
    }
 
public:
 
    CXmlDocument(void) : m_pDoc(NULL)
    {
        m_initRes = ::CoInitializeEx(NULL, COINIT_MULTITHREADED);
    }
 
    virtual ~CXmlDocument(void)
    {
        m_Release();
        if ( m_initRes == S_OK )
        {
            ::CoUninitialize();
        }
    }
 
    bool IsValid(void) const
    {
        return m_pDoc != NULL;
    }
 
    void Invalid(void)
    {
        m_pDoc = NULL;
    }
 
    DWORD GetLastError(void) const
    {
        return m_pDoc->GetparseError()->GeterrorCode();
    }
 
    CStr GetLastErrorString(void) const
    {
        CStr r;
        MSXML::IXMLDOMParseErrorPtr pError = m_pDoc->GetparseError();
        if ( pError->GeterrorCode() != 0 )
        {
            _bstr_t bstr = pError->Getreason();
            r = LPCTSTR(bstr);
        }
        return r;
    }
 
    void Initialize(LPCTSTR lpszRootElementName, LPCTSTR lpszComment = NULL, LPCTSTR lpszTarget = NULL, LPCTSTR lpszData = NULL)
    {
        m_Init();
        if ( lpszTarget != NULL && lpszData != NULL )
        {
            CXmlNodePtr pNode = m_pDoc->createProcessingInstruction(lpszTarget, lpszData);
            m_pDoc->appendChild(pNode);
        }
        if ( lpszComment != NULL )
        {
            CXmlNodePtr pNode = m_pDoc->createComment(lpszComment);
            m_pDoc->appendChild(pNode);
        }
        CXmlNodePtr pNode = m_pDoc->createElement(lpszRootElementName);
        m_pDoc->appendChild(pNode);
    }
 
    void InitializeXml(LPCTSTR lpszRootElementName, LPCTSTR lpszComment = NULL)
    {
        m_Init();
        CXmlNodePtr pNode = m_pDoc->createProcessingInstruction(_T("xml"), _T("version='1.0'"));
        m_pDoc->appendChild(pNode);
        if ( lpszComment != NULL )
        {
            CXmlNodePtr pNode = m_pDoc->createComment(lpszComment);
            m_pDoc->appendChild(pNode);
        }
        pNode = m_pDoc->createElement(lpszRootElementName);
        m_pDoc->appendChild(pNode);
    }
 
    bool LoadFile(LPCTSTR lpszFileName)
    {
        return m_Load(lpszFileName, true);
    }
 
    bool LoadXml(LPCTSTR lpszXml)
    {
        return m_Load(lpszXml, false);
    }
 
    bool SaveFile(LPCTSTR lpszFileName, bool boIsUtf8 = true) const
    {
        _bstr_t bstr = lpszFileName;
        CXmlProcessingInstruction pi = GetProcessingInstruction();
        if ( pi.IsValid() )
        {
            pi.SetAttribute(_T("encoding"), (boIsUtf8 ? _T("UTF-8") : _T("SJIS")));
        }
        return SUCCEEDED(m_pDoc->save(bstr));
    }
 
 
#ifdef _TnbXML_MsXml6_ENABLE
 
    bool SaveFileEx(LPCTSTR lpszFileName, bool boIsUtf8 = true) const
    {
        IStreamPtr stream = NULL;
        try
        {
            typedef HRESULT (WINAPI *P_SHCreateStreamOnFileW)(LPCWSTR, DWORD, IStream**);
            CDynamicFuncT<P_SHCreateStreamOnFileW>("shlwapi.dll", "SHCreateStreamOnFileW")()(
                                CUnicode(lpszFileName),
                                STGM_READWRITE | STGM_SHARE_DENY_WRITE | STGM_CREATE,
                                &stream
            );
        }
        catch(CNullPointerException& e)
        {
            e.OnCatch();
            return false;
        }
        if ( stream == NULL )
        {
            return false;
        }
//      MSXML2::IMXWriterPtr wrt(__uuidof(MSXML2::MXXMLWriter));
        MSXML2::IMXWriterPtr wrt(__uuidof(MSXML2::MXXMLWriter60));
        wrt->put_version(L"1.0");
        wrt->put_encoding(boIsUtf8 ? L"UTF-8" : L"SJIS");
        wrt->put_indent(VARIANT_TRUE);
        wrt->Putstandalone(VARIANT_TRUE);
        wrt->put_output(_variant_t(IUnknownPtr(stream).GetInterfacePtr()));
        MSXML2::ISAXXMLReaderPtr rdr(__uuidof(MSXML2::SAXXMLReader60));
//      MSXML2::ISAXXMLReaderPtr rdr(__uuidof(MSXML2::SAXXMLReader));
        rdr->putContentHandler(MSXML2::ISAXContentHandlerPtr(wrt));
        _variant_t vinput = IUnknownPtr(m_pDoc).GetInterfacePtr();
        return SUCCEEDED(rdr->parse(vinput));
    }
 
#endif
 
 
    CStr ToString(void) const
    {
        _bstr_t str = m_pDoc->Getxml();
        return CStr(LPCTSTR(str));
    }
 
    CXmlNodeList GetChildNodes(void) const
    {
        return CXmlNodeList(m_pDoc->GetchildNodes(), m_pDoc, m_pDoc);
    }
 
    CXmlProcessingInstruction GetProcessingInstruction(void) const
    {
        const CXmlNodeList& list = GetChildNodes();
        loop ( i, list.GetLength() )
        {
            if ( list.GetNodeType(i) == MSXML::NODE_PROCESSING_INSTRUCTION )
            {
                return list.GetNode(i);
            }
        }
        return CXmlProcessingInstruction();
    }
 
    CXmlElement GetRootElement(void) const
    {
        const CXmlNodeList& list = GetChildNodes();
        loop ( i, list.GetLength() )
        {
            if ( list.GetNodeType(i) == MSXML::NODE_ELEMENT )
            {
                return list.GetNode(i);
            }
        }
        return CXmlElement();
    }
    
    CXmlDocumentFragment CreateDocumentFragment(void) const
    {
        return CXmlDocumentFragment(m_pDoc->createDocumentFragment());
    }
 
    CXmlNodeList GetElementsByTagName(LPCTSTR name) const
    {
        return CXmlNodeList(m_pDoc->getElementsByTagName(name), m_pDoc, m_pDoc);
    }
 
    CXmlNodeList SelectNodes(LPCTSTR expression) const
    {
        return CXmlNodeList(m_pDoc->selectNodes(expression), m_pDoc, m_pDoc);
    }
 
    CXmlNode SelectSingleNode(LPCTSTR expression) const
    {
        return CXmlNode(m_pDoc->selectSingleNode(expression));
    }
 
private:
    friend class CXmlTest;
};
 
 
 
}; // TNB