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