xmlcom.cpp

著名的下载软件核心Shareaza

//
// XMLCOM.cpp
//
// Copyright (c) Shareaza Development Team, 2002-2004.
// This file is part of SHAREAZA (www.shareaza.com)
//
// Shareaza is free software; you can redistribute it
// and/or modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2 of
// the License, or (at your option) any later version.
//
// Shareaza is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Shareaza; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//

#include "StdAfx.h"
#include "Shareaza.h"
#include "XMLCOM.h"
#include "XML.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

BEGIN_INTERFACE_MAP(CXMLCOM, CComObject)
	INTERFACE_PART(CXMLCOM, IID_ISXMLNode, XMLNode)
	INTERFACE_PART(CXMLCOM, IID_ISXMLElement, XMLElement)
	INTERFACE_PART(CXMLCOM, IID_ISXMLAttribute, XMLAttribute)
END_INTERFACE_MAP()

BEGIN_INTERFACE_MAP(CXMLCOMCol, CComObject)
	INTERFACE_PART(CXMLCOMCol, IID_ISXMLElements, XMLElements)
	INTERFACE_PART(CXMLCOMCol, IID_ISXMLAttributes, XMLAttributes)
	INTERFACE_PART(CXMLCOMCol, IID_IEnumVARIANT, EnumVARIANT)
END_INTERFACE_MAP()


//////////////////////////////////////////////////////////////////////
// CXMLCOM construction

CXMLCOM::CXMLCOM(CXMLNode* pNode)
{
	m_pNode = pNode ? pNode : new CXMLElement();

	EnableDispatch( IID_ISXMLNode );
	EnableDispatch( IID_ISXMLElement );
	EnableDispatch( IID_ISXMLAttribute );
}

CXMLCOM::~CXMLCOM()
{
}

//////////////////////////////////////////////////////////////////////
// CXMLCOM wrapper

IUnknown* CXMLCOM::Wrap(CXMLNode* pNode, REFIID pIID)
{
	if ( pNode == NULL ) return NULL;
	
	if ( pIID == IID_ISXMLElement )
	{
		if ( pNode->m_nNode != CXMLNode::xmlElement ) return NULL;
	}
	else if ( pIID == IID_ISXMLAttribute )
	{
		if ( pNode->m_nNode != CXMLNode::xmlAttribute ) return NULL;
	}
	
	CXMLCOM* pWrap = new CXMLCOM( pNode );
	
	IUnknown* pCom = pWrap->GetInterface( pIID, FALSE );
	if ( pCom == NULL ) delete pWrap;
	
	return pCom;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOM unwrapper

CXMLElement* CXMLCOM::Unwrap(ISXMLElement* pInterface)
{
	if ( pInterface == NULL ) return NULL;
	INTERFACE_TO_CLASS(CXMLCOM, XMLElement, pInterface, pWrapper)
	return (CXMLElement*)pWrapper->m_pNode;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOM ISXMLNode

IMPLEMENT_DISPATCH( CXMLCOM, XMLNode )

STDMETHODIMP CXMLCOM::XXMLNode::get_Parent(ISXMLElement FAR* FAR* ppParent)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( ppParent == NULL ) return E_INVALIDARG;
	CXMLElement* pParent = pThis->m_pNode->GetParent();
	if ( pParent )
		*ppParent = (ISXMLElement*)Wrap( pParent, IID_ISXMLElement );
	else
		*ppParent = NULL;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_Type(SXMLNodeType FAR* pnType)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( pnType == NULL ) return E_INVALIDARG;
	*pnType = (SXMLNodeType)pThis->m_pNode->GetType();
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_AsNode(ISXMLNode FAR* FAR* ppNode)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( ppNode == NULL ) return E_INVALIDARG;
	*ppNode = (ISXMLNode*)Wrap( pThis->m_pNode, IID_ISXMLNode );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_AsElement(ISXMLNode FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( ppElement == NULL ) return E_INVALIDARG;
	*ppElement = (ISXMLElement*)Wrap( pThis->m_pNode, IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_AsAttribute(ISXMLNode FAR* FAR* ppAttribute)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( ppAttribute == NULL ) return E_INVALIDARG;
	*ppAttribute = (ISXMLAttribute*)Wrap( pThis->m_pNode, IID_ISXMLAttribute );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_Name(BSTR FAR* psName)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( psName == NULL ) return E_INVALIDARG;
	pThis->m_pNode->GetName().SetSysString( psName );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::put_Name(BSTR sName)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( sName == NULL ) return E_INVALIDARG;
	pThis->m_pNode->SetName( CString( sName ) );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::get_Value(BSTR FAR* psValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( psValue == NULL ) return E_INVALIDARG;
	pThis->m_pNode->GetValue().SetSysString( psValue );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::put_Value(BSTR sValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( sValue == NULL ) return E_INVALIDARG;
	pThis->m_pNode->SetValue( CString( sValue ) );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::Delete()
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	pThis->m_pNode->Delete();
	pThis->m_pNode = NULL;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLNode::IsNamed(BSTR sName, VARIANT_BOOL FAR* pbResult)
{
	METHOD_PROLOGUE( CXMLCOM, XMLNode )
	if ( sName == NULL || pbResult == NULL ) return E_INVALIDARG;
	*pbResult = pThis->m_pNode->IsNamed( CString( sName ) ) ? VARIANT_TRUE : VARIANT_FALSE;
	return S_OK;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOM ISXMLElement

IMPLEMENT_DISPATCH( CXMLCOM, XMLElement )

STDMETHODIMP CXMLCOM::XXMLElement::get_Parent(ISXMLElement FAR* FAR* ppParent)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppParent == NULL ) return E_INVALIDARG;
	CXMLElement* pParent = pThis->m_pNode->GetParent();
	if ( pParent )
		*ppParent = (ISXMLElement*)Wrap( pParent, IID_ISXMLElement );
	else
		*ppParent = NULL;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_Type(SXMLNodeType FAR* pnType)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( pnType == NULL ) return E_INVALIDARG;
	*pnType = (SXMLNodeType)pThis->m_pNode->GetType();
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_AsNode(ISXMLNode FAR* FAR* ppNode)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppNode == NULL ) return E_INVALIDARG;
	*ppNode = (ISXMLNode*)Wrap( pThis->m_pNode, IID_ISXMLNode );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_AsElement(ISXMLNode FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppElement == NULL ) return E_INVALIDARG;
	*ppElement = (ISXMLElement*)Wrap( pThis->m_pNode, IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_AsAttribute(ISXMLNode FAR* FAR* ppAttribute)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppAttribute == NULL ) return E_INVALIDARG;
	*ppAttribute = (ISXMLAttribute*)Wrap( pThis->m_pNode, IID_ISXMLAttribute );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_Name(BSTR FAR* psName)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( psName == NULL ) return E_INVALIDARG;
	pThis->m_pNode->GetName().SetSysString( psName );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::put_Name(BSTR sName)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( sName == NULL ) return E_INVALIDARG;
	pThis->m_pNode->SetName( CString( sName ) );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_Value(BSTR FAR* psValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( psValue == NULL ) return E_INVALIDARG;
	pThis->m_pNode->GetValue().SetSysString( psValue );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::put_Value(BSTR sValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( sValue == NULL ) return E_INVALIDARG;
	pThis->m_pNode->SetValue( CString( sValue ) );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::Delete()
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	pThis->m_pNode->Delete();
	pThis->m_pNode = NULL;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::IsNamed(BSTR sName, VARIANT_BOOL FAR* pbResult)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( sName == NULL || pbResult == NULL ) return E_INVALIDARG;
	*pbResult = pThis->m_pNode->IsNamed( CString( sName ) ) ? VARIANT_TRUE : VARIANT_FALSE;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_Elements(ISXMLElements FAR* FAR* ppElements)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppElements == NULL ) return E_INVALIDARG;
	*ppElements = CXMLCOMCol::WrapElements( (CXMLElement*)pThis->m_pNode );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::get_Attributes(ISXMLAttributes FAR* FAR* ppAttributes)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppAttributes == NULL ) return E_INVALIDARG;
	*ppAttributes = CXMLCOMCol::WrapAttributes( (CXMLElement*)pThis->m_pNode );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::Detach()
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	((CXMLElement*)pThis->m_pNode)->Detach();
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::Clone(ISXMLElement FAR* FAR* ppClone)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( ppClone == NULL ) return E_INVALIDARG;
	*ppClone = (ISXMLElement*)Wrap( ((CXMLElement*)pThis->m_pNode)->Clone(), IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::ToString(BSTR FAR* psValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( psValue == NULL ) return E_INVALIDARG;
	((CXMLElement*)pThis->m_pNode)->ToString().SetSysString( psValue );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::ToStringEx(VARIANT_BOOL bHeader, VARIANT_BOOL bNewlines, BSTR FAR* psValue)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( psValue == NULL ) return E_INVALIDARG;
	((CXMLElement*)pThis->m_pNode)->ToString( (BOOL)bHeader, (BOOL)bNewlines ).SetSysString( psValue );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::FromString(BSTR sXML, ISXMLElement FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( sXML == NULL || ppElement == NULL ) return E_INVALIDARG;
	CXMLElement* pElement = CXMLElement::FromString( CString( sXML ) );
	if ( ! pElement ) return E_FAIL;
	*ppElement = (ISXMLElement*)Wrap( pElement, IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLElement::GetWords(BSTR FAR* psWords)
{
	METHOD_PROLOGUE( CXMLCOM, XMLElement )
	if ( psWords == NULL ) return E_INVALIDARG;
	((CXMLElement*)pThis->m_pNode)->GetRecursiveWords().SetSysString( psWords );
	return S_OK;
}


//////////////////////////////////////////////////////////////////////
// CXMLCOM ISXMLAttribute

IMPLEMENT_DISPATCH( CXMLCOM, XMLAttribute )

STDMETHODIMP CXMLCOM::XXMLAttribute::get_Parent(ISXMLElement FAR* FAR* ppParent)
{
	METHOD_PROLOGUE( CXMLCOM, XMLAttribute )
	if ( ppParent == NULL ) return E_INVALIDARG;
	CXMLElement* pParent = pThis->m_pNode->GetParent();
	if ( pParent )
		*ppParent = (ISXMLElement*)Wrap( pParent, IID_ISXMLElement );
	else
		*ppParent = NULL;
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLAttribute::get_Type(SXMLNodeType FAR* pnType)
{
	METHOD_PROLOGUE( CXMLCOM, XMLAttribute )
	if ( pnType == NULL ) return E_INVALIDARG;
	*pnType = (SXMLNodeType)pThis->m_pNode->GetType();	
	return S_OK;
}

STDMETHODIMP CXMLCOM::XXMLAttribute::get_AsNode(ISXMLNode FAR* FAR* ppNode)