开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
fswtchr.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：27k
源码类别：

Symbian

开发平台：

Visual C++

fswtchr.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /****************************************************************************
  37.  *  Includes
  38.  */
  39. #include "fswtchr.h"
  40. #include "hxassert.h"
  41. #include "qtffrefcounter.h"
  44. /****************************************************************************
  45.  *  Local Defines
  46.  */
  47. #define MAX_CHUNK_SIZE 0x0000FFFF  // 64K
  48. #define MAX_CONSECUTIVE_FRAGMENT_LOADS 8     // Do not set to 0
  52. /****************************************************************************
  53.  *  Class CFileSwitcher
  54.  */
  55. /****************************************************************************
  56.  *  Constructor/Destructor
  57.  */
  58. CFileSwitcher::CFileSwitcher(void)
  59.     : m_uMaxChildCount(0)
  60.     , m_uCurrentChildCount(0)
  61.     , m_pHandleTable(NULL)
  62.     , m_ulFlags(0)
  63.     , m_ulSize(0)
  64.     , m_ulChunkSize(0)
  65.     , m_ulProcessedSize(0)
  66.     , m_ulFragmentCount(0)
  67.     , m_bRelative(FALSE)
  68.     , m_pBuffer(NULL)
  69.     , m_pClassFactory(NULL)
  70.     , m_pCurrentHandle(NULL)
  71.     , m_pResponse(NULL)
  72.     , m_pScheduler(NULL)
  73.     , m_State(FSWCHR_Offline)
  74.     , m_lRefCount(0)
  75.     , m_uLastDisownedChild(0)
  76.     , m_bClosing(FALSE)
  77.     , m_CloseStatus(HXR_OK)
  78.     , m_bSyncMode(FALSE)
  79. {
  80.     g_nRefCount_qtff++;
  81. }
  84. CFileSwitcher::~CFileSwitcher()
  85. {
  86.     Reset();
  87.     g_nRefCount_qtff--;
  88. }
  91. /****************************************************************************
  92.  *  IHXFileSwitcher private methods
  93.  */
  94. /****************************************************************************
  95.  *  Reset
  96.  */
  97. inline void CFileSwitcher::Reset(void)
  98. {
  99.     HX_VECTOR_DELETE(m_pHandleTable);
  100.     HX_RELEASE(m_pResponse);
  101.     HX_RELEASE(m_pBuffer);
  102.     HX_RELEASE(m_pClassFactory);
  103.     HX_RELEASE(m_pScheduler);
  104.     m_uCurrentChildCount = 0;
  105. }
  107. /****************************************************************************
  108.  *  HandleFailureAsync
  109.  */
  110. HX_RESULT CFileSwitcher::HandleFailureAsync(HX_RESULT status)
  111. {
  112.     // Asynchronous failures occur only during Read, Write or Seek
  113.     // process while a new FileHandle is beeing formed (since the
  114.     // operation was requested on a file without a handle present
  115.     // in tha HandleTable).
  116.     HX_RESULT retVal;
  118.     HX_ASSERT(status != HXR_OK);
  119.     HX_ASSERT(m_pCurrentHandle);
  121.     HX_RELEASE(m_pBuffer);
  123.     if (m_pCurrentHandle != m_pHandleTable)
  124.     {
  125. m_pCurrentHandle->Clear();
  126. m_uCurrentChildCount--;
  127.     }
  129.     switch (m_State)
  130.     {
  131.     case FSWCHR_ProcRead:
  132. retVal = ReadDone(status, NULL);
  133. break;
  134.     case FSWCHR_ProcSeek:
  135. retVal = SeekDone(status);
  136. break;
  137.     case FSWCHR_ProcWrite:
  138. retVal = WriteDone(status);
  139. break;
  140.     case FSWCHR_ProcAdvise:
  141. retVal = HXR_OK;    // Silent failure
  142. break;
  143.     default:
  144. retVal = HXR_UNEXPECTED;
  145. break;
  146.     }
  148.     return retVal;
  149. }
  151. /****************************************************************************
  152.  *  HandleFailureSync
  153.  */
  154. HX_RESULT CFileSwitcher::HandleFailureSync(HX_RESULT status)
  155. {
  156.     // Synchronous failures may occur during Read, Write, Seek
  157.     // process while a correct FileHandle is preformed and known.
  158.     // Sync. failure also may occur during initalization of this
  159.     // object.
  160.     HX_ASSERT(status != HXR_OK);
  162.     HX_RELEASE(m_pResponse);
  163.     HX_RELEASE(m_pBuffer);
  165.     if (m_State == FSWCHR_ProcInit)
  166.     {
  167. HX_VECTOR_DELETE(m_pHandleTable);
  168. m_State = FSWCHR_Offline;
  169.     }
  170.     else
  171.     {
  172. m_State = FSWCHR_Ready;
  173.     }
  175.     return status;
  176. }
  178. /****************************************************************************
  179.  *  FindFileHandle
  180.  */
  181. inline CFileSwitcher::FileHandle* CFileSwitcher::FindFileHandle(const char* pFileName)
  182. {
  183.     FileHandle* pFileHandle;
  184.     FileHandle* pFreeHandle = NULL;
  185.     UINT16 uChildrenExamined;
  186.     
  187.     if (pFileName == NULL)
  188.     {
  189. return m_pHandleTable;
  190.     }
  191.     
  192.     for (uChildrenExamined = 0, pFileHandle = m_pHandleTable + 1;
  193.  uChildrenExamined < m_uCurrentChildCount;
  194.  pFileHandle++)
  195.     {
  196. if (pFileHandle->m_pFileName)
  197. {
  198.     if (!strcmp(pFileHandle->m_pFileName, pFileName))
  199.     {
  200. return pFileHandle;
  201.     }
  202.     
  203.     uChildrenExamined++;
  204. }
  205. else
  206. {
  207.     pFreeHandle = pFileHandle;
  208. }
  209.     }
  210.     
  211.     if (m_State == FSWCHR_ProcAdvise)
  212.     {
  213. // Do not page-in on attempt to Advise. Advise must be synchronous.
  214. return NULL;
  215.     }
  217.     // Appropriate file handle wasn't found, so find a
  218.     // free one to make a new one
  219.     pFileHandle = pFreeHandle;
  220.     if (m_uCurrentChildCount < m_uMaxChildCount)
  221.     {
  222. pFileHandle = m_pHandleTable + m_uCurrentChildCount + 1;
  224. HX_ASSERT(!pFileHandle->m_pFileName);
  225. HX_ASSERT(!pFileHandle->m_pFileObject);
  226.     }
  228.     // make new handle
  229.     if (pFileHandle)
  230.     {
  231. if (pFileHandle->SetName(pFileName))
  232. {
  233.     m_uCurrentChildCount++;
  234. }
  235. else
  236. {
  237.     pFileHandle = NULL;
  238. }
  239.     }
  241.     return pFileHandle;
  242. }
  244. /****************************************************************************
  245.  *  SelectStaleHandle
  246.  */
  247. inline CFileSwitcher::FileHandle* CFileSwitcher::SelectStaleHandle(void)
  248. {
  249.     FileHandle *pFileHandle = NULL;
  250.     
  251.     // Getting a stale handle is only valid when
  252.     // there is no more room for the child handles
  253.     HX_ASSERT(m_uMaxChildCount == m_uCurrentChildCount);
  255.     if (m_uMaxChildCount > 0)
  256.     {
  257. if (m_uLastDisownedChild < m_uMaxChildCount)
  258. {
  259.     m_uLastDisownedChild++;
  260. }
  261. else
  262. {
  263.     m_uLastDisownedChild = 1;
  264. }
  266. pFileHandle = m_pHandleTable + m_uLastDisownedChild;
  268. HX_ASSERT(pFileHandle->m_pFileName);
  269.     }
  271.     return pFileHandle;
  272. }
  274. /****************************************************************************
  275.  *  GetFileHandle
  276.  */
  277. HX_RESULT CFileSwitcher::GetFileHandle(const char* pFileName)
  278. {
  279.     HX_RESULT retVal;
  281.     m_pCurrentHandle = FindFileHandle(pFileName);
  283.     if (m_pCurrentHandle)
  284.     {
  285. if (m_pCurrentHandle->m_pFileObject)
  286. {
  287.     // A set-up handle exists
  288.     retVal = FileHandleReady();
  289. }
  290. else
  291. {
  292.     IHXGetFileFromSamePool* pFilePool;
  294.     // Handle was made but needs set-up
  295.     HX_ASSERT(m_pHandleTable->m_pFileObject);
  297.     retVal = m_pHandleTable->m_pFileObject->QueryInterface(
  298. IID_IHXGetFileFromSamePool,
  299. (void**) &pFilePool);
  301.     if (SUCCEEDED(retVal))
  302.     {
  303. // Set-up is made by duplicating the root file object
  304. retVal = pFilePool->GetFileObjectFromPool(
  305.     (IHXGetFileFromSamePoolResponse*) this);
  306. pFilePool->Release();
  307.     }
  308. }
  309.     }
  310.     else if (m_State == FSWCHR_ProcAdvise)
  311.     {
  312. // Cannot advise paged-out file object
  313. retVal = HXR_FAIL;
  314.     }
  315.     else
  316.     {
  317. // If the file handle table is full, select a stale
  318. // handle and dispose of it so the room is made for
  319. // the currently needed handle,
  320. if (m_uMaxChildCount == m_uCurrentChildCount)
  321. {
  322.     m_pCurrentHandle = SelectStaleHandle();
  324.     if (m_pCurrentHandle)
  325.     {
  326. m_pCurrentHandle->SetName(pFileName);
  328. retVal = CloseFileHandleObject(m_pCurrentHandle);
  329.     }
  330.     else
  331.     {
  332. retVal = HXR_FAIL;
  333.     }
  334. }
  335. else
  336. {
  337.     // We must be out memory if we failed to find or
  338.     // make a file handle and the file handle table
  339.     // still has slots available.
  340.     retVal = HXR_OUTOFMEMORY;
  341. }
  342.     }
  344.     if (FAILED(retVal))
  345.     {
  346. retVal = HandleFailureSync(retVal);
  347.     }
  349.     return retVal;
  350. }
  352. /****************************************************************************
  353.  *  CloseFileHandle
  354.  */
  355. HX_RESULT CFileSwitcher::CloseFileHandleObject(FileHandle *pFileHandle)
  356. {
  357.     HX_RESULT retVal;
  358.     IHXFileObject *pFileObject;
  360.     HX_ASSERT(pFileHandle);
  362.     pFileObject = pFileHandle->m_pFileObject;
  364.     if (pFileObject)
  365.     {
  366. pFileHandle->m_pFileObject = NULL;
  368. retVal = pFileObject->Close();
  370. pFileObject->Release();
  371.     }
  372.     else
  373.     {
  374. CloseDone(HXR_OK);
  375. retVal = HXR_OK;
  376.     }
  378.     return retVal;
  379. }
  381. /****************************************************************************
  382.  *  FileHandleReady
  383.  */
  384. HX_RESULT CFileSwitcher::FileHandleReady(void)
  385. {
  386.     HX_RESULT retVal;
  388.     HX_ASSERT(m_pCurrentHandle);
  389.     HX_ASSERT(m_pCurrentHandle->m_pFileObject);
  391.     switch (m_State)
  392.     {
  393.     case FSWCHR_ProcRead:
  394. m_ulProcessedSize = 0;
  395. return ProcessRead();
  396.     case FSWCHR_ProcSeek:
  397. return m_pCurrentHandle->m_pFileObject->Seek(m_ulSize, m_bRelative);
  398.     case FSWCHR_ProcWrite:
  399. {
  400.     IHXBuffer* pBuffer;
  401.     HX_RESULT retVal;
  402.     
  403.     HX_ASSERT(m_pBuffer);
  405.     HX_RELEASE(m_pBuffer);
  406.     pBuffer = m_pBuffer;
  407.     m_pBuffer = NULL;
  408.     
  409.     retVal = m_pCurrentHandle->m_pFileObject->Write(pBuffer);
  410.     
  411.     pBuffer->Release();
  412.     
  413.     return retVal;
  414. }
  415.     case FSWCHR_ProcAdvise:
  416. retVal = m_pCurrentHandle->m_pFileObject->Advise(m_ulSize);
  417. if (SUCCEEDED(retVal))
  418. {
  419.     if (m_ulSize == HX_FILEADVISE_SYNCACCESS)
  420.     {
  421. m_bSyncMode = TRUE;
  422.     }
  423.     else if (m_ulSize == HX_FILEADVISE_ASYNCACCESS)
  424.     {
  425. m_bSyncMode = FALSE;
  426.     }
  427. }
  428. m_State = FSWCHR_Ready;
  429. return retVal;
  430.     default:
  431. // nothing to do
  432. break;
  433.     }
  435.     return HXR_UNEXPECTED;
  436. }
  438. /****************************************************************************
  439.  *  ProcessRead
  440.  */
  441. HX_RESULT CFileSwitcher::ProcessRead(void)
  442. {
  443.     ULONG32 ulSize = m_ulSize - m_ulProcessedSize;
  444.     m_ulChunkSize = (ulSize <= MAX_CHUNK_SIZE) ? 
  445.      ulSize : MAX_CHUNK_SIZE;
  447.     return m_pCurrentHandle->m_pFileObject->Read(m_ulChunkSize);
  448. }
  450. /****************************************************************************
  451.  *  ReadNextFragment
  452.  */
  453. HX_RESULT CFileSwitcher::ReadNextFragment(void)
  454. {
  455.     HX_RESULT retVal = HXR_FAIL;
  457.     if ((!m_bClosing) &&
  458. m_pCurrentHandle &&
  459. m_pCurrentHandle->m_pFileObject)
  460.     {
  461. if (m_bSyncMode ||
  462.     (m_ulFragmentCount < MAX_CONSECUTIVE_FRAGMENT_LOADS))
  463. {
  464.     retVal = ProcessRead();
  465. }
  466. else
  467. {
  468.     m_ulFragmentCount = 0;
  469.     retVal = m_pScheduler->RelativeEnter(this, 0);
  470. }
  471.     }
  473.     if (FAILED(retVal))
  474.     {
  475. retVal = ReadDone(HXR_FAIL, NULL);
  476.     }
  478.     return retVal;
  479. }
  481. /****************************************************************************
  482.  *  IHXFileSwitcher methods - Main interface
  483.  */
  484. /****************************************************************************
  485.  *  Init
  486.  */
  487. STDMETHODIMP CFileSwitcher::Init(IHXFileObject* pFileObject,
  488.  ULONG32 ulFlags,
  489.  IHXFileResponse* pResponse,
  490.  IUnknown* pContext,
  491.  UINT16 uMaxChildCount)
  492. {
  493.     HX_RESULT retVal = HXR_OK;
  495.     if (m_State != FSWCHR_Offline)
  496.     {
  497. retVal = HXR_UNEXPECTED;
  498.     }
  500.     if (SUCCEEDED(retVal))
  501.     {
  502. Reset();
  504. HX_ASSERT(pFileObject);
  505. HX_ASSERT(pResponse);
  506. HX_ASSERT(pContext);
  508. m_uMaxChildCount = uMaxChildCount;
  509. m_ulFlags = ulFlags;
  510.     
  511. // First Entry in the table is used as RootHandle
  512. m_pHandleTable = new FileHandle[m_uMaxChildCount + 1];
  513. if (m_pHandleTable == NULL)
  514. {
  515.     retVal = HXR_OUTOFMEMORY;
  516. }
  517.     }
  519.     if (SUCCEEDED(retVal))
  520.     {
  521. retVal = pContext->QueryInterface(
  522.     IID_IHXCommonClassFactory,
  523.     (void**) &m_pClassFactory);
  524.     }
  526.     if (SUCCEEDED(retVal))
  527.     {
  528. retVal = pContext->QueryInterface(
  529.     IID_IHXScheduler, 
  530.     (void**) &m_pScheduler);
  531.     }
  533.     if (SUCCEEDED(retVal))
  534.     {
  535. HX_ASSERT(!m_pResponse);
  537. m_pHandleTable = m_pHandleTable;
  538. m_pHandleTable->m_pFileObject = pFileObject;
  539. pFileObject->AddRef();
  541. m_State = FSWCHR_ProcInit;
  542. m_pResponse = pResponse;
  543. m_pResponse->AddRef();
  545. retVal = pFileObject->Init(m_ulFlags, (IHXFileResponse*) this);
  547. if (FAILED(retVal))
  548. {
  549.     retVal = HandleFailureSync(retVal);
  550. }
  551.     }
  553.     return retVal;
  554. }
  556. /****************************************************************************
  557.  *  Read
  558.  */
  559. STDMETHODIMP CFileSwitcher::Read(ULONG32 ulSize,
  560.  IHXFileResponse* pResponse,
  561.  const char* pFileName)
  562. {
  563.     HX_RESULT retVal = HXR_UNEXPECTED;
  565.     if ((m_State == FSWCHR_Ready) && (!m_bClosing))
  566.     {
  567. HX_ASSERT(!m_pResponse);
  569. m_ulSize = ulSize;
  570. m_pResponse = pResponse;
  571. m_pResponse->AddRef();
  573. m_State = FSWCHR_ProcRead;
  575. retVal = GetFileHandle(pFileName);
  576.     }
  578.     return retVal;
  579. }
  581. /****************************************************************************
  582.  *  Write
  583.  */
  584. STDMETHODIMP CFileSwitcher::Write(IHXBuffer* pBuffer,
  585.   IHXFileResponse* pResponse,
  586.   const char* pFileName)
  587. {
  588.     HX_RESULT retVal = HXR_UNEXPECTED;
  590.     if ((m_State == FSWCHR_Ready) && (!m_bClosing))
  591.     {
  592. HX_ASSERT(!m_pResponse);
  593. HX_ASSERT(!m_pBuffer);
  595. m_pBuffer = pBuffer;
  596. m_pBuffer->AddRef();
  597. m_pResponse = pResponse;
  598. m_pResponse->AddRef();
  600. m_State = FSWCHR_ProcWrite;
  602. retVal = GetFileHandle(pFileName);
  603.     }
  605.     return retVal;
  606. }
  608. /****************************************************************************
  609.  *  Seek
  610.  */
  611. STDMETHODIMP CFileSwitcher::Seek(ULONG32 ulOffset,
  612.  BOOL bRelative,
  613.  IHXFileResponse* pResponse,
  614.  const char* pFileName)
  615. {
  616.     HX_RESULT retVal = HXR_UNEXPECTED;
  618.     if ((m_State == FSWCHR_Ready) && (!m_bClosing))
  619.     {
  620. HX_ASSERT(!m_pResponse);
  622. m_ulSize = ulOffset;
  623. m_bRelative = bRelative;
  624. m_pResponse = pResponse;
  625. m_pResponse->AddRef();
  627. m_State = FSWCHR_ProcSeek;
  629. retVal = GetFileHandle(pFileName);
  630.     }
  632.     return retVal;
  633. }
  635. /****************************************************************************
  636.  *  Advise
  637.  */
  638. STDMETHODIMP CFileSwitcher::Advise(ULONG32 ulInfo,
  639.    const char* pFileName)
  640. {
  641.     HX_RESULT retVal = HXR_UNEXPECTED;
  643.     if ((m_State == FSWCHR_Ready) && (!m_bClosing))
  644.     {
  645. HX_ASSERT(!m_pResponse);
  647. m_ulSize = ulInfo;
  649. m_State = FSWCHR_ProcAdvise;
  651. retVal = GetFileHandle(pFileName);
  652.     }
  654.     return retVal;
  655. }
  657. /****************************************************************************
  658.  *  Close
  659.  */
  660. STDMETHODIMP CFileSwitcher::Close(IHXFileResponse *pResponse,
  661.   const char* pFileName)
  662. {
  663.     HX_RESULT retVal = HXR_UNEXPECTED;
  665.     if ((m_State != FSWCHR_Offline) && (!m_bClosing))
  666.     {
  667. if (pFileName)
  668. {
  669.     // File Specific Closing - must be synchronous
  670.     if (m_State == FSWCHR_Ready)
  671.     {
  672. FileHandle *pFileHandle;
  674. HX_ASSERT(!m_pResponse);
  675. m_pResponse = pResponse;
  676. pResponse->AddRef();
  678. retVal = HXR_OK;
  679. m_State = FSWCHR_ProcClose;
  681. pFileHandle = FindFileHandle(pFileName);
  683. if (pFileHandle)
  684. {
  685.     if (pFileHandle->m_pFileName)
  686.     {
  687. pFileHandle->SetName(NULL);
  689. HX_ASSERT(m_uCurrentChildCount > 0);
  691. m_uCurrentChildCount--;
  692.     }
  693.     
  694.     retVal = CloseFileHandleObject(pFileHandle);
  695. }
  696. else
  697. {
  698.     CloseDone(HXR_OK);
  699. }
  700.     }
  701. }
  702. else
  703. {
  704.     // This is a general closure (shutdown)
  705.     // which need not be synchronous
  706.     UINT16 i;
  707.     FileHandle* pFileHandle;
  708.     
  709.     HX_ASSERT(m_pHandleTable);
  710.     
  711.     retVal = HXR_OK;
  713.     m_bClosing = TRUE;
  714.     m_CloseStatus = HXR_OK;
  716.     HX_RELEASE(m_pResponse);
  717.     m_pResponse = pResponse;
  718.     pResponse->AddRef();
  719.     
  720.     if (m_State == FSWCHR_ProcClose)
  721.     {
  722. // there is an additional outstanding Close to complete 
  723. // for a child
  724. m_uCurrentChildCount++;
  725.     }
  726.     
  727.     // Close Children
  728.     HX_ASSERT(m_uCurrentChildCount <= m_uMaxChildCount);
  729.     
  730.     for (i = m_uCurrentChildCount, pFileHandle = m_pHandleTable + 1;
  731.  i > 0;
  732.  i--, pFileHandle++)
  733.     {
  734. if (pFileHandle->m_pFileName)
  735. {
  736.     pFileHandle->SetName(NULL);
  737.     
  738.     if (FAILED(CloseFileHandleObject(pFileHandle)))
  739.     {
  740. // Recover by forcing the closing on this level
  741. CloseDone(HXR_OK);
  742.     }
  743. }
  744.     }
  746.     // Close the root file
  747.     if (FAILED(CloseFileHandleObject(m_pHandleTable)))
  748.     {
  749. // Recover by forcing the closing on this level
  750. CloseDone(HXR_OK);
  751.     }
  752. }
  753.     }
  755.     return retVal;
  756. }
  759. /****************************************************************************
  760.  *  IHXFileResponse methods
  761.  */
  762. /****************************************************************************
  763.  *  InitDone
  764.  */
  765. STDMETHODIMP CFileSwitcher::InitDone(HX_RESULT status)
  766. {
  767.     HX_RESULT retVal = HXR_OK;
  769.     if (m_State != FSWCHR_Offline)
  770.     {
  771. if (m_State != FSWCHR_ProcInit)
  772. {
  773.     HX_ASSERT(m_pCurrentHandle);
  774.     HX_ASSERT(m_pCurrentHandle->m_pFileObject);
  776.     // This must be initialization completion
  777.     // as part of obtaining file handle during
  778.     // Read, Write or Seek
  779.     if (SUCCEEDED(status))
  780.     {
  781. status = FileHandleReady();
  782.     }
  784.     if (FAILED(status))
  785.     {
  786. m_pCurrentHandle->Clear();
  788. // Must report Failure to the requestor
  789. retVal = HandleFailureAsync(status);
  790.     }
  791. }
  792. else
  793. {
  794.     // Initialization complete
  795.     IHXFileResponse* pResponse = m_pResponse;
  797.     HX_ASSERT(pResponse);
  799.     m_pResponse = NULL;
  800.     if (SUCCEEDED(status))
  801.     {
  802. m_State = FSWCHR_Ready;
  803.     }
  805.     retVal = pResponse->InitDone(status);
  807.     pResponse->Release();
  808. }
  809.     }
  810.     else
  811.     {
  812. retVal = HXR_UNEXPECTED;
  813.     }
  815.     return retVal;
  816. }
  818. /****************************************************************************
  819.  *  CloseDone
  820.  */
  821. STDMETHODIMP CFileSwitcher::CloseDone(HX_RESULT status)
  822. {
  823.     HX_RESULT retVal = HXR_UNEXPECTED;
  825.     if (m_State != FSWCHR_Offline)
  826.     {
  827. if (((m_State == FSWCHR_ProcRead) ||
  828.      (m_State == FSWCHR_ProcWrite) ||
  829.      (m_State == FSWCHR_ProcSeek) ||
  830.      (m_State == FSWCHR_ProcAdvise)) &&
  831.     (!m_bClosing))
  832. {
  833.     // It must be a close due to freeing of a stale
  834.     // file handle so we can create a new one
  835.     retVal = HXR_OK;
  837.     if (SUCCEEDED(status))
  838.     {
  839. IHXGetFileFromSamePool* pFilePool;
  841. // Handle was made but needs set-up
  842. HX_ASSERT(m_pHandleTable->m_pFileObject);
  844. status = m_pHandleTable->m_pFileObject->QueryInterface(
  845.     IID_IHXGetFileFromSamePool,
  846.     (void**) &pFilePool);
  848. if (SUCCEEDED(status))
  849. {
  850.     // Set-up is made by duplicating the root file object
  851.     status = pFilePool->GetFileObjectFromPool(
  852. (IHXGetFileFromSamePoolResponse*) this);
  853.     pFilePool->Release();
  854. }
  855.     }
  856.     
  857.     if (FAILED(status))
  858.     {
  859. retVal = HandleFailureAsync(status);
  860.     }
  861. }
  862. else if ((m_State == FSWCHR_ProcClose) ||
  863.          (m_bClosing))
  864. {
  865.     retVal = HXR_OK;
  867.     if (!m_bClosing || (m_uCurrentChildCount == 0))
  868.     {
  869. // Close completion
  870. IHXFileResponse *pResponse = m_pResponse;
  872. m_pResponse = NULL;
  874. if (m_bClosing)
  875. {
  876.     Reset();
  878.     m_State = FSWCHR_Offline;
  880.     if (FAILED(m_CloseStatus))
  881.     {
  882. status = m_CloseStatus;
  883.     }
  884. }
  885. else
  886. {
  887.     m_State = FSWCHR_Ready;
  888. }
  890. if (pResponse)
  891. {
  892.     retVal = pResponse->CloseDone(status);
  893.     pResponse->Release();
  894. }
  895.     }
  896.     else
  897.     {
  898. // Still Closing files
  899. m_uCurrentChildCount--;
  901. if (SUCCEEDED(m_CloseStatus))
  902. {
  903.     m_CloseStatus = status;
  904. }
  905.     }
  906. }
  907.     }
  909.     return retVal;
  910. }
  912. /****************************************************************************
  913.  *  ReadDone
  914.  */
  915. STDMETHODIMP CFileSwitcher::ReadDone(HX_RESULT status,
  916.      IHXBuffer* pBuffer)
  917. {
  918.     HX_RESULT retVal = HXR_UNEXPECTED;
  920.     if (m_State == FSWCHR_ProcRead)
  921.     {
  922. HX_ASSERT(m_pResponse);
  924. if (m_ulChunkSize == m_ulSize)
  925. {
  926.     IHXFileResponse *pResponse = m_pResponse;
  927.     m_pResponse = NULL;
  928.     m_State = FSWCHR_Ready;
  929.     retVal = pResponse->ReadDone(status, pBuffer);
  930.     pResponse->Release();
  931. }
  932. else
  933. {
  934.     // The read of a fragment is completed
  935.     // Initialize fragment buffer if just starting
  936.     if (SUCCEEDED(status))
  937.     {
  938. if (m_ulProcessedSize == 0)
  939. {
  940.     // Starting the fragmented read - 
  941.     HX_ASSERT(m_pBuffer == NULL);
  942.     HX_ASSERT(m_ulSize != 0);
  943.     
  944.     m_ulFragmentCount = 0;
  946.     HX_RELEASE(m_pBuffer);
  947.     
  948.     status = m_pClassFactory->CreateInstance(
  949. IID_IHXBuffer, 
  950. (void **) &m_pBuffer);
  951.     
  952.     if (SUCCEEDED(status))
  953.     {
  954. status = m_pBuffer->SetSize(m_ulSize);
  956. if (FAILED(status))
  957. {
  958.     HX_RELEASE(m_pBuffer);
  959. }
  960.     }
  961. }
  962.     }
  964.     if (SUCCEEDED(status))
  965.     {
  966. ULONG32 ulSize = pBuffer->GetSize();
  968. memcpy(m_pBuffer->GetBuffer() + m_ulProcessedSize, /* Flawfinder: ignore */
  969.        pBuffer->GetBuffer(),
  970.        ulSize);
  971. m_ulProcessedSize += ulSize;
  972.     }
  974.     if ((m_ulProcessedSize >= m_ulSize) || FAILED(status))
  975.     {
  976. HX_ASSERT(m_ulProcessedSize <= m_ulSize);
  978. if (FAILED(status) && m_pBuffer)
  979. {
  980.     if (m_ulProcessedSize != 0)
  981.     {
  982. // Trim the buffer to what was read successfully
  983. m_pBuffer->SetSize(m_ulProcessedSize);
  984. status = HXR_OK;
  985.     }
  986.     else
  987.     {
  988. HX_RELEASE(m_pBuffer);
  989.     }
  990. }
  992. IHXBuffer* pBuffer = m_pBuffer;
  993. IHXFileResponse *pResponse = m_pResponse;
  994. m_pResponse = NULL;
  995. m_pBuffer = NULL;
  996. m_State = FSWCHR_Ready;
  997. retVal = pResponse->ReadDone(status, pBuffer);
  998. HX_RELEASE(pBuffer);
  999. pResponse->Release();
  1000.     }
  1001.     else
  1002.     {
  1003. m_ulFragmentCount++;
  1004. retVal = ReadNextFragment();
  1005.     }
  1006. }
  1007.     }
  1009.     return retVal;
  1010. }
  1012. /****************************************************************************
  1013.  *  WriteDone
  1014.  */
  1015. STDMETHODIMP CFileSwitcher::WriteDone(HX_RESULT status)
  1016. {
  1017.     HX_RESULT retVal = HXR_UNEXPECTED;
  1019.     if (m_State == FSWCHR_ProcWrite)
  1020.     {
  1021. IHXFileResponse *pResponse = m_pResponse;
  1023. HX_ASSERT(m_pResponse);
  1025. m_pResponse = NULL;
  1026. m_State = FSWCHR_Ready;
  1028. retVal = pResponse->WriteDone(status);
  1030. pResponse->Release();
  1031.     }
  1033.     return retVal;
  1034. }
  1036. /****************************************************************************
  1037.  *  SeekDone
  1038.  */
  1039. STDMETHODIMP CFileSwitcher::SeekDone(HX_RESULT status)
  1040. {
  1041.     HX_RESULT retVal = HXR_UNEXPECTED;
  1043.     if (m_State == FSWCHR_ProcSeek)
  1044.     {
  1045. IHXFileResponse *pResponse = m_pResponse;
  1047. HX_ASSERT(m_pResponse);
  1049. m_pResponse = NULL;
  1050. m_State = FSWCHR_Ready;
  1052. retVal = pResponse->SeekDone(status);
  1054. pResponse->Release();
  1055.     }
  1057.     return retVal;
  1058. }
  1060. /****************************************************************************
  1061.  *  IHXCallback methods
  1062.  */
  1063. /****************************************************************************
  1064.  *  Func
  1065.  */
  1066. STDMETHODIMP CFileSwitcher::Func(void)
  1067. {
  1068.     HX_RESULT retVal = HXR_UNEXPECTED;
  1070.     if (m_State == FSWCHR_ProcRead)
  1071.     {
  1072. retVal = ReadNextFragment();
  1073.     }
  1075.     return retVal;
  1076. }
  1078. /****************************************************************************
  1079.  *  IHXThreadSafeMethods method
  1080.  */
  1081. /****************************************************************************
  1082.  *  IsThreadSafe
  1083.  */
  1084. STDMETHODIMP_(UINT32)
  1085. CFileSwitcher::IsThreadSafe()
  1086. {
  1087.     return HX_THREADSAFE_METHOD_FSR_READDONE;
  1088. }
  1091. /****************************************************************************
  1092.  *  IHXGetFileFromSamePoolResponse method
  1093.  */
  1094. /****************************************************************************
  1095.  *  FileObjectReady
  1096.  */
  1097. STDMETHODIMP CFileSwitcher::FileObjectReady(HX_RESULT status,
  1098.     IUnknown* pFileObject)
  1099. {
  1100.     HX_RESULT retVal = HXR_UNEXPECTED;
  1102.     if (m_State != FSWCHR_Offline)
  1103.     {
  1104. HX_ASSERT(m_pCurrentHandle);
  1105. HX_ASSERT(m_pCurrentHandle->m_pFileName);
  1106. HX_ASSERT(!m_pCurrentHandle->m_pFileObject);
  1108. if (SUCCEEDED(status))
  1109. {
  1110.     IHXRequestHandler* pRequestHandler = NULL;
  1111.     IHXRequest* pRequest = NULL;
  1113.     if (!m_bClosing)
  1114.     {
  1115. status = pFileObject->QueryInterface(
  1116.     IID_IHXFileObject, 
  1117.     (void **) &(m_pCurrentHandle->m_pFileObject));
  1118.     }
  1119.     else
  1120.     {
  1121. status = HXR_ABORT;
  1122.     }
  1124.     if (status == HXR_OK)
  1125.     {
  1126. status = m_pClassFactory->CreateInstance(
  1127.     IID_IHXRequest, 
  1128.     (void **) &pRequest);
  1129.     }
  1130.     
  1131.     if (status == HXR_OK)
  1132.     {
  1133. status = pRequest->SetURL(m_pCurrentHandle->m_pFileName);
  1134.     }
  1136.     if (status == HXR_OK)
  1137.     {
  1138. status = pFileObject->QueryInterface(
  1139.     IID_IHXRequestHandler, 
  1140.     (void**) &pRequestHandler);
  1141.     }
  1142.     
  1143.     if (status == HXR_OK)
  1144.     {
  1145. status = pRequestHandler->SetRequest(pRequest);
  1146.     }
  1148.     HX_RELEASE(pRequest);
  1149.     HX_RELEASE(pRequestHandler);
  1150.     
  1151.     if (status == HXR_OK)
  1152.     {
  1153. status = m_pCurrentHandle->m_pFileObject->Init
  1154.     (m_ulFlags, 
  1155.     (IHXFileResponse*) this);
  1156.     }
  1157. }
  1159. if (status != HXR_OK)
  1160. {
  1161.     retVal = HandleFailureAsync(status);
  1162. }
  1163.     }
  1165.     return retVal;
  1166. }
  1169. /****************************************************************************
  1170.  *  IUnknown methods
  1171.  */
  1172. /////////////////////////////////////////////////////////////////////////
  1173. //  Method:
  1174. // IUnknown::QueryInterface
  1175. //
  1176. STDMETHODIMP CFileSwitcher::QueryInterface(REFIID riid, void** ppvObj)
  1177. {
  1178.     if (IsEqualIID(riid, IID_IHXFileSwitcher))
  1179.     {
  1180. AddRef();
  1181. *ppvObj = (IHXFileSwitcher*) this;
  1182. return HXR_OK;
  1183.     }
  1184.     else if (IsEqualIID(riid, IID_IHXCallback))
  1185.     {
  1186.         AddRef();
  1187.         *ppvObj = (IHXCallback*)this;
  1188.         return HXR_OK;
  1189.     }
  1190.     else if (IsEqualIID(riid, IID_IHXGetFileFromSamePoolResponse))
  1191.     {
  1192. AddRef();
  1193. *ppvObj = (IHXGetFileFromSamePoolResponse*) this;
  1194. return HXR_OK;
  1195.     }
  1196.     else if (IsEqualIID(riid, IID_IHXFileResponse))
  1197.     {
  1198. AddRef();
  1199. *ppvObj = (IHXFileResponse*) this;
  1200. return HXR_OK;
  1201.     }
  1202.     else if (IsEqualIID(riid, IID_IUnknown))
  1203.     {
  1204. AddRef();
  1205. *ppvObj = this;
  1206. return HXR_OK;
  1207.     }
  1208.     else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
  1209.     {
  1210. AddRef();
  1211. *ppvObj = (IHXThreadSafeMethods*) this;
  1212. return HXR_OK;
  1213.     }
  1215.     *ppvObj = NULL;
  1217.     return HXR_NOINTERFACE;
  1218. }
  1220. /////////////////////////////////////////////////////////////////////////
  1221. //  Method:
  1222. // IUnknown::AddRef
  1223. //
  1224. STDMETHODIMP_(ULONG32) CFileSwitcher::AddRef()
  1225. {
  1226.     return InterlockedIncrement(&m_lRefCount);
  1227. }
  1229. /////////////////////////////////////////////////////////////////////////
  1230. //  Method:
  1231. // IUnknown::Release
  1232. //
  1233. STDMETHODIMP_(ULONG32) CFileSwitcher::Release()
  1234. {
  1235.     if (InterlockedDecrement(&m_lRefCount) > 0)
  1236.     {
  1237.         return m_lRefCount;
  1238.     }
  1240.     delete this;
  1241.     return 0;
  1242. }