store/source/store.cxx

   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 class OStoreHandle : public rtl::Reference<store_handle_type>
  42 {
  43 public:
  44     explicit OStoreHandle (store_handle_type * pHandle)
  45         : rtl::Reference<store_handle_type> (pHandle)
  46     {}
  47
  48     static store_handle_type * SAL_CALL query (void * pHandle)
  49     {
  50         return store::query (
  51             static_cast<OStoreObject*>(pHandle),
  52             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 storeError SAL_CALL store_acquireHandle (
  68     storeHandle Handle
  69 ) SAL_THROW_EXTERN_C()
  70 {
  71     OStoreObject *pHandle = static_cast<OStoreObject*>(Handle);
  72     if (!pHandle)
  73         return store_E_InvalidHandle;
  74
  75     pHandle->acquire();
  76     return store_E_None;
  77 }
  78
  79 /*
  80  * store_releaseHandle.
  81  */
  82 storeError SAL_CALL store_releaseHandle (
  83     storeHandle Handle
  84 ) SAL_THROW_EXTERN_C()
  85 {
  86     OStoreObject *pHandle = static_cast<OStoreObject*>(Handle);
  87     if (!pHandle)
  88         return store_E_InvalidHandle;
  89
  90     pHandle->release();
  91     return store_E_None;
  92 }
  93
  94 /*========================================================================
  95  *
  96  * storeFileHandle implementation.
  97  *
  98  *======================================================================*/
  99 /*
 100  * store_createMemoryFile.
 101  */
 102 storeError SAL_CALL store_createMemoryFile (
 103     sal_uInt16       nPageSize,
 104     storeFileHandle *phFile
 105 ) SAL_THROW_EXTERN_C()
 106 {
 107     if (!phFile)
 108         return store_E_InvalidParameter;
 109     *phFile = nullptr;
 110
 111     Reference<ILockBytes> xLockBytes;
 112
 113     storeError eErrCode = MemoryLockBytes_createInstance(xLockBytes);
 114     if (eErrCode != store_E_None)
 115         return eErrCode;
 116     OSL_ASSERT(xLockBytes.is());
 117
 118     Reference<OStorePageManager> xManager (new OStorePageManager());
 119     if (!xManager.is())
 120         return store_E_OutOfMemory;
 121
 122     eErrCode = xManager->initialize (
 123         &*xLockBytes, storeAccessMode::Create, nPageSize);
 124     if (eErrCode != store_E_None)
 125         return eErrCode;
 126
 127     xManager->acquire();
 128
 129     *phFile = xManager.get();
 130     return store_E_None;
 131 }
 132
 133 /*
 134  * store_openFile.
 135  */
 136 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     if (phFile)
 144         *phFile = nullptr;
 145
 146     if (!(pFilename && phFile))
 147         return store_E_InvalidParameter;
 148
 149     Reference<ILockBytes> xLockBytes;
 150
 151     storeError eErrCode = FileLockBytes_createInstance (xLockBytes, pFilename, eAccessMode);
 152     if (eErrCode != store_E_None)
 153         return eErrCode;
 154     OSL_ASSERT(xLockBytes.is());
 155
 156     Reference<OStorePageManager> xManager (new OStorePageManager());
 157     if (!xManager.is())
 158         return store_E_OutOfMemory;
 159
 160     eErrCode = xManager->initialize (
 161         &*xLockBytes, eAccessMode, nPageSize);
 162     if (eErrCode != store_E_None)
 163         return eErrCode;
 164
 165     xManager->acquire();
 166
 167     *phFile = xManager.get();
 168     return store_E_None;
 169 }
 170
 171 /*
 172  * store_closeFile.
 173  */
 174 storeError SAL_CALL store_closeFile (
 175     storeFileHandle Handle
 176 ) SAL_THROW_EXTERN_C()
 177 {
 178     OStorePageManager *pManager =
 179         OStoreHandle<OStorePageManager>::query (Handle);
 180     if (!pManager)
 181         return store_E_InvalidHandle;
 182
 183     storeError eErrCode = pManager->close();
 184     pManager->release();
 185     return eErrCode;
 186 }
 187
 188 /*
 189  * store_flushFile.
 190  */
 191 storeError SAL_CALL store_flushFile (
 192     storeFileHandle Handle
 193 ) SAL_THROW_EXTERN_C()
 194 {
 195     OStoreHandle<OStorePageManager> xManager (
 196         OStoreHandle<OStorePageManager>::query (Handle));
 197     if (!xManager.is())
 198         return store_E_InvalidHandle;
 199
 200     return xManager->flush();
 201 }
 202
 203 /*========================================================================
 204  *
 205  * storeDirectoryHandle implementation.
 206  *
 207  *======================================================================*/
 208 /*
 209  * store_openDirectory.
 210  */
 211 storeError SAL_CALL store_openDirectory (
 212     storeFileHandle       hFile,
 213     rtl_uString const    *pPath,
 214     rtl_uString const    *pName,
 215     storeAccessMode       eAccessMode,
 216     storeDirectoryHandle *phDirectory
 217 ) SAL_THROW_EXTERN_C()
 218 {
 219     storeError eErrCode = store_E_None;
 220     if (phDirectory)
 221         *phDirectory = nullptr;
 222
 223     OStoreHandle<OStorePageManager> xManager (
 224         OStoreHandle<OStorePageManager>::query (hFile));
 225     if (!xManager.is())
 226         return store_E_InvalidHandle;
 227
 228     if (!(pPath && pName && phDirectory))
 229         return store_E_InvalidParameter;
 230
 231     Reference<OStoreDirectory_Impl> xDirectory (new OStoreDirectory_Impl());
 232     if (!xDirectory.is())
 233         return store_E_OutOfMemory;
 234
 235     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
 236     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
 237
 238     eErrCode = xDirectory->create (&*xManager, aPath.pData, aName.pData, eAccessMode);
 239     if (eErrCode != store_E_None)
 240         return eErrCode;
 241
 242     xDirectory->acquire();
 243
 244     *phDirectory = xDirectory.get();
 245     return store_E_None;
 246 }
 247
 248 /*
 249  * store_findFirst.
 250  */
 251 storeError SAL_CALL store_findFirst (
 252     storeDirectoryHandle  Handle,
 253     storeFindData        *pFindData
 254 ) SAL_THROW_EXTERN_C()
 255 {
 256     OStoreHandle<OStoreDirectory_Impl> xDirectory (
 257         OStoreHandle<OStoreDirectory_Impl>::query (Handle));
 258     if (!xDirectory.is())
 259         return store_E_InvalidHandle;
 260
 261     if (!pFindData)
 262         return store_E_InvalidParameter;
 263
 264     // Initialize FindData.
 265     memset (pFindData, 0, sizeof (storeFindData));
 266
 267     // Find first.
 268     pFindData->m_nReserved = (sal_uInt32)(~0);
 269     return xDirectory->iterate (*pFindData);
 270 }
 271
 272 /*
 273  * store_findNext.
 274  */
 275 storeError SAL_CALL store_findNext (
 276     storeDirectoryHandle  Handle,
 277     storeFindData        *pFindData
 278 ) SAL_THROW_EXTERN_C()
 279 {
 280     OStoreHandle<OStoreDirectory_Impl> xDirectory (
 281         OStoreHandle<OStoreDirectory_Impl>::query (Handle));
 282     if (!xDirectory.is())
 283         return store_E_InvalidHandle;
 284
 285     if (!pFindData)
 286         return store_E_InvalidParameter;
 287
 288     // Check FindData.
 289     if (!pFindData->m_nReserved)
 290         return store_E_NoMoreFiles;
 291
 292     // Find next.
 293     pFindData->m_nReserved -= 1;
 294     return xDirectory->iterate (*pFindData);
 295 }
 296
 297 /*========================================================================
 298  *
 299  * storeStreamHandle implementation.
 300  *
 301  *======================================================================*/
 302 /*
 303  * store_openStream
 304  */
 305 storeError SAL_CALL store_openStream (
 306     storeFileHandle    hFile,
 307     rtl_uString const *pPath,
 308     rtl_uString const *pName,
 309     storeAccessMode    eAccessMode,
 310     storeStreamHandle *phStream
 311 ) SAL_THROW_EXTERN_C()
 312 {
 313     storeError eErrCode = store_E_None;
 314     if (phStream)
 315         *phStream = nullptr;
 316
 317     OStoreHandle<OStorePageManager> xManager (
 318         OStoreHandle<OStorePageManager>::query (hFile));
 319     if (!xManager.is())
 320         return store_E_InvalidHandle;
 321
 322     if (!(pPath && pName && phStream))
 323         return store_E_InvalidParameter;
 324
 325     Reference<OStoreLockBytes> xLockBytes (new OStoreLockBytes());
 326     if (!xLockBytes.is())
 327         return store_E_OutOfMemory;
 328
 329     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
 330     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
 331
 332     eErrCode = xLockBytes->create (&*xManager, aPath.pData, aName.pData, eAccessMode);
 333     if (eErrCode != store_E_None)
 334         return eErrCode;
 335
 336     xLockBytes->acquire();
 337
 338     *phStream = xLockBytes.get();
 339     return store_E_None;
 340 }
 341
 342 /*
 343  * store_readStream.
 344  */
 345 storeError SAL_CALL store_readStream (
 346     storeStreamHandle  Handle,
 347     sal_uInt32         nOffset,
 348     void              *pBuffer,
 349     sal_uInt32         nBytes,
 350     sal_uInt32        *pnDone
 351 ) SAL_THROW_EXTERN_C()
 352 {
 353     OStoreHandle<OStoreLockBytes> xLockBytes (
 354         OStoreHandle<OStoreLockBytes>::query (Handle));
 355     if (!xLockBytes.is())
 356         return store_E_InvalidHandle;
 357
 358     if (!(pBuffer && pnDone))
 359         return store_E_InvalidParameter;
 360
 361     return xLockBytes->readAt (nOffset, pBuffer, nBytes, *pnDone);
 362 }
 363
 364 /*
 365  * store_writeStream.
 366  */
 367 storeError SAL_CALL store_writeStream (
 368     storeStreamHandle  Handle,
 369     sal_uInt32         nOffset,
 370     const void        *pBuffer,
 371     sal_uInt32         nBytes,
 372     sal_uInt32        *pnDone
 373 ) SAL_THROW_EXTERN_C()
 374 {
 375     OStoreHandle<OStoreLockBytes> xLockBytes (
 376         OStoreHandle<OStoreLockBytes>::query (Handle));
 377     if (!xLockBytes.is())
 378         return store_E_InvalidHandle;
 379
 380     if (!(pBuffer && pnDone))
 381         return store_E_InvalidParameter;
 382
 383     return xLockBytes->writeAt (nOffset, pBuffer, nBytes, *pnDone);
 384 }
 385
 386 /*
 387  * store_remove.
 388  */
 389 storeError SAL_CALL store_remove (
 390     storeFileHandle Handle,
 391     rtl_uString const *pPath,
 392     rtl_uString const *pName
 393 ) SAL_THROW_EXTERN_C()
 394 {
 395     storeError eErrCode = store_E_None;
 396
 397     OStoreHandle<OStorePageManager> xManager (
 398         OStoreHandle<OStorePageManager>::query (Handle));
 399     if (!xManager.is())
 400         return store_E_InvalidHandle;
 401
 402     if (!(pPath && pName))
 403         return store_E_InvalidParameter;
 404
 405     // Setup page key.
 406     OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8);
 407     OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8);
 408     OStorePageKey aKey;
 409
 410     eErrCode = OStorePageManager::namei (aPath.pData, aName.pData, aKey);
 411     if (eErrCode != store_E_None)
 412         return eErrCode;
 413
 414     // Remove.
 415     return xManager->remove (aKey);
 416 }
 417
 418 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */