include/store/store.hxx

   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 #pragma once
  21
  22 #include <store/store.h>
  23 #include <sal/types.h>
  24 #include <rtl/ustring.hxx>
  25 #include <store/types.h>
  26
  27 namespace store
  28 {
  29
  30 class OStoreStream
  31 {
  32 public:
  33     OStoreStream()
  34         : m_hImpl (nullptr)
  35     {}
  36
  37     ~OStoreStream()
  38     {
  39         if (m_hImpl)
  40             (void) store_releaseHandle (m_hImpl);
  41     }
  42
  43     OStoreStream (OStoreStream const & rhs)
  44         : m_hImpl (rhs.m_hImpl)
  45     {
  46         if (m_hImpl)
  47             (void) store_acquireHandle (m_hImpl);
  48     }
  49
  50     OStoreStream & operator= (OStoreStream const & rhs)
  51     {
  52         if (rhs.m_hImpl)
  53             (void) store_acquireHandle (rhs.m_hImpl);
  54         if (m_hImpl)
  55             (void) store_releaseHandle (m_hImpl);
  56         m_hImpl = rhs.m_hImpl;
  57         return *this;
  58     }
  59
  60     /** Open the stream.
  61         @see store_openStream()
  62      */
  63     storeError create (
  64         storeFileHandle       hFile,
  65         OUString const & rPath,
  66         OUString const & rName,
  67         storeAccessMode       eMode)
  68     {
  69         if (m_hImpl)
  70         {
  71             (void) store_releaseHandle (m_hImpl);
  72             m_hImpl = nullptr;
  73         }
  74         return store_openStream (hFile, rPath.pData, rName.pData, eMode, &m_hImpl);
  75     }
  76
  77     /** Read from the stream.
  78         @see store_readStream()
  79      */
  80     storeError readAt (
  81         sal_uInt32   nOffset,
  82         void *       pBuffer,
  83         sal_uInt32   nBytes,
  84         sal_uInt32 & rnDone)
  85     {
  86         if (!m_hImpl)
  87             return store_E_InvalidHandle;
  88
  89         return store_readStream (m_hImpl, nOffset, pBuffer, nBytes, &rnDone);
  90     }
  91
  92     /** Write to the stream.
  93         @see store_writeStream()
  94      */
  95     storeError writeAt (
  96         sal_uInt32   nOffset,
  97         void const * pBuffer,
  98         sal_uInt32   nBytes,
  99         sal_uInt32 & rnDone)
 100     {
 101         if (!m_hImpl)
 102             return store_E_InvalidHandle;
 103
 104         return store_writeStream (m_hImpl, nOffset, pBuffer, nBytes, &rnDone);
 105     }
 106
 107 private:
 108     storeStreamHandle m_hImpl;
 109 };
 110
 111 class OStoreDirectory
 112 {
 113 public:
 114     OStoreDirectory()
 115         : m_hImpl (nullptr)
 116     {}
 117
 118     ~OStoreDirectory()
 119     {
 120         if (m_hImpl)
 121             (void) store_releaseHandle (m_hImpl);
 122     }
 123
 124     OStoreDirectory (OStoreDirectory const & rhs)
 125         : m_hImpl (rhs.m_hImpl)
 126     {
 127         if (m_hImpl)
 128             (void) store_acquireHandle (m_hImpl);
 129     }
 130
 131     OStoreDirectory (OStoreDirectory && rhs) noexcept
 132         : m_hImpl (rhs.m_hImpl)
 133     {
 134         rhs.m_hImpl = nullptr;
 135     }
 136
 137     OStoreDirectory & operator= (OStoreDirectory const & rhs)
 138     {
 139         if (rhs.m_hImpl)
 140             (void) store_acquireHandle (rhs.m_hImpl);
 141         if (m_hImpl)
 142             (void) store_releaseHandle (m_hImpl);
 143         m_hImpl = rhs.m_hImpl;
 144         return *this;
 145     }
 146
 147     OStoreDirectory & operator= (OStoreDirectory && rhs) noexcept
 148     {
 149         if (m_hImpl)
 150             (void) store_releaseHandle (m_hImpl);
 151         m_hImpl = rhs.m_hImpl;
 152         rhs.m_hImpl = nullptr;
 153         return *this;
 154     }
 155
 156     /** Open the directory.
 157         @see store_openDirectory()
 158      */
 159     storeError create (
 160         storeFileHandle       hFile,
 161         OUString const & rPath,
 162         OUString const & rName,
 163         storeAccessMode       eMode)
 164     {
 165         if (m_hImpl)
 166         {
 167             (void) store_releaseHandle (m_hImpl);
 168             m_hImpl = nullptr;
 169         }
 170         return store_openDirectory (hFile, rPath.pData, rName.pData, eMode, &m_hImpl);
 171     }
 172
 173     /** Directory iterator type.
 174         @see first()
 175         @see next()
 176      */
 177     typedef storeFindData iterator;
 178
 179     /** Find first directory entry.
 180         @see store_findFirst()
 181      */
 182     storeError first (iterator& it)
 183     {
 184         if (!m_hImpl)
 185             return store_E_InvalidHandle;
 186
 187         return store_findFirst (m_hImpl, &it);
 188     }
 189
 190     /** Find next directory entry.
 191         @see store_findNext()
 192      */
 193     storeError next (iterator& it)
 194     {
 195         if (!m_hImpl)
 196             return store_E_InvalidHandle;
 197
 198         return store_findNext (m_hImpl, &it);
 199     }
 200
 201 private:
 202     storeDirectoryHandle m_hImpl;
 203 };
 204
 205 class OStoreFile
 206 {
 207 public:
 208     OStoreFile()
 209         : m_hImpl (nullptr)
 210     {}
 211
 212     ~OStoreFile()
 213     {
 214         if (m_hImpl)
 215             (void) store_releaseHandle (m_hImpl);
 216     }
 217
 218     OStoreFile (OStoreFile const & rhs)
 219         : m_hImpl (rhs.m_hImpl)
 220     {
 221         if (m_hImpl)
 222             (void) store_acquireHandle (m_hImpl);
 223     }
 224
 225     OStoreFile & operator= (OStoreFile const & rhs)
 226     {
 227         if (rhs.m_hImpl)
 228             (void) store_acquireHandle (rhs.m_hImpl);
 229         if (m_hImpl)
 230             (void) store_releaseHandle (m_hImpl);
 231         m_hImpl = rhs.m_hImpl;
 232         return *this;
 233     }
 234
 235     operator storeFileHandle() const
 236     {
 237         return m_hImpl;
 238     }
 239
 240     /** Check for a valid File Handle.
 241         @return sal_True if valid, sal_False otherwise.
 242      */
 243     bool isValid() const
 244     {
 245         return (m_hImpl != nullptr);
 246     }
 247
 248     /** Open the file.
 249         @see store_openFile()
 250      */
 251     storeError create(
 252         OUString const & rFilename,
 253         storeAccessMode       eAccessMode )
 254     {
 255         if (m_hImpl)
 256         {
 257             (void) store_releaseHandle (m_hImpl);
 258             m_hImpl = nullptr;
 259         }
 260         return store_openFile (rFilename.pData, eAccessMode, STORE_DEFAULT_PAGESIZE, &m_hImpl);
 261     }
 262
 263     /** Open the temporary file in memory.
 264         @see store_createMemoryFile()
 265      */
 266     storeError createInMemory ()
 267     {
 268         if (m_hImpl)
 269         {
 270             (void) store_releaseHandle (m_hImpl);
 271             m_hImpl = nullptr;
 272         }
 273         return store_createMemoryFile (STORE_DEFAULT_PAGESIZE, &m_hImpl);
 274     }
 275
 276     /** Close the file.
 277         @see store_closeFile()
 278      */
 279     void close()
 280     {
 281         if (m_hImpl)
 282         {
 283             (void) store_closeFile (m_hImpl);
 284             m_hImpl = nullptr;
 285         }
 286     }
 287
 288     /** Flush the file.
 289         @see store_flushFile()
 290      */
 291     storeError flush() const
 292     {
 293         if (!m_hImpl)
 294             return store_E_InvalidHandle;
 295
 296         return store_flushFile (m_hImpl);
 297     }
 298
 299     /** Remove a file entry.
 300         @see store_remove()
 301      */
 302     storeError remove (
 303         OUString const & rPath, OUString const & rName)
 304     {
 305         if (!m_hImpl)
 306             return store_E_InvalidHandle;
 307
 308         return store_remove (m_hImpl, rPath.pData, rName.pData);
 309     }
 310
 311 private:
 312     storeFileHandle m_hImpl;
 313 };
 314
 315 } // namespace store
 316
 317 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */