Symbian

开发平台：
C/C++

arrenum.h：源码内容
							/* ***** BEGIN LICENSE BLOCK ***** 
 * Version: RCSL 1.0/RPSL 1.0 
 *  
 * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
 *      
 * The contents of this file, and the files included with this file, are 
 * subject to the current version of the RealNetworks Public Source License 
 * Version 1.0 (the "RPSL") available at 
 * http://www.helixcommunity.org/content/rpsl unless you have licensed 
 * the file under the RealNetworks Community Source License Version 1.0 
 * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
 * in which case the RCSL will apply. You may also obtain the license terms 
 * directly from RealNetworks.  You may not use this file except in 
 * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
 * applicable to this file, the RCSL.  Please see the applicable RPSL or 
 * RCSL for the rights, obligations and limitations governing use of the 
 * contents of the file.  
 *  
 * This file is part of the Helix DNA Technology. RealNetworks is the 
 * developer of the Original Code and owns the copyrights in the portions 
 * it created. 
 *  
 * This file, and the files included with this file, is distributed and made 
 * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
 * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
 * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
 * 
 * Technology Compatibility Kit Test Suite(s) Location: 
 *    http://www.helixcommunity.org/content/tck 
 * 
 * Contributor(s): 
 *  
 * ***** END LICENSE BLOCK ***** */ 
#include "unkimp.h"
/* This class implements the fragment Enumerator
 */
#define DECLARE_INTERFACE_ARRAY_ENUMERATOR(ENUMERATED, IENUMERATE)	
    class _C##IENUMERATE##IMP                                           
	: public IENUMERATE                                             
	, public CUnknownIMP                                            
    {                                                                   
	DECLARE_UNKNOWN(_C##IENUMERATE##IMP)				
    public:                                                             
	_C##IENUMERATE##IMP()                                           
	    : m_arrpbufData(NULL)                                       
	    , m_ulIndex(0)                                              
	{}                                                              
	~_C##IENUMERATE##IMP()                                          
	{_KillData();}                                                  
	STDMETHOD(Reset)(THIS)                                          
	{                                                               
	    m_ulIndex = 0;                                              
	    return HXR_OK;                                              
	}                                                               
	STDMETHOD(Next)                                                 
	(                                                               
	    THIS_                                                       
	    UINT32          ulNumToReturn,                              
	    ENUMERATED**    ppbufNext,                                  
	    UINT32*         pulNumReturned                              
	)                                                               
	{                                                               
	    if(!ppbufNext || (ulNumToReturn != 1 && pulNumReturned == NULL))    
	    {                                                           
		return HXR_POINTER;                                     
	    }                                                           
	    if(!m_arrpbufData || !m_ulTotal)                            
	    {                                                           
		return HXR_FAIL;                                        
	    }                                                           
	    HX_RESULT pnrRes = HXR_OK;                                  
	    UINT32 ulRemaining = m_ulTotal-m_ulIndex;                   
	    if(ulNumToReturn > ulRemaining)                             
	    {                                                           
		pnrRes = HXR_INCOMPLETE;                                
		ulNumToReturn = ulRemaining;                            
	    }                                                           
	    else                                                        
	    {                                                           
		ulRemaining = ulNumToReturn;                            
	    }                                                           
	    if (pulNumReturned)						
	    {								
		*pulNumReturned = ulNumToReturn;                        
	    }								
	    while(ulRemaining)                                          
	    {                                                           
		(                                                       
		    ppbufNext[ulRemaining-ulNumToReturn]		
		    = m_arrpbufData[m_ulIndex]                          
		)->AddRef();                                            
		++m_ulIndex;                                            
		--ulRemaining;                                          
	    }                                                           
	    return pnrRes;                                              
	}                                                               
	STDMETHOD(Skip)                                                 
	(                                                               
	    THIS_                                                       
	    UINT32 ulNumToSkip                                          
	)                                                               
	{                                                               
	    m_ulIndex += ulNumToSkip;                                   
	    if (m_ulIndex < m_ulTotal)                                  
	    {                                                           
		return HXR_OK;                                            
	    }                                                           
	    m_ulIndex = m_ulTotal;                                      
	    return HXR_FAIL;                                             
	}                                                               
	STDMETHOD(Clone)                                                
	(                                                               
	    THIS_                                                       
	    IENUMERATE** ppefbNew                                       
	)                                                               
	{                                                               
	    ENUMERATED** arrpbufData = NULL;                            
	    if(m_arrpbufData && m_ulTotal)                              
	    {                                                           
		UINT32 ulIndex = 0;                                     
		arrpbufData = (ENUMERATED**)new ENUMERATED*[m_ulTotal];   
		for                                                     
		(                                                       
		    ulIndex = 0;                                        
		    ulIndex < m_ulTotal;                                
		    ++ulIndex                                           
		)                                                       
		{                                                       
		    arrpbufData[ulIndex] = m_arrpbufData[ulIndex];      
		    (arrpbufData[ulIndex])->AddRef();                   
		}                                                       
	    }                                                           
	    _C##IENUMERATE##IMP* pNewEnum = CreateObject();             
	    pNewEnum->_SetData(arrpbufData, m_ulTotal, m_ulIndex);      
	    return pNewEnum->QueryInterface(IID_##IENUMERATE, (void**)ppefbNew);   
	}                                                               
	void _SetData                                                   
	(                                                               
	    ENUMERATED** arrpbufData,                                   
	    UINT32 ulTotal,                                             
	    UINT32 ulIndex = 0                                          
	)                                                               
	{                                                               
	    _KillData();                                                
	    m_arrpbufData = arrpbufData;                                
	    m_ulTotal = ulTotal;                                        
	    m_ulIndex = ulIndex;                                        
	}                                                               
    private:                                                            
	void _KillData()                                                
	{                                                               
	    if(m_arrpbufData)                                           
	    {                                                           
		for                                                     
		(                                                       
		    m_ulIndex = 0;                                      
		    m_ulIndex < m_ulTotal;                              
		    ++m_ulIndex                                         
		)                                                       
		{                                                       
		    (m_arrpbufData[m_ulIndex])->Release();              
		}                                                       
		delete[] m_arrpbufData;                                 
		m_ulIndex = 0;                                          
	    }                                                           
	}                                                               
	ENUMERATED**    m_arrpbufData;                                  
	UINT32          m_ulIndex;                                      
	UINT32          m_ulTotal;                                      
    }                                                                  
#define IMPLEMENT_INTERFACE_ARRAY_ENUMERATOR(IENUMERATE)		
    BEGIN_INTERFACE_LIST(_C##IENUMERATE##IMP)				
	INTERFACE_LIST_ENTRY(IID_##IENUMERATE,  IENUMERATE)		
    END_INTERFACE_LIST
#define CREATE_INTERFACE_ARRAY_ENUMERATOR(IENUMERATE, ARRAY, TOTAL, NEWENUM)        
    {                                                                               
	_C##IENUMERATE##IMP* _pNewEnum = _C##IENUMERATE##IMP::CreateObject();       
	_pNewEnum->_SetData(ARRAY, TOTAL);                                          
	_pNewEnum->QueryInterface(IID_##IENUMERATE, (void**)NEWENUM);   
    }

						