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 <sal/types.h>
  24 #include <rtl/ustring.hxx>
  25 #include <store/store.h>
  26
  27 namespace store
  28 {
  29
  30 /*========================================================================
  31  *
  32  * OStoreStream interface.
  33  *
  34  *======================================================================*/
  35 class OStoreStream
  36 {
  37 public:
  38     /** Construction.
  39      */
  40     inline OStoreStream()
  41         : m_hImpl (0)
  42     {}
  43
  44     /** Destruction.
  45      */
  46     inline ~OStoreStream()
  47     {
  48         if (m_hImpl)
  49             (void) store_releaseHandle (m_hImpl);
  50     }
  51
  52     /** Copy construction.
  53      */
  54     inline OStoreStream (OStoreStream const & rhs)
  55         : m_hImpl (rhs.m_hImpl)
  56     {
  57         if (m_hImpl)
  58             (void) store_acquireHandle (m_hImpl);
  59     }
  60
  61     /** Assignment.
  62      */
  63     inline OStoreStream & operator= (OStoreStream const & rhs)
  64     {
  65         if (rhs.m_hImpl)
  66             (void) store_acquireHandle (rhs.m_hImpl);
  67         if (m_hImpl)
  68             (void) store_releaseHandle (m_hImpl);
  69         m_hImpl = rhs.m_hImpl;
  70         return *this;
  71     }
  72
  73     /** Construction from Stream Handle.
  74      */
  75     inline explicit OStoreStream (storeStreamHandle Handle)
  76         : m_hImpl (Handle)
  77     {
  78         if (m_hImpl)
  79             (void) store_acquireHandle (m_hImpl);
  80     }
  81
  82     /** Conversion into Stream Handle.
  83      */
  84     inline operator storeStreamHandle() const
  85     {
  86         return m_hImpl;
  87     }
  88
  89     /** Check for a valid Stream Handle.
  90         @return sal_True if valid, sal_False otherwise.
  91      */
  92     inline bool isValid() const
  93     {
  94         return (m_hImpl != 0);
  95     }
  96
  97     /** Open the stream.
  98         @see store_openStream()
  99      */
 100     inline storeError create (
 101         storeFileHandle       hFile,
 102         rtl::OUString const & rPath,
 103         rtl::OUString const & rName,
 104         storeAccessMode       eMode)
 105     {
 106         if (m_hImpl)
 107         {
 108             (void) store_releaseHandle (m_hImpl);
 109             m_hImpl = 0;
 110         }
 111         return store_openStream (hFile, rPath.pData, rName.pData, eMode, &m_hImpl);
 112     }
 113
 114     /** Close the stream.
 115         @see store_closeStream()
 116      */
 117     inline void close()
 118     {
 119         if (m_hImpl)
 120         {
 121             (void) store_closeStream (m_hImpl);
 122             m_hImpl = 0;
 123         }
 124     }
 125
 126     /** Read from the stream.
 127         @see store_readStream()
 128      */
 129     inline storeError readAt (
 130         sal_uInt32   nOffset,
 131         void *       pBuffer,
 132         sal_uInt32   nBytes,
 133         sal_uInt32 & rnDone)
 134     {
 135         if (!m_hImpl)
 136             return store_E_InvalidHandle;
 137
 138         return store_readStream (m_hImpl, nOffset, pBuffer, nBytes, &rnDone);
 139     }
 140
 141     /** Write to the stream.
 142         @see store_writeStream()
 143      */
 144     inline storeError writeAt (
 145         sal_uInt32   nOffset,
 146         void const * pBuffer,
 147         sal_uInt32   nBytes,
 148         sal_uInt32 & rnDone)
 149     {
 150         if (!m_hImpl)
 151             return store_E_InvalidHandle;
 152
 153         return store_writeStream (m_hImpl, nOffset, pBuffer, nBytes, &rnDone);
 154     }
 155
 156     /** Flush the stream.
 157         @see store_flushStream()
 158      */
 159     inline storeError flush() const
 160     {
 161         if (!m_hImpl)
 162             return store_E_InvalidHandle;
 163
 164         return store_flushStream (m_hImpl);
 165     }
 166
 167     /** Get the stream size.
 168         @see store_getStreamSize()
 169      */
 170     inline storeError getSize (sal_uInt32 & rnSize) const
 171     {
 172         if (!m_hImpl)
 173             return store_E_InvalidHandle;
 174
 175         return store_getStreamSize (m_hImpl, &rnSize);
 176     }
 177
 178     /** Set the stream size.
 179         @see store_setStreamSize()
 180      */
 181     inline storeError setSize (sal_uInt32 nSize)
 182     {
 183         if (!m_hImpl)
 184             return store_E_InvalidHandle;
 185
 186         return store_setStreamSize (m_hImpl, nSize);
 187     }
 188
 189 private:
 190     /** Representation.
 191      */
 192     storeStreamHandle m_hImpl;
 193 };
 194
 195 /*========================================================================
 196  *
 197  * OStoreDirectory interface.
 198  *
 199  *======================================================================*/
 200 class OStoreDirectory
 201 {
 202 public:
 203     /** Construction.
 204      */
 205     inline OStoreDirectory()
 206         : m_hImpl (0)
 207     {}
 208
 209     /** Destruction.
 210      */
 211     inline ~OStoreDirectory()
 212     {
 213         if (m_hImpl)
 214             (void) store_releaseHandle (m_hImpl);
 215     }
 216
 217     /** Copy construction.
 218      */
 219     inline OStoreDirectory (OStoreDirectory const & rhs)
 220         : m_hImpl (rhs.m_hImpl)
 221     {
 222         if (m_hImpl)
 223             (void) store_acquireHandle (m_hImpl);
 224     }
 225
 226     /** Assignment.
 227      */
 228     inline OStoreDirectory & operator= (OStoreDirectory const & rhs)
 229     {
 230         if (rhs.m_hImpl)
 231             (void) store_acquireHandle (rhs.m_hImpl);
 232         if (m_hImpl)
 233             (void) store_releaseHandle (m_hImpl);
 234         m_hImpl = rhs.m_hImpl;
 235         return *this;
 236     }
 237
 238     /** Construction from Directory Handle.
 239      */
 240     inline explicit OStoreDirectory (storeDirectoryHandle Handle)
 241         : m_hImpl (Handle)
 242     {
 243         if (m_hImpl)
 244             (void) store_acquireHandle (m_hImpl);
 245     }
 246
 247     /** Conversion into Directory Handle.
 248      */
 249     inline operator storeDirectoryHandle() const
 250     {
 251         return m_hImpl;
 252     }
 253
 254     /** Check for a valid Directory Handle.
 255         @return sal_True if valid, sal_False otherwise.
 256      */
 257     inline bool isValid() const
 258     {
 259         return (m_hImpl != 0);
 260     }
 261
 262     /** Open the directory.
 263         @see store_openDirectory()
 264      */
 265     inline storeError create (
 266         storeFileHandle       hFile,
 267         rtl::OUString const & rPath,
 268         rtl::OUString const & rName,
 269         storeAccessMode       eMode)
 270     {
 271         if (m_hImpl)
 272         {
 273             (void) store_releaseHandle (m_hImpl);
 274             m_hImpl = 0;
 275         }
 276         return store_openDirectory (hFile, rPath.pData, rName.pData, eMode, &m_hImpl);
 277     }
 278
 279     /** Close the directory.
 280         @see store_closeDirectory()
 281      */
 282     inline void close()
 283     {
 284         if (m_hImpl)
 285         {
 286             (void) store_closeDirectory (m_hImpl);
 287             m_hImpl = 0;
 288         }
 289     }
 290
 291     /** Directory iterator type.
 292         @see first()
 293         @see next()
 294      */
 295     typedef storeFindData iterator;
 296
 297     /** Find first directory entry.
 298         @see store_findFirst()
 299      */
 300     inline storeError first (iterator& it)
 301     {
 302         if (!m_hImpl)
 303             return store_E_InvalidHandle;
 304
 305         return store_findFirst (m_hImpl, &it);
 306     }
 307
 308     /** Find next directory entry.
 309         @see store_findNext()
 310      */
 311     inline storeError next (iterator& it)
 312     {
 313         if (!m_hImpl)
 314             return store_E_InvalidHandle;
 315
 316         return store_findNext (m_hImpl, &it);
 317     }
 318
 319 private:
 320     /** Representation.
 321      */
 322     storeDirectoryHandle m_hImpl;
 323 };
 324
 325 /*========================================================================
 326  *
 327  * OStoreFile interface.
 328  *
 329  *======================================================================*/
 330 class OStoreFile
 331 {
 332 public:
 333     /** Construction.
 334      */
 335     inline OStoreFile()
 336         : m_hImpl (0)
 337     {}
 338
 339     /** Destruction.
 340      */
 341     inline ~OStoreFile()
 342     {
 343         if (m_hImpl)
 344             (void) store_releaseHandle (m_hImpl);
 345     }
 346
 347     /** Copy construction.
 348      */
 349     inline OStoreFile (OStoreFile const & rhs)
 350         : m_hImpl (rhs.m_hImpl)
 351     {
 352         if (m_hImpl)
 353             (void) store_acquireHandle (m_hImpl);
 354     }
 355
 356     /** Assignment.
 357      */
 358     inline OStoreFile & operator= (OStoreFile const & rhs)
 359     {
 360         if (rhs.m_hImpl)
 361             (void) store_acquireHandle (rhs.m_hImpl);
 362         if (m_hImpl)
 363             (void) store_releaseHandle (m_hImpl);
 364         m_hImpl = rhs.m_hImpl;
 365         return *this;
 366     }
 367
 368     /** Construction from File Handle.
 369      */
 370     inline explicit OStoreFile (storeFileHandle Handle)
 371         : m_hImpl (Handle)
 372     {
 373         if (m_hImpl)
 374             (void) store_acquireHandle (m_hImpl);
 375     }
 376
 377     /** Conversion into File Handle.
 378      */
 379     inline operator storeFileHandle() const
 380     {
 381         return m_hImpl;
 382     }
 383
 384     /** Check for a valid File Handle.
 385         @return sal_True if valid, sal_False otherwise.
 386      */
 387     inline bool isValid() const
 388     {
 389         return (m_hImpl != 0);
 390     }
 391
 392     /** Open the file.
 393         @see store_openFile()
 394      */
 395     inline storeError create (
 396         rtl::OUString const & rFilename,
 397         storeAccessMode       eAccessMode,
 398         sal_uInt16            nPageSize = STORE_DEFAULT_PAGESIZE)
 399     {
 400         if (m_hImpl)
 401         {
 402             (void) store_releaseHandle (m_hImpl);
 403             m_hImpl = 0;
 404         }
 405         return store_openFile (rFilename.pData, eAccessMode, nPageSize, &m_hImpl);
 406     }
 407
 408     /** Open the temporary file in memory.
 409         @see store_createMemoryFile()
 410      */
 411     inline storeError createInMemory (
 412         sal_uInt16 nPageSize = STORE_DEFAULT_PAGESIZE)
 413     {
 414         if (m_hImpl)
 415         {
 416             (void) store_releaseHandle (m_hImpl);
 417             m_hImpl = 0;
 418         }
 419         return store_createMemoryFile (nPageSize, &m_hImpl);
 420     }
 421
 422     /** Close the file.
 423         @see store_closeFile()
 424      */
 425     inline void close()
 426     {
 427         if (m_hImpl)
 428         {
 429             (void) store_closeFile (m_hImpl);
 430             m_hImpl = 0;
 431         }
 432     }
 433
 434     /** Flush the file.
 435         @see store_flushFile()
 436      */
 437     inline storeError flush() const
 438     {
 439         if (!m_hImpl)
 440             return store_E_InvalidHandle;
 441
 442         return store_flushFile (m_hImpl);
 443     }
 444
 445     /** Get the number of referers to the file.
 446         @see store_getFileRefererCount()
 447      */
 448     inline storeError getRefererCount (sal_uInt32 & rnRefCount) const
 449     {
 450         if (!m_hImpl)
 451             return store_E_InvalidHandle;
 452
 453         return store_getFileRefererCount (m_hImpl, &rnRefCount);
 454     }
 455
 456     /** Get the file size.
 457         @see store_getFileSize()
 458      */
 459     inline storeError getSize (sal_uInt32 & rnSize) const
 460     {
 461         if (!m_hImpl)
 462             return store_E_InvalidHandle;
 463
 464         return store_getFileSize (m_hImpl, &rnSize);
 465     }
 466
 467     /** Set attributes of a file entry.
 468         @see store_attrib()
 469      */
 470     inline storeError attrib (
 471         rtl::OUString const & rPath,
 472         rtl::OUString const & rName,
 473         sal_uInt32            nMask1,
 474         sal_uInt32            nMask2,
 475         sal_uInt32          & rnAttrib)
 476     {
 477         if (!m_hImpl)
 478             return store_E_InvalidHandle;
 479
 480         return store_attrib (m_hImpl, rPath.pData, rName.pData, nMask1, nMask2, &rnAttrib);
 481     }
 482
 483     /** Set attributes of a file entry.
 484         @see store_attrib()
 485      */
 486     inline storeError attrib (
 487         rtl::OUString const & rPath,
 488         rtl::OUString const & rName,
 489         sal_uInt32            nMask1,
 490         sal_uInt32            nMask2)
 491     {
 492         if (!m_hImpl)
 493             return store_E_InvalidHandle;
 494
 495         return store_attrib (m_hImpl, rPath.pData, rName.pData, nMask1, nMask2, NULL);
 496     }
 497
 498     /** Insert a file entry as 'hard link' to another file entry.
 499         @see store_link()
 500      */
 501     inline storeError link (
 502         rtl::OUString const & rSrcPath, rtl::OUString const & rSrcName,
 503         rtl::OUString const & rDstPath, rtl::OUString const & rDstName)
 504     {
 505         if (!m_hImpl)
 506             return store_E_InvalidHandle;
 507
 508         return store_link (
 509             m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 510     }
 511
 512     /** Insert a file entry as 'symbolic link' to another file entry.
 513         @see store_symlink()
 514      */
 515     inline storeError symlink (
 516         rtl::OUString const & rSrcPath, rtl::OUString const & rSrcName,
 517         rtl::OUString const & rDstPath, rtl::OUString const & rDstName)
 518     {
 519         if (!m_hImpl)
 520             return store_E_InvalidHandle;
 521
 522         return store_symlink (m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 523     }
 524
 525     /** Rename a file entry.
 526         @see store_rename()
 527      */
 528     inline storeError rename (
 529         rtl::OUString const & rSrcPath, rtl::OUString const & rSrcName,
 530         rtl::OUString const & rDstPath, rtl::OUString const & rDstName)
 531     {
 532         if (!m_hImpl)
 533             return store_E_InvalidHandle;
 534
 535         return store_rename (m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 536     }
 537
 538     /** Remove a file entry.
 539         @see store_remove()
 540      */
 541     inline storeError remove (
 542         rtl::OUString const & rPath, rtl::OUString const & rName)
 543     {
 544         if (!m_hImpl)
 545             return store_E_InvalidHandle;
 546
 547         return store_remove (m_hImpl, rPath.pData, rName.pData);
 548     }
 549
 550 private:
 551     /** Representation.
 552      */
 553     storeFileHandle m_hImpl;
 554 };
 555
 556 /*========================================================================
 557  *
 558  * The End.
 559  *
 560  *======================================================================*/
 561
 562 } // namespace store
 563
 564 #endif /* ! INCLUDED_STORE_STORE_HXX */
 565
 566
 567
 568
 569 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */