xmlcom.cpp

著名的下载软件核心Shareaza

{
	METHOD_PROLOGUE( CXMLCOM, XMLAttribute )
	if ( ppNode == NULL ) return E_INVALIDARG;
	*ppNode = (ISXMLNode*)Wrap( pThis->m_pNode, IID_ISXMLNode );	
	return S_OK;
}

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

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

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

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

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

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

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

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

STDMETHODIMP CXMLCOM::XXMLAttribute::Detach()
{
	METHOD_PROLOGUE( CXMLCOM, XMLAttribute )
	return E_NOTIMPL;
}

STDMETHODIMP CXMLCOM::XXMLAttribute::Clone(ISXMLAttribute FAR* FAR* ppClone)
{
	METHOD_PROLOGUE( CXMLCOM, XMLAttribute )
	if ( ppClone == NULL ) return E_INVALIDARG;
	*ppClone = (ISXMLAttribute*)Wrap( ((CXMLAttribute*)pThis->m_pNode)->Clone(), IID_ISXMLAttribute );
	return S_OK;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOMCol construction

CXMLCOMCol::CXMLCOMCol(CXMLElement* pElement)
{
	m_pElement = pElement;

	EnableDispatch( IID_ISXMLElements );
	EnableDispatch( IID_ISXMLAttributes );
}

CXMLCOMCol::~CXMLCOMCol()
{
}

//////////////////////////////////////////////////////////////////////
// CXMLCOMCol wrapper

ISXMLElements* CXMLCOMCol::WrapElements(CXMLElement* pElement)
{
	CXMLCOMCol* pWrap = new CXMLCOMCol( pElement );

	ISXMLElements* pCom = (ISXMLElements*)pWrap->GetInterface( IID_ISXMLElements, FALSE );
	if ( pCom == NULL ) delete pWrap;

	return pCom;
}

ISXMLAttributes* CXMLCOMCol::WrapAttributes(CXMLElement* pElement)
{
	CXMLCOMCol* pWrap = new CXMLCOMCol( pElement );

	ISXMLAttributes* pCom = (ISXMLAttributes*)pWrap->GetInterface( IID_ISXMLAttributes, FALSE );
	if ( pCom == NULL ) delete pWrap;

	return pCom;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOMCol ISXMLElements

IMPLEMENT_DISPATCH( CXMLCOMCol, XMLElements )

STDMETHODIMP CXMLCOMCol::XXMLElements::get__NewEnum(IUnknown FAR* FAR* ppEnum)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	AddRef();
	*ppEnum = &pThis->m_xEnumVARIANT;
	pThis->m_xEnumVARIANT.m_posCurrent = pThis->m_pElement->GetElementIterator();
	pThis->m_xEnumVARIANT.m_bAttributes = FALSE;
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::get_Item(VARIANT vIndex, ISXMLElement FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	
	CXMLElement* pElement = NULL;

	if ( vIndex.vt == VT_BSTR )
	{
		pElement = pThis->m_pElement->GetElementByName( CString( vIndex.bstrVal ) );
	}
	else
	{
		VARIANT va;
		VariantInit( &va );

		if ( SUCCEEDED( VariantChangeType( &va, (VARIANT FAR*)&vIndex, 0, VT_I4 ) ) )
		{
			for ( POSITION pos = pThis->m_pElement->GetElementIterator() ; pos ; vIndex.lVal-- )
			{
				pElement = pThis->m_pElement->GetNextElement( pos );
				if ( vIndex.lVal == 0 ) break;
				pElement = NULL;
			}
		}
	}                 

	*ppElement = (ISXMLElement*)CXMLCOM::Wrap( pElement, IID_ISXMLElement );

	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::get_Count(LONG FAR* pnCount)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	*pnCount = (LONG)pThis->m_pElement->GetElementCount();
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::Create(BSTR strName, ISXMLElement FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	*ppElement = (ISXMLElement*)CXMLCOM::Wrap( pThis->m_pElement->AddElement( CString( strName ) ), IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::Attach(ISXMLElement FAR* pElement)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	INTERFACE_TO_CLASS( CXMLCOM, XMLElement, pElement, prWrap )
	pThis->m_pElement->AddElement( (CXMLElement*)prWrap->m_pNode );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::RemoveAll()
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	pThis->m_pElement->DeleteAllElements();
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::get_First(ISXMLElement FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	*ppElement = (ISXMLElement*)CXMLCOM::Wrap( pThis->m_pElement->GetFirstElement(), IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLElements::get_ByName(BSTR sName, ISXMLElement FAR* FAR* ppElement)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLElements )
	*ppElement = (ISXMLElement*)CXMLCOM::Wrap( pThis->m_pElement->GetElementByName( CString( sName ) ), IID_ISXMLElement );
	return S_OK;
}

//////////////////////////////////////////////////////////////////////
// CXMLCOMCol ISXMLAttributes

IMPLEMENT_DISPATCH( CXMLCOMCol, XMLAttributes )

STDMETHODIMP CXMLCOMCol::XXMLAttributes::get__NewEnum(IUnknown FAR* FAR* ppEnum)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	AddRef();
	*ppEnum = &pThis->m_xEnumVARIANT;
	pThis->m_xEnumVARIANT.m_posCurrent = pThis->m_pElement->GetAttributeIterator();
	pThis->m_xEnumVARIANT.m_bAttributes = TRUE;
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::get_Item(VARIANT vIndex, ISXMLAttribute FAR* FAR* ppAttribute)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )

	CXMLAttribute* pAttribute = NULL;

	if ( vIndex.vt == VT_BSTR )
	{
		pAttribute = pThis->m_pElement->GetAttribute( CString( vIndex.bstrVal ) );
	}
	else
	{
		VARIANT va;
		VariantInit( &va );

		if ( SUCCEEDED( VariantChangeType( &va, (VARIANT FAR*)&vIndex, 0, VT_I4 ) ) )
		{
			for ( POSITION pos = pThis->m_pElement->GetAttributeIterator() ; pos ; vIndex.lVal-- )
			{
				pAttribute = pThis->m_pElement->GetNextAttribute( pos );
				if ( vIndex.lVal == 0 ) break;
				pAttribute = NULL;
			}
		}
	}                 

	*ppAttribute = (ISXMLAttribute*)CXMLCOM::Wrap( pAttribute, IID_ISXMLAttribute );

	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::get_Count(LONG FAR* pnCount)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	*pnCount = (LONG)pThis->m_pElement->GetAttributeCount();
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::Add(BSTR strName, BSTR strValue)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	pThis->m_pElement->AddAttribute( CString( strName ), CString( strValue ) );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::Create(BSTR strName, ISXMLAttribute FAR* FAR* ppAttribute)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	*ppAttribute = (ISXMLAttribute*)CXMLCOM::Wrap( pThis->m_pElement->AddAttribute( CString( strName ) ), IID_ISXMLElement );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::Attach(ISXMLAttribute FAR* pAttribute)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	INTERFACE_TO_CLASS( CXMLCOM, XMLAttribute, pAttribute, prWrap )
	pThis->m_pElement->AddAttribute( (CXMLAttribute*)prWrap->m_pNode );	
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::RemoveAll()
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	pThis->m_pElement->DeleteAllAttributes();
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::get_ByName(BSTR sName, ISXMLAttribute FAR* FAR* ppAttribute)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	*ppAttribute = (ISXMLAttribute*)CXMLCOM::Wrap( pThis->m_pElement->GetAttribute( CString( sName ) ), IID_ISXMLAttribute );
	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XXMLAttributes::get_Get(BSTR sName, BSTR FAR* psValue)
{
	METHOD_PROLOGUE( CXMLCOMCol, XMLAttributes )
	pThis->m_pElement->GetAttributeValue( CString( sName ) ).SetSysString( psValue );
	return S_OK;
}

/////////////////////////////////////////////////////////////////////////////
// CXMLCOMCol::XEnumVARIANT enumerator

IMPLEMENT_UNKNOWN( CXMLCOMCol, EnumVARIANT )

STDMETHODIMP CXMLCOMCol::XEnumVARIANT::Next(ULONG celt, VARIANT FAR* rgvar, ULONG FAR* pceltFetched)
{
	METHOD_PROLOGUE( CXMLCOMCol, EnumVARIANT )

	ULONG i;

	if ( pceltFetched ) *pceltFetched = 0;
	else if ( celt > 1 ) return E_INVALIDARG;

	for ( i = 0 ; i < celt ; i++ ) VariantInit( &rgvar[i] );

	for ( i = 0 ; i < celt ; i++ )
	{   
		if ( m_bAttributes )
		{
			CXMLAttribute* pAttribute = pThis->m_pElement->GetNextAttribute( m_posCurrent );
			if ( ! pAttribute ) break;

			rgvar[i].vt			= VT_DISPATCH;
			rgvar[i].pdispVal	= (IDispatch*)CXMLCOM::Wrap( pAttribute, IID_ISXMLAttribute );
		}
		else
		{
			CXMLElement* pElement = pThis->m_pElement->GetNextElement( m_posCurrent );
			if ( ! pElement ) break;

			rgvar[i].vt			= VT_DISPATCH;
			rgvar[i].pdispVal	= (IDispatch*)CXMLCOM::Wrap( pElement, IID_ISXMLElement );
		}

		if ( pceltFetched ) (*pceltFetched)++;
	}

	if ( i < celt ) return ResultFromScode( S_FALSE );

	return S_OK;
}

STDMETHODIMP CXMLCOMCol::XEnumVARIANT::Skip(ULONG celt) 
{
    METHOD_PROLOGUE( CXMLCOMCol, EnumVARIANT )

	if ( m_bAttributes )
	{
		while ( celt > 0 && pThis->m_pElement->GetNextAttribute( m_posCurrent ) ) celt--;
	}
	else
	{
		while ( celt > 0 && pThis->m_pElement->GetNextElement( m_posCurrent ) ) celt--;
	}
    
    return ( celt == 0 ? S_OK : ResultFromScode( S_FALSE ) );
}

STDMETHODIMP CXMLCOMCol::XEnumVARIANT::Reset()
{
    METHOD_PROLOGUE( CXMLCOMCol, EnumVARIANT )
	m_posCurrent = m_bAttributes ? pThis->m_pElement->GetAttributeIterator() : pThis->m_pElement->GetElementIterator();
    return S_OK;
}

STDMETHODIMP CXMLCOMCol::XEnumVARIANT::Clone(IEnumVARIANT FAR* FAR* ppenum) 
{
    METHOD_PROLOGUE( CXMLCOMCol, EnumVARIANT )
    return E_NOTIMPL;
}