自学教程：C++ HX_RELEASE函数代码示例

HX_RESULT HXCloakedV2TCPSocket::GetAddrInfoDone(HX_RESULT status,                                                UINT32 nVecLen,                                                IHXSockAddr** ppAddrVec){    HX_RESULT res = HXR_FAIL;    HX_ASSERT(0!=m_nProxyPort);    //We are done getting the addr info for the proxy host.    if( SUCCEEDED(status) && 1<=nVecLen )    {        HX_ASSERT(!m_pProxyAddr);        HX_ASSERT(m_pTCPSocket);        HX_RELEASE(m_pProxyAddr);        ppAddrVec[0]->Clone(&m_pProxyAddr);        m_pProxyAddr->SetPort(m_nProxyPort);        if( m_pTCPSocket )        {            res = m_pTCPSocket->ConnectToOne(m_pProxyAddr);        }    }    if( !SUCCEEDED(res) )    {        HX_RELEASE(m_pProxyAddr);    }    //hardcoded because I have no idea what the IHXSocket would do    //with any other return code. Not sure why we return one at all.    return HXR_OK;}

STDMETHODIMP HXCloakedV2TCPSocket::Write(IHXBuffer* pBuffer){    IHXBuffer* pNew      = NULL;    HX_RESULT  res       = HXR_FAIL;    CHXString  GetString = "";        //    HX_ASSERT( csReady == m_CloakingState && pBuffer );//    if( csReady == m_CloakingState && pBuffer )    if( pBuffer )    {        pBuffer->AddRef();        res = _GeneratePostRequest(pBuffer, pNew);        HX_ASSERT(SUCCEEDED(res));        if( SUCCEEDED(res) && pNew )        {            res = m_pTCPSocket->Write(pNew);        }                HX_RELEASE(pBuffer);        HX_RELEASE(pNew);        //We always follow our POST request with a Get request.        GetString = _GenerateGetRequest();        _WriteString(GetString);    }        return res;}

void OutputBuffers(UINT16 ulStreamID, IHXValues* pHdr){    const char* pName = 0;    IHXBuffer* pValue = 0;    HX_RESULT res = pHdr->GetFirstPropertyBuffer(pName, pValue);        while (HXR_OK == res)    {	printf("GetBuffer %u /"%s/" /"", ulStreamID, pName);	UCHAR* pCur = pValue->GetBuffer();	UCHAR* pEnd = pCur + pValue->GetSize();	static const char z_hexChars[] = "0123456789abcdef";	for (;pCur < pEnd; pCur++)	{	    printf("%c%c", z_hexChars[*pCur >> 4], z_hexChars[*pCur & 0xf]);	}	printf("/"/n");		HX_RELEASE(pValue);		res = pHdr->GetNextPropertyBuffer(pName, pValue);    }        HX_RELEASE(pValue);}

void CHXPrefList::SetPreferences(IUnknown* pContext){    IHXPreferences* pPrefs = NULL;    IHXCommonClassFactory* pCCF = NULL;    if (pContext &&        (HXR_OK == pContext->QueryInterface(IID_IHXPreferences,                                            (void**)&pPrefs)) &&        (HXR_OK == pContext->QueryInterface(IID_IHXCommonClassFactory,                                            (void**)&pCCF)))    {        CHXSimpleList::Iterator itr = m_prefInfo.Begin();                for(; itr != m_prefInfo.End(); ++itr)        {            CHXPrefInfo* pInfo = (CHXPrefInfo*)(*itr);                        IHXBuffer* pBuf = NULL;                        if ((HXR_OK == pCCF->CreateInstance(CLSID_IHXBuffer,                                                (void**)&pBuf)) &&                (HXR_OK == pBuf->Set((const unsigned char*)pInfo->Value(),                                     strlen(pInfo->Value()))))            {                pPrefs->WritePref(pInfo->Key(), pBuf);            }            HX_RELEASE(pBuf);        }    }    HX_RELEASE(pPrefs);    HX_RELEASE(pCCF);}

CSymbIHXDataFile::~CSymbIHXDataFile(void){    Close();    HX_RELEASE(m_pFileName);    HX_RELEASE(m_pSessionManager);    HX_RELEASE(m_pContext);}

int DLLAccessClient::open(const char* dllName, 			  UINT16 nLibType, 			  IUnknown* pContext){    HX_RESULT status;    int retVal = DLLAccess::NO_LOAD;    IHXCommonClassFactory* pCCF = NULL;    HX_RELEASE(m_pDllAccessServer);    status = pContext->QueryInterface(IID_IHXCommonClassFactory,				      (void**) &pCCF);    if (SUCCEEDED(status))    {	pCCF->CreateInstance(CLSID_IHXDllAccess,			     (void**) &m_pDllAccessServer);    }    HX_RELEASE(pCCF);    if (m_pDllAccessServer)    {	if (SUCCEEDED(m_pDllAccessServer->Open(dllName, nLibType)))	{	    retVal = DLLAccess::DLL_OK;	}    }        return retVal;}

CAudioOutOpenwave::~CAudioOutOpenwave(){    //We must assume that _Imp_Close has already been called. If not, we are     //in big trouble.    if ( m_wState != RA_AOS_CLOSED )     {        HX_ASSERT( "Device not closed in dtor." == NULL );    }    //Clean up the scheduler.    HX_RELEASE( m_pScheduler );    HX_DELETE(m_pPlaybackCountCBTime);    HX_RELEASE(m_pCallback);    //OpDPRINTF("dtor: Freeing sample buffer, expect an exception/n");    for (int i=0; i<10; i++)    	HX_DELETE(m_SndBuf[i].fSampleBuffer);    //OpDPRINTF("dtor: Done freeing sample buffers /n");    if (m_pSndDev)     {    	//OpDPRINTF("dtor : before freeing the channel/n");	op_sound_unregister_callback(m_pSndDev, iodone_callback);	op_sound_freechan(m_pSndDev);    	//OpDPRINTF("dtor : freeing the channel/n");    }    HX_DELETE(m_pWriteList); // Remove all elements in the list, if any}

HX_RESULT CMP4ADecoder::OpenNext(IHXValues* pHeader,                                 IMP4APayloadFormat* pRssm, 			         IHXAudioDecoder** pOutAudioDecoder,			         IUnknown* pContext){    HX_RESULT retVal = HXR_FAIL;    if (pHeader && pOutAudioDecoder)    {        // Close the decoder        Close();        // Get the mime type        IHXBuffer* pMimeType = NULL;        pHeader->GetPropertyCString("MimeType", pMimeType);        if (pMimeType)        {            m_pDecoderInfo = m_decInfoStore.GetInfoNext((const char*) pMimeType->GetBuffer(), pRssm);            if (m_pDecoderInfo)            {                HX_RELEASE(*pOutAudioDecoder);                retVal = BuildDLLAccessBridge(pOutAudioDecoder, pMimeType, pRssm, pContext);            }        }        HX_RELEASE(pMimeType);    }    return retVal;}

/* * ClientRegTree::RegTreeInit() * * This object is meant to be passed from client to client as the sequential * WMT HTTP requests come in.  Therefore, only one client at a time is  * accessing it (so no mutex needed), but we must ensure that this object has * the context and registry for the current proc.  Thus, it must be init'ed * every time a new client picks it up. */HX_RESULTClientRegTree::RegTreeInit(Client* pClient, IHXBuffer* pStartTime){    HX_RELEASE(m_pContext);    HX_RELEASE(m_pRegistry);    HX_RELEASE(m_pClassFactory);    m_pProc = pClient->proc;        // don't addref/release    m_pProc->pc->server_context->        QueryInterface(IID_IUnknown, (void**) &m_pContext);    m_pContext->QueryInterface(IID_IHXRegistry, (void**) &m_pRegistry);    m_pContext->QueryInterface(IID_IHXCommonClassFactory,                               (void**) &m_pClassFactory);    // The seqnum (session id) is persistent across calls.    // Only set up the registry tree once.    if (!m_ulRegistryConnId)    {        m_ulRegistryConnId = m_pProc->pc->server_info->            IncrementTotalClientCount(m_pProc);        InitRegistry(pStartTime);    }    return HXR_OK;}

	WebkitClientAdviseSink::~WebkitClientAdviseSink(void)	{		HX_RELEASE(m_pRegistry);		HX_RELEASE(m_pPlayer);		HX_RELEASE(m_pUnknown);		HX_RELEASE(m_pWebkitContext);	}

voidHXRecordControl::Cleanup(){    OnEndOfPackets();    for(UINT16 nStream = 0; nStream < m_PendingGetPackets.GetSize(); nStream++)    {	IHXPacket* pPacket = (IHXPacket*)m_PendingGetPackets.GetAt(nStream);	m_PendingGetPackets.SetAt(nStream, NULL);	HX_RELEASE(pPacket);    }    if(m_pRecordService)	m_pRecordService->CloseRecordSource(m_pRecordSource);    HX_RELEASE(m_pRecordService);    HX_RELEASE(m_pRecordSource);    HX_VECTOR_DELETE(m_pStreamInfo);#if defined(HELIX_FEATURE_RECORDCONTROL_MERGESORT)    HX_DELETE(m_pMergeSorter);#endif /* #if defined(HELIX_FEATURE_RECORDCONTROL_MERGESORT) */    while(!m_PendingPutPackets.IsEmpty())    {	PendingPutPacket* pPutPacket = (PendingPutPacket*)m_PendingPutPackets.RemoveHead();	HX_ASSERT(pPutPacket);	HX_RELEASE(pPutPacket->pPacket);	HX_DELETE(pPutPacket);    }}

STDMETHODIMPStaticPushSource::Done(){    HX_VECTOR_DELETE(m_pStreams);    HX_RELEASE(m_pSinkControl);    HX_RELEASE(m_pFileObject);    HX_RELEASE(m_pBWEValues);    HX_RELEASE(m_pRequest);    if (m_pSink)    {	m_pSink->SourceDone();	m_pSink->Release();	m_pSink = NULL;    }    if (m_pFileFormat)    {        /*         * Close() must be called before Release() so that the         * IHXFileFormatObject will properly free its IHXFileObject         */        m_pFileFormat->Close();        m_pFileFormat->Release();        m_pFileFormat = NULL;    }    return HXR_OK;}

ConfigWatcher::~ConfigWatcher(){    Cleanup();    HX_RELEASE(m_pRegistry);    HX_RELEASE(m_pActiveRegistry);    HX_RELEASE(m_pPropWatch);}

HXFileSystemManager::~HXFileSystemManager(){    if (m_pContext)    {	m_pContext->Release();	m_pContext = 0;    }    if(m_pSamePool)    {	m_pSamePool->Release();	m_pSamePool = NULL;    }    if (m_pFSManagerResponse)    {	m_pFSManagerResponse->Release();	m_pFSManagerResponse = 0;    }    HX_RELEASE(m_pRequest);    if (m_pCallback &&	m_pCallback->m_bIsCallbackPending &&	m_pScheduler)    {	m_pScheduler->Remove(m_pCallback->m_Handle);    }    HX_RELEASE(m_pCallback);    HX_RELEASE(m_pScheduler);    HX_RELEASE(m_pOriginalObject);    HX_VECTOR_DELETE(m_pRelativePath);}

static /* private */bool MatchClass(IHXSockAddr* pAddr, HXIN4AddrClass addrClassIN4,                 HXIN6AddrClass addrClassIN6){    HX_ASSERT(HX_IN6_CLASS_V4MAPPED != addrClassIN6);    bool isMatch = false;    HX_RESULT hxr = HXR_FAILED;        IHXSockAddrIN6* pAddr6 = 0;    hxr = pAddr->QueryInterface(IID_IHXSockAddrIN6,                     reinterpret_cast<void**>(&pAddr6));    if(SUCCEEDED(hxr))    {        isMatch = MatchClassIN6(pAddr6, addrClassIN4, addrClassIN6);        HX_RELEASE(pAddr6);    }    else    {        IHXSockAddrIN4* pAddr4 = 0;        hxr = pAddr->QueryInterface(IID_IHXSockAddrIN4,                         reinterpret_cast<void**>(&pAddr4));        if(SUCCEEDED(hxr))        {            isMatch = (addrClassIN4 == pAddr4->GetAddrClass());            HX_RELEASE(pAddr4);        }    }    return isMatch;}

STDMETHODIMPDataRevertController::RevertedFileHeaderReady(HX_RESULT status,						IHXValues* pHeader){    if (pHeader)    {	HX_RELEASE(m_pFileHeaders);	m_pFileHeaders = pHeader;	pHeader->AddRef();    }    pHeader = (IHXValues*)m_pStreamHeaders->RemoveHead();     if (!pHeader)    {	m_pControlResp->RevertHeadersDone(m_pFileHeaders,					  m_pRevertedStreamHeaders, 					  m_pResponseHeaders,					  TRUE);	return HXR_OK;    }        HX_RELEASE(m_pCurrentStreamHeader);    m_pCurrentStreamHeader = pHeader;    m_pDataRevert->RevertStreamHeader(pHeader);    return HXR_OK;}

HXExternalResourceManager::~HXExternalResourceManager(){    delete[] m_pExternalResDir;    if(m_pResourceList)    {	CHXSimpleList::Iterator i = m_pResourceList->Begin();	for (; i != m_pResourceList->End(); ++i)	{	    IHXXResFile* pRes = (IHXXResFile*)(*i);	    pRes->Close();	    pRes->Release();	}    }    HX_DELETE(m_pResourceList);    HX_RELEASE(m_pPrefs);    HX_RELEASE(m_pRegistry);    HX_RELEASE(m_pContext);    HX_RELEASE(m_pHXXResPlugin);#if defined(HELIX_CONFIG_NOSTATICS)    HXExternalResourceManager*& m_pResourceManager =	(HXExternalResourceManager*&)HXGlobalPtr::Get(	    &HXExternalResourceManager::m_pResourceManager);#endif    m_pResourceManager = NULL;}

voidHXOverlayManager::Close(){     CSiteStats* pStats;    CStatPoint* pPoint;    while (m_ListOfSiteStats.GetCount())    {        pStats = (CSiteStats*) m_ListOfSiteStats.RemoveHead();        while(pStats->samples.GetCount())        {            pPoint = (CStatPoint*) pStats->samples.RemoveHead();            HX_DELETE(pPoint);        }        HX_DELETE(pStats);    }    if (m_CallbackHandle)    {        m_pScheduler->Remove(m_CallbackHandle);        m_CallbackHandle = 0;    }    HX_RELEASE(m_pContext);    HX_RELEASE(m_pScheduler);    HX_RELEASE(m_pMutex);}

HX_RESULT CHXAudioDeviceDS::InternalClose(){    HX_RESULT	theErr = HXR_OK;    KillThreadAndEvent();    HX_RELEASE(m_pAudioHookDMO);    HX_RELEASE(m_pPrimaryBuffer);    HX_RELEASE(m_pSecondaryBuffer);    HX_RELEASE(m_pDSDev);    m_pAudioPtrStart = NULL;    m_ulLastPlayCursor = 0;    m_ulLastWriteCursor =0;    m_eState = E_DEV_CLOSED;    m_ulLoops = 0;    m_ulLoopTime = 0;    m_nBlocksPerBuffer = 0;    m_ulCurrPlayTime = 0;	m_ulCurrLoopTime = 0;    if (m_hwnd)    {	SetWindowLong(m_hwnd, GWL_USERDATA, NULL);    }    return HXR_OK;}

HX_RESULTFileFormatSource::Init(IHXPSinkControl* pSink){    HX_RESULT			h_result = HXR_OK;    IHXFileObject*             pFileObject;    IHXBandwidthNegotiator*    pBandwidthNegotiator;    HX_RELEASE(m_pSinkControl);    pSink->AddRef();    m_pSinkControl = pSink;    AddRef();    if (HXR_OK == h_result)    {        if(HXR_OK == m_pFileObject->QueryInterface(IID_IHXFileObject,                                                 (void**)&pFileObject))        {                      if(m_bwe_values &&                (HXR_OK == m_file_format->QueryInterface(                IID_IHXBandwidthNegotiator,                (void**)&pBandwidthNegotiator)))            {                pBandwidthNegotiator->SetBandwidthInfo(m_bwe_values);                pBandwidthNegotiator->Release();                m_bwe_values->Release();                m_bwe_values = NULL;            }            HX_ASSERT(m_file_format != NULL);            if (m_bFileFormatInitialized)            {                InitDone(HXR_OK);            }            else            {                m_bFileFormatInitialized = TRUE;                h_result = m_file_format->InitFileFormat(m_pRequest, this,                                                     pFileObject);            }            HX_RELEASE(pFileObject);            if (HXR_OK != h_result)            {                ERRMSG(m_proc->pc->error_handler,                       "File Format initialization failed/n");                m_file_format->Close();                m_file_format->Release();                m_file_format = 0;                m_bFileFormatInitialized = FALSE;            }        }    }    Release();    return h_result;}

HX_RESULTCHXAltGroupIterator::getIterator(IUnknown* pUnk){    HX_RESULT res = HXR_INVALID_PARAMETER;    if (pUnk)    {        IHXList* pList = NULL;        res = pUnk->QueryInterface(IID_IHXList, (void**)&pList);        if (HXR_OK == res)        {            HX_RELEASE(m_pItr);            m_pItr = pList->Begin();            if (!m_pItr)            {                res = HXR_UNEXPECTED;            }        }        HX_RELEASE(pList);    }    return res;}

HX_RESULT CBaseArchiver2::MakeNuggetFileObject(IHXFileObject* pFileObject,					       const char* pFileMimeType,					       IHXFileObject* &pNuggetFileObject){    HX_RESULT retVal = HXR_OUTOFMEMORY;    CNGTFileObject* pNewNuggetFileObject = new CNGTFileObject();    if (pNewNuggetFileObject)    {	pNewNuggetFileObject->AddRef();	retVal = pNewNuggetFileObject->InitNugget(m_pContext,					          pFileObject,						  HX_FILE_READ | HX_FILE_WRITE | HX_FILE_BINARY,						  NULL,	    // IHXMetaFileFormatResponse						  TRUE);    // bForceNew	if (SUCCEEDED(retVal))	{	    UINT32 ulExpiration = 0;	    UINT32 ulConnectTime = 0;	    IHXBuffer* pRemoteSourceURLBuffer = NULL;	    m_pAdviser->GetPropertyULONG32("NuggetExpiration", 					   ulExpiration);	    m_pAdviser->GetPropertyCString("NuggetRemoteSourceURL", 					   pRemoteSourceURLBuffer);	    m_pAdviser->GetPropertyULONG32("NuggetConnectTime", 					   ulConnectTime);	    retVal = pNewNuggetFileObject->ConfigureNugget(			   ulExpiration,			   ulConnectTime,			   m_ulNuggetMinLocalDuration,			   m_ulMaxDuration,			   pFileMimeType,			   pRemoteSourceURLBuffer ? ((const char*) pRemoteSourceURLBuffer->GetBuffer()) : NULL);	    HX_RELEASE(pRemoteSourceURLBuffer);	}	if (SUCCEEDED(retVal))	{	    retVal = pNewNuggetFileObject->QueryInterface(IID_IHXFileObject, 							  (void**) &pNuggetFileObject);	}	if (SUCCEEDED(retVal))	{	    m_pNuggetFileObject = pNewNuggetFileObject;	    HX_ADDREF(m_pNuggetFileObject);	}    }    HX_RELEASE(pNewNuggetFileObject);    return retVal;}

voidBasicPacketFlow::ScheduleStreamDone(BasicPacketFlow* pFlow,                                    Transport* pTransport,                                     PacketStream* pStream,                                     UINT16 unStreamNumber){    /*      * Notify the protocol if we've reached the end of the stream following a     * seek and have no packets to send.     */    if (!pStream->IsFirstPacketTSSet())    {        SetStreamStartTime(unStreamNumber, (UINT32)~0);        pStream->SetFirstPacketTS((UINT32)~0);    }    if (m_pRateManager)    {	IHXPacketFlowControl* pRateMgrFlowControl = NULL;	if (HXR_OK == m_pRateManager->QueryInterface(IID_IHXPacketFlowControl,						     (void**)&pRateMgrFlowControl))	{	    pRateMgrFlowControl->StreamDone(unStreamNumber);	    HX_RELEASE(pRateMgrFlowControl);	}        }    HandleStreamDone(pStream);    pStream->m_bSentStreamDone = TRUE;    HX_ASSERT(!pStream->m_uScheduledStreamDoneID);    if (pStream->m_uScheduledStreamDoneID)    {        return;    }    else if (!pStream->m_pStreamDoneCallback)    {        pStream->m_pStreamDoneCallback =            new (m_pProc->pc->mem_cache) PacketStreamDoneCallback();        pStream->m_pStreamDoneCallback->m_pFlow          = pFlow;        pStream->m_pStreamDoneCallback->m_pTransport     = pTransport;        pStream->m_pStreamDoneCallback->m_pStream        = pStream;        pStream->m_pStreamDoneCallback->m_unStreamNumber = unStreamNumber;        pStream->m_pStreamDoneCallback->AddRef();    }    Timeval tNow = m_pProc->pc->engine->now;    Timeval tCallbackTime;    pStream->m_uScheduledStreamDoneID =        m_pProc->pc->engine->schedule.enter(tCallbackTime,                                            pStream->m_pStreamDoneCallback);    if (!pStream->m_uScheduledStreamDoneID)        HX_RELEASE(pStream->m_pStreamDoneCallback);}

ClientRegTree::~ClientRegTree(){    DeleteRegEntry();    HX_RELEASE(m_pRegistry);    HX_RELEASE(m_pClassFactory);    HX_RELEASE(m_pContext);}

voidGetTypeTest::cleanup(){    HX_DELETE(m_pBRD);    HX_RELEASE(m_pSHdr);    HX_RELEASE(m_pBufA);    HX_RELEASE(m_pBufB);}

CloakConn::~CloakConn(void){    HX_RELEASE(m_pRTSPProt);    HX_RELEASE(m_pGETHandler);    HX_RELEASE(m_pRTSPSvrProt);    HX_RELEASE(m_pRefSock);    HXDestroyMutex(m_pMutex);}

/////////////////////////// CHXAudioDeviceHookBase::~CHXAudioDeviceHookBase////  Destructor for CHXAudioDeviceHookBase.//CHXAudioDeviceHookBase::~CHXAudioDeviceHookBase(){    // Free streaming resources in case it hasn't been done by the client    InternalFreeStreamingResources();    HX_RELEASE( m_pContext );    HX_RELEASE( m_pHook );};

CHXAudioDevice::~CHXAudioDevice(){    Close(TRUE);    m_iTimer.Close();    HX_DELETE(m_pPrioritySettings);    HX_RELEASE(m_pContext);    HX_RELEASE(m_pErrorMessages);}