LCOV - code coverage report
Current view: top level - store/source - store.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 126 292 43.2 %
Date: 2014-11-03 Functions: 22 34 64.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "store/store.h"
      21             : 
      22             : #include <sal/types.h>
      23             : #include <rtl/string.hxx>
      24             : #include <rtl/ref.hxx>
      25             : 
      26             : #include "object.hxx"
      27             : #include "lockbyte.hxx"
      28             : 
      29             : #include "storbase.hxx"
      30             : #include "storpage.hxx"
      31             : #include "stordir.hxx"
      32             : #include "storlckb.hxx"
      33             : 
      34             : using rtl::Reference;
      35             : 
      36             : namespace store
      37             : {
      38             : /** Template helper class as type safe Reference to store_handle_type.
      39             :  */
      40             : template<class store_handle_type>
      41        3668 : class OStoreHandle : public rtl::Reference<store_handle_type>
      42             : {
      43             : public:
      44        3668 :     OStoreHandle (store_handle_type * pHandle)
      45        3668 :         : rtl::Reference<store_handle_type> (pHandle)
      46        3668 :     {}
      47             : 
      48        3960 :     static store_handle_type * SAL_CALL query (void * pHandle)
      49             :     {
      50             :         return store::query (
      51             :             static_cast<IStoreHandle*>(pHandle),
      52        3960 :             static_cast<store_handle_type*>(0));
      53             :     }
      54             : };
      55             : }
      56             : 
      57             : using namespace store;
      58             : 
      59             : /*========================================================================
      60             :  *
      61             :  * storeHandle implementation.
      62             :  *
      63             :  *======================================================================*/
      64             : /*
      65             :  * store_acquireHandle.
      66             :  */
      67         310 : storeError SAL_CALL store_acquireHandle (
      68             :     storeHandle Handle
      69             : ) SAL_THROW_EXTERN_C()
      70             : {
      71         310 :     IStoreHandle *pHandle = static_cast<IStoreHandle*>(Handle);
      72         310 :     if (!pHandle)
      73           0 :         return store_E_InvalidHandle;
      74             : 
      75         310 :     pHandle->acquire();
      76         310 :     return store_E_None;
      77             : }
      78             : 
      79             : /*
      80             :  * store_releaseHandle.
      81             :  */
      82        2952 : storeError SAL_CALL store_releaseHandle (
      83             :     storeHandle Handle
      84             : ) SAL_THROW_EXTERN_C()
      85             : {
      86        2952 :     IStoreHandle *pHandle = static_cast<IStoreHandle*>(Handle);
      87        2952 :     if (!pHandle)
      88           0 :         return store_E_InvalidHandle;
      89             : 
      90        2952 :     pHandle->release();
      91        2952 :     return store_E_None;
      92             : }
      93             : 
      94             : /*========================================================================
      95             :  *
      96             :  * storeFileHandle implementation.
      97             :  *
      98             :  *======================================================================*/
      99             : /*
     100             :  * store_createMemoryFile.
     101             :  */
     102           4 : storeError SAL_CALL store_createMemoryFile (
     103             :     sal_uInt16       nPageSize,
     104             :     storeFileHandle *phFile
     105             : ) SAL_THROW_EXTERN_C()
     106             : {
     107           4 :     if (!phFile)
     108           0 :         return store_E_InvalidParameter;
     109           4 :     *phFile = NULL;
     110             : 
     111           4 :     Reference<ILockBytes> xLockBytes;
     112             : 
     113           4 :     storeError eErrCode = MemoryLockBytes_createInstance(xLockBytes);
     114           4 :     if (eErrCode != store_E_None)
     115           0 :         return eErrCode;
     116             :     OSL_ASSERT(xLockBytes.is());
     117             : 
     118           8 :     Reference<OStorePageManager> xManager (new OStorePageManager());
     119           4 :     if (!xManager.is())
     120           0 :         return store_E_OutOfMemory;
     121             : 
     122           4 :     eErrCode = xManager->initialize (
     123           4 :         &*xLockBytes, store_AccessCreate, nPageSize);
     124           4 :     if (eErrCode != store_E_None)
     125           0 :         return eErrCode;
     126             : 
     127           4 :     xManager->acquire();
     128             : 
     129           4 :     *phFile = (storeFileHandle)&(*xManager);
     130           8 :     return store_E_None;
     131             : }
     132             : 
     133             : /*
     134             :  * store_openFile.
     135             :  */
     136         300 : storeError SAL_CALL store_openFile (
     137             :     rtl_uString     *pFilename,
     138             :     storeAccessMode  eAccessMode,
     139             :     sal_uInt16       nPageSize,
     140             :     storeFileHandle *phFile
     141             : ) SAL_THROW_EXTERN_C()
     142             : {
     143         300 :     if (phFile)
     144         300 :         *phFile = NULL;
     145             : 
     146         300 :     if (!(pFilename && phFile))
     147           0 :         return store_E_InvalidParameter;
     148             : 
     149         300 :     Reference<ILockBytes> xLockBytes;
     150             : 
     151         300 :     storeError eErrCode = FileLockBytes_createInstance (xLockBytes, pFilename, eAccessMode);
     152         300 :     if (eErrCode != store_E_None)
     153           4 :         return eErrCode;
     154             :     OSL_ASSERT(xLockBytes.is());
     155             : 
     156         592 :     Reference<OStorePageManager> xManager (new OStorePageManager());
     157         296 :     if (!xManager.is())
     158           0 :         return store_E_OutOfMemory;
     159             : 
     160         296 :     eErrCode = xManager->initialize (
     161         296 :         &*xLockBytes, eAccessMode, nPageSize);
     162         296 :     if (eErrCode != store_E_None)
     163           4 :         return eErrCode;
     164             : 
     165         292 :     xManager->acquire();
     166             : 
     167         292 :     *phFile = (storeFileHandle)&(*xManager);
     168         592 :     return store_E_None;
     169             : }
     170             : 
     171             : /*
     172             :  * store_closeFile.
     173             :  */
     174         292 : storeError SAL_CALL store_closeFile (
     175             :     storeFileHandle Handle
     176             : ) SAL_THROW_EXTERN_C()
     177             : {
     178             :     OStorePageManager *pManager =
     179         292 :         OStoreHandle<OStorePageManager>::query (Handle);
     180         292 :     if (!pManager)
     181           0 :         return store_E_InvalidHandle;
     182             : 
     183         292 :     storeError eErrCode = pManager->close();
     184         292 :     pManager->release();
     185         292 :     return eErrCode;
     186             : }
     187             : 
     188             : /*
     189             :  * store_flushFile.
     190             :  */
     191           4 : storeError SAL_CALL store_flushFile (
     192             :     storeFileHandle Handle
     193             : ) SAL_THROW_EXTERN_C()
     194             : {
     195             :     OStoreHandle<OStorePageManager> xManager (
     196           4 :         OStoreHandle<OStorePageManager>::query (Handle));
     197           4 :     if (!xManager.is())
     198           0 :         return store_E_InvalidHandle;
     199             : 
     200           4 :     return xManager->flush();
     201             : }
     202             : 
     203             : /*
     204             :  * store_getFileRefererCount.
     205             :  */
     206           0 : storeError SAL_CALL store_getFileRefererCount (
     207             :     storeFileHandle  Handle,
     208             :     sal_uInt32      *pnRefCount
     209             : ) SAL_THROW_EXTERN_C()
     210             : {
     211             :     OStoreHandle<OStorePageManager> xManager (
     212           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     213           0 :     if (!xManager.is())
     214           0 :         return store_E_InvalidHandle;
     215             : 
     216           0 :     if (!pnRefCount)
     217           0 :         return store_E_InvalidParameter;
     218             : 
     219           0 :     *pnRefCount = xManager->getRefererCount();
     220           0 :     return store_E_None;
     221             : }
     222             : 
     223             : /*
     224             :  * store_getFileSize.
     225             :  */
     226           0 : storeError SAL_CALL store_getFileSize (
     227             :     storeFileHandle  Handle,
     228             :     sal_uInt32      *pnSize
     229             : ) SAL_THROW_EXTERN_C()
     230             : {
     231             :     OStoreHandle<OStorePageManager> xManager (
     232           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     233           0 :     if (!xManager.is())
     234           0 :         return store_E_InvalidHandle;
     235             : 
     236           0 :     if (!pnSize)
     237           0 :         return store_E_InvalidParameter;
     238             : 
     239           0 :     return xManager->size (*pnSize);
     240             : }
     241             : 
     242             : /*
     243             :  * store_rebuildFile.
     244             :  */
     245           0 : storeError SAL_CALL store_rebuildFile (
     246             :     rtl_uString *pSrcFilename,
     247             :     rtl_uString *pDstFilename
     248             : ) SAL_THROW_EXTERN_C()
     249             : {
     250           0 :     storeError eErrCode = store_E_None;
     251             : 
     252           0 :     if (!(pSrcFilename && pDstFilename))
     253           0 :         return store_E_InvalidParameter;
     254             : 
     255           0 :     Reference<OStorePageManager> xManager (new OStorePageManager());
     256           0 :     if (!xManager.is())
     257           0 :         return store_E_OutOfMemory;
     258             : 
     259           0 :     Reference<ILockBytes> xSrcLB;
     260           0 :     eErrCode = FileLockBytes_createInstance (xSrcLB, pSrcFilename, store_AccessReadOnly);
     261           0 :     if (eErrCode != store_E_None)
     262           0 :         return eErrCode;
     263             :     OSL_ASSERT(xSrcLB.is());
     264             : 
     265           0 :     Reference<ILockBytes> xDstLB;
     266           0 :     eErrCode = FileLockBytes_createInstance (xDstLB, pDstFilename, store_AccessCreate);
     267           0 :     if (eErrCode != store_E_None)
     268           0 :         return eErrCode;
     269             :     OSL_ASSERT(xDstLB.is());
     270             : 
     271           0 :     return xManager->rebuild (&*xSrcLB, &*xDstLB);
     272             : }
     273             : 
     274             : /*========================================================================
     275             :  *
     276             :  * storeDirectoryHandle implementation.
     277             :  *
     278             :  *======================================================================*/
     279             : /*
     280             :  * store_openDirectory.
     281             :  */
     282        1840 : storeError SAL_CALL store_openDirectory (
     283             :     storeFileHandle       hFile,
     284             :     rtl_uString          *pPath,
     285             :     rtl_uString          *pName,
     286             :     storeAccessMode       eAccessMode,
     287             :     storeDirectoryHandle *phDirectory
     288             : ) SAL_THROW_EXTERN_C()
     289             : {
     290        1840 :     storeError eErrCode = store_E_None;
     291        1840 :     if (phDirectory)
     292        1840 :         *phDirectory = NULL;
     293             : 
     294             :     OStoreHandle<OStorePageManager> xManager (
     295        1840 :         OStoreHandle<OStorePageManager>::query (hFile));
     296        1840 :     if (!xManager.is())
     297           0 :         return store_E_InvalidHandle;
     298             : 
     299        1840 :     if (!(pPath && pName && phDirectory))
     300           0 :         return store_E_InvalidParameter;
     301             : 
     302        3680 :     Reference<OStoreDirectory_Impl> xDirectory (new OStoreDirectory_Impl());
     303        1840 :     if (!xDirectory.is())
     304           0 :         return store_E_OutOfMemory;
     305             : 
     306        3680 :     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
     307        3680 :     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
     308             : 
     309        1840 :     eErrCode = xDirectory->create (&*xManager, aPath.pData, aName.pData, eAccessMode);
     310        1840 :     if (eErrCode != store_E_None)
     311          12 :         return eErrCode;
     312             : 
     313        1828 :     xDirectory->acquire();
     314             : 
     315        1828 :     *phDirectory = (storeDirectoryHandle)&(*xDirectory);
     316        3668 :     return store_E_None;
     317             : }
     318             : 
     319             : /*
     320             :  * store_closeDirectory.
     321             :  */
     322           0 : storeError SAL_CALL store_closeDirectory (
     323             :     storeDirectoryHandle Handle
     324             : ) SAL_THROW_EXTERN_C()
     325             : {
     326             :     OStoreDirectory_Impl *pDirectory =
     327           0 :         OStoreHandle<OStoreDirectory_Impl>::query (Handle);
     328           0 :     if (!pDirectory)
     329           0 :         return store_E_InvalidHandle;
     330             : 
     331           0 :     pDirectory->release();
     332           0 :     return store_E_None;
     333             : }
     334             : 
     335             : /*
     336             :  * store_findFirst.
     337             :  */
     338          74 : storeError SAL_CALL store_findFirst (
     339             :     storeDirectoryHandle  Handle,
     340             :     storeFindData        *pFindData
     341             : ) SAL_THROW_EXTERN_C()
     342             : {
     343             :     OStoreHandle<OStoreDirectory_Impl> xDirectory (
     344          74 :         OStoreHandle<OStoreDirectory_Impl>::query (Handle));
     345          74 :     if (!xDirectory.is())
     346           0 :         return store_E_InvalidHandle;
     347             : 
     348          74 :     if (!pFindData)
     349           0 :         return store_E_InvalidParameter;
     350             : 
     351             :     // Initialize FindData.
     352          74 :     memset (pFindData, 0, sizeof (storeFindData));
     353             : 
     354             :     // Find first.
     355          74 :     pFindData->m_nReserved = (sal_uInt32)(~0);
     356          74 :     return xDirectory->iterate (*pFindData);
     357             : }
     358             : 
     359             : /*
     360             :  * store_findNext.
     361             :  */
     362          82 : storeError SAL_CALL store_findNext (
     363             :     storeDirectoryHandle  Handle,
     364             :     storeFindData        *pFindData
     365             : ) SAL_THROW_EXTERN_C()
     366             : {
     367             :     OStoreHandle<OStoreDirectory_Impl> xDirectory (
     368          82 :         OStoreHandle<OStoreDirectory_Impl>::query (Handle));
     369          82 :     if (!xDirectory.is())
     370           0 :         return store_E_InvalidHandle;
     371             : 
     372          82 :     if (!pFindData)
     373           0 :         return store_E_InvalidParameter;
     374             : 
     375             :     // Check FindData.
     376          82 :     if (!pFindData->m_nReserved)
     377           0 :         return store_E_NoMoreFiles;
     378             : 
     379             :     // Find next.
     380          82 :     pFindData->m_nReserved -= 1;
     381          82 :     return xDirectory->iterate (*pFindData);
     382             : }
     383             : 
     384             : /*========================================================================
     385             :  *
     386             :  * storeStreamHandle implementation.
     387             :  *
     388             :  *======================================================================*/
     389             : /*
     390             :  * store_openStream
     391             :  */
     392         830 : storeError SAL_CALL store_openStream (
     393             :     storeFileHandle    hFile,
     394             :     rtl_uString       *pPath,
     395             :     rtl_uString       *pName,
     396             :     storeAccessMode    eAccessMode,
     397             :     storeStreamHandle *phStream
     398             : ) SAL_THROW_EXTERN_C()
     399             : {
     400         830 :     storeError eErrCode = store_E_None;
     401         830 :     if (phStream)
     402         830 :         *phStream = NULL;
     403             : 
     404             :     OStoreHandle<OStorePageManager> xManager (
     405         830 :         OStoreHandle<OStorePageManager>::query (hFile));
     406         830 :     if (!xManager.is())
     407           0 :         return store_E_InvalidHandle;
     408             : 
     409         830 :     if (!(pPath && pName && phStream))
     410           0 :         return store_E_InvalidParameter;
     411             : 
     412        1660 :     Reference<OStoreLockBytes> xLockBytes (new OStoreLockBytes());
     413         830 :     if (!xLockBytes.is())
     414           0 :         return store_E_OutOfMemory;
     415             : 
     416        1660 :     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
     417        1660 :     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
     418             : 
     419         830 :     eErrCode = xLockBytes->create (&*xManager, aPath.pData, aName.pData, eAccessMode);
     420         830 :     if (eErrCode != store_E_None)
     421          16 :         return eErrCode;
     422             : 
     423         814 :     xLockBytes->acquire();
     424             : 
     425         814 :     *phStream = (storeStreamHandle)&(*xLockBytes);
     426        1644 :     return store_E_None;
     427             : }
     428             : 
     429             : /*
     430             :  * store_closeStream.
     431             :  */
     432           0 : storeError SAL_CALL store_closeStream (
     433             :     storeStreamHandle Handle
     434             : ) SAL_THROW_EXTERN_C()
     435             : {
     436             :     OStoreLockBytes *pLockBytes =
     437           0 :         OStoreHandle<OStoreLockBytes>::query (Handle);
     438           0 :     if (!pLockBytes)
     439           0 :         return store_E_InvalidHandle;
     440             : 
     441           0 :     pLockBytes->release();
     442           0 :     return store_E_None;
     443             : }
     444             : 
     445             : /*
     446             :  * store_readStream.
     447             :  */
     448          24 : storeError SAL_CALL store_readStream (
     449             :     storeStreamHandle  Handle,
     450             :     sal_uInt32         nOffset,
     451             :     void              *pBuffer,
     452             :     sal_uInt32         nBytes,
     453             :     sal_uInt32        *pnDone
     454             : ) SAL_THROW_EXTERN_C()
     455             : {
     456             :     OStoreHandle<OStoreLockBytes> xLockBytes (
     457          24 :         OStoreHandle<OStoreLockBytes>::query (Handle));
     458          24 :     if (!xLockBytes.is())
     459           0 :         return store_E_InvalidHandle;
     460             : 
     461          24 :     if (!(pBuffer && pnDone))
     462           0 :         return store_E_InvalidParameter;
     463             : 
     464          24 :     return xLockBytes->readAt (nOffset, pBuffer, nBytes, *pnDone);
     465             : }
     466             : 
     467             : /*
     468             :  * store_writeStream.
     469             :  */
     470         796 : storeError SAL_CALL store_writeStream (
     471             :     storeStreamHandle  Handle,
     472             :     sal_uInt32         nOffset,
     473             :     const void        *pBuffer,
     474             :     sal_uInt32         nBytes,
     475             :     sal_uInt32        *pnDone
     476             : ) SAL_THROW_EXTERN_C()
     477             : {
     478             :     OStoreHandle<OStoreLockBytes> xLockBytes (
     479         796 :         OStoreHandle<OStoreLockBytes>::query (Handle));
     480         796 :     if (!xLockBytes.is())
     481           0 :         return store_E_InvalidHandle;
     482             : 
     483         796 :     if (!(pBuffer && pnDone))
     484           0 :         return store_E_InvalidParameter;
     485             : 
     486         796 :     return xLockBytes->writeAt (nOffset, pBuffer, nBytes, *pnDone);
     487             : }
     488             : 
     489             : /*
     490             :  * store_flushStream.
     491             :  */
     492           0 : storeError SAL_CALL store_flushStream (
     493             :     storeStreamHandle Handle
     494             : ) SAL_THROW_EXTERN_C()
     495             : {
     496             :     OStoreHandle<OStoreLockBytes> xLockBytes (
     497           0 :         OStoreHandle<OStoreLockBytes>::query (Handle));
     498           0 :     if (!xLockBytes.is())
     499           0 :         return store_E_InvalidHandle;
     500             : 
     501           0 :     return xLockBytes->flush();
     502             : }
     503             : 
     504             : /*
     505             :  * store_getStreamSize.
     506             :  */
     507           0 : storeError SAL_CALL store_getStreamSize (
     508             :     storeStreamHandle  Handle,
     509             :     sal_uInt32        *pnSize
     510             : ) SAL_THROW_EXTERN_C()
     511             : {
     512             :     OStoreHandle<OStoreLockBytes> xLockBytes (
     513           0 :         OStoreHandle<OStoreLockBytes>::query (Handle));
     514           0 :     if (!xLockBytes.is())
     515           0 :         return store_E_InvalidHandle;
     516             : 
     517           0 :     if (!pnSize)
     518           0 :         return store_E_InvalidParameter;
     519             : 
     520           0 :     return xLockBytes->stat (*pnSize);
     521             : }
     522             : 
     523             : /*
     524             :  * store_setStreamSize.
     525             :  */
     526           0 : storeError SAL_CALL store_setStreamSize (
     527             :     storeStreamHandle Handle,
     528             :     sal_uInt32        nSize
     529             : ) SAL_THROW_EXTERN_C()
     530             : {
     531             :     OStoreHandle<OStoreLockBytes> xLockBytes (
     532           0 :         OStoreHandle<OStoreLockBytes>::query (Handle));
     533           0 :     if (!xLockBytes.is())
     534           0 :         return store_E_InvalidHandle;
     535             : 
     536           0 :     return xLockBytes->setSize (nSize);
     537             : }
     538             : 
     539             : /*========================================================================
     540             :  *
     541             :  * Common storeDirectoryHandle and storeStreamHandle operations.
     542             :  *
     543             :  *======================================================================*/
     544             : /*
     545             :  * store_attrib.
     546             :  */
     547           0 : storeError SAL_CALL store_attrib (
     548             :     storeFileHandle Handle,
     549             :     rtl_uString    *pPath,
     550             :     rtl_uString    *pName,
     551             :     sal_uInt32      nMask1,
     552             :     sal_uInt32      nMask2,
     553             :     sal_uInt32     *pnAttrib
     554             : ) SAL_THROW_EXTERN_C()
     555             : {
     556           0 :     storeError eErrCode = store_E_None;
     557           0 :     if (pnAttrib)
     558           0 :         *pnAttrib = 0;
     559             : 
     560             :     OStoreHandle<OStorePageManager> xManager (
     561           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     562           0 :     if (!xManager.is())
     563           0 :         return store_E_InvalidHandle;
     564             : 
     565           0 :     if (!(pPath && pName))
     566           0 :         return store_E_InvalidParameter;
     567             : 
     568             :     // Setup page key.
     569           0 :     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
     570           0 :     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
     571           0 :     OStorePageKey aKey;
     572             : 
     573           0 :     eErrCode = OStorePageManager::namei (aPath.pData, aName.pData, aKey);
     574           0 :     if (eErrCode != store_E_None)
     575           0 :         return eErrCode;
     576             : 
     577             :     // Obtain or modify page attributes.
     578           0 :     sal_uInt32 nAttrib = 0;
     579           0 :     eErrCode = xManager->attrib (aKey, nMask1, nMask2, nAttrib);
     580           0 :     if (pnAttrib)
     581           0 :         *pnAttrib = nAttrib;
     582           0 :     return eErrCode;
     583             : }
     584             : 
     585             : /*
     586             :  * store_link.
     587             :  */
     588           0 : storeError SAL_CALL store_link (
     589             :     storeFileHandle Handle,
     590             :     rtl_uString *pSrcPath, rtl_uString *pSrcName,
     591             :     rtl_uString *pDstPath, rtl_uString *pDstName
     592             : ) SAL_THROW_EXTERN_C()
     593             : {
     594           0 :     storeError eErrCode = store_E_None;
     595             : 
     596             :     OStoreHandle<OStorePageManager> xManager (
     597           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     598           0 :     if (!xManager.is())
     599           0 :         return store_E_InvalidHandle;
     600             : 
     601           0 :     if (!(pSrcPath && pSrcName))
     602           0 :         return store_E_InvalidParameter;
     603             : 
     604           0 :     if (!(pDstPath && pDstName))
     605           0 :         return store_E_InvalidParameter;
     606             : 
     607             :     // Setup 'Source' page key.
     608             :     OString aSrcPath (
     609           0 :         pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8);
     610             :     OString aSrcName (
     611           0 :         pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8);
     612           0 :     OStorePageKey aSrcKey;
     613             : 
     614             :     eErrCode = OStorePageManager::namei (
     615           0 :         aSrcPath.pData, aSrcName.pData, aSrcKey);
     616           0 :     if (eErrCode != store_E_None)
     617           0 :         return eErrCode;
     618             : 
     619             :     // Setup 'Destination' page key.
     620             :     OString aDstPath (
     621           0 :         pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8);
     622             :     OString aDstName (
     623           0 :         pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8);
     624           0 :     OStorePageKey aDstKey;
     625             : 
     626             :     eErrCode = OStorePageManager::namei (
     627           0 :         aDstPath.pData, aDstName.pData, aDstKey);
     628           0 :     if (eErrCode != store_E_None)
     629           0 :         return eErrCode;
     630             : 
     631             :     // Link 'Source' hard to 'Destination'.
     632           0 :     return xManager->link (aSrcKey, aDstKey);
     633             : }
     634             : 
     635             : /*
     636             :  * store_symlink.
     637             :  */
     638           0 : storeError SAL_CALL store_symlink (
     639             :     storeFileHandle Handle,
     640             :     rtl_uString *pSrcPath, rtl_uString *pSrcName,
     641             :     rtl_uString *pDstPath, rtl_uString *pDstName
     642             : ) SAL_THROW_EXTERN_C()
     643             : {
     644           0 :     storeError eErrCode = store_E_None;
     645             : 
     646             :     OStoreHandle<OStorePageManager> xManager (
     647           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     648           0 :     if (!xManager.is())
     649           0 :         return store_E_InvalidHandle;
     650             : 
     651           0 :     if (!(pSrcPath && pSrcName))
     652           0 :         return store_E_InvalidParameter;
     653             : 
     654           0 :     if (!(pDstPath && pDstName))
     655           0 :         return store_E_InvalidParameter;
     656             : 
     657             :     // Setup 'Destination' page key.
     658             :     OString aDstPath (
     659           0 :         pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8);
     660             :     OString aDstName (
     661           0 :         pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8);
     662           0 :     OStorePageKey aDstKey;
     663             : 
     664             :     eErrCode = OStorePageManager::namei (
     665           0 :         aDstPath.pData, aDstName.pData, aDstKey);
     666           0 :     if (eErrCode != store_E_None)
     667           0 :         return eErrCode;
     668             : 
     669             :     // Insert 'Source' as symlink to 'Destination'.
     670             :     OString aSrcPath (
     671           0 :         pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8);
     672             :     OString aSrcName (
     673           0 :         pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8);
     674             : 
     675           0 :     return xManager->symlink (aSrcPath.pData, aSrcName.pData, aDstKey);
     676             : }
     677             : 
     678             : /*
     679             :  * store_rename.
     680             :  */
     681           0 : storeError SAL_CALL store_rename (
     682             :     storeFileHandle Handle,
     683             :     rtl_uString *pSrcPath, rtl_uString *pSrcName,
     684             :     rtl_uString *pDstPath, rtl_uString *pDstName
     685             : ) SAL_THROW_EXTERN_C()
     686             : {
     687           0 :     storeError eErrCode = store_E_None;
     688             : 
     689             :     OStoreHandle<OStorePageManager> xManager (
     690           0 :         OStoreHandle<OStorePageManager>::query (Handle));
     691           0 :     if (!xManager.is())
     692           0 :         return store_E_InvalidHandle;
     693             : 
     694           0 :     if (!(pSrcPath && pSrcName))
     695           0 :         return store_E_InvalidParameter;
     696             : 
     697           0 :     if (!(pDstPath && pDstName))
     698           0 :         return store_E_InvalidParameter;
     699             : 
     700             :     // Setup 'Source' page key.
     701             :     OString aSrcPath (
     702           0 :         pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8);
     703             :     OString aSrcName (
     704           0 :         pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8);
     705           0 :     OStorePageKey aSrcKey;
     706             : 
     707             :     eErrCode = OStorePageManager::namei (
     708           0 :         aSrcPath.pData, aSrcName.pData, aSrcKey);
     709           0 :     if (eErrCode != store_E_None)
     710           0 :         return eErrCode;
     711             : 
     712             :     // Rename 'Source' into 'Destination'.
     713             :     OString aDstPath (
     714           0 :         pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8);
     715             :     OString aDstName (
     716           0 :         pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8);
     717             : 
     718           0 :     return xManager->rename (aSrcKey, aDstPath.pData, aDstName.pData);
     719             : }
     720             : 
     721             : /*
     722             :  * store_remove.
     723             :  */
     724          18 : storeError SAL_CALL store_remove (
     725             :     storeFileHandle Handle,
     726             :     rtl_uString    *pPath,
     727             :     rtl_uString    *pName
     728             : ) SAL_THROW_EXTERN_C()
     729             : {
     730          18 :     storeError eErrCode = store_E_None;
     731             : 
     732             :     OStoreHandle<OStorePageManager> xManager (
     733          18 :         OStoreHandle<OStorePageManager>::query (Handle));
     734          18 :     if (!xManager.is())
     735           0 :         return store_E_InvalidHandle;
     736             : 
     737          18 :     if (!(pPath && pName))
     738           0 :         return store_E_InvalidParameter;
     739             : 
     740             :     // Setup page key.
     741          36 :     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
     742          36 :     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
     743          18 :     OStorePageKey aKey;
     744             : 
     745          18 :     eErrCode = OStorePageManager::namei (aPath.pData, aName.pData, aKey);
     746          18 :     if (eErrCode != store_E_None)
     747           0 :         return eErrCode;
     748             : 
     749             :     // Remove.
     750          36 :     return xManager->remove (aKey);
     751             : }
     752             : 
     753             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10