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 (void) SAL_THROW(())
  41         : m_hImpl (0)
  42     {}
  43
  44     /** Destruction.
  45      */
  46     inline ~OStoreStream (void) SAL_THROW(())
  47     {
  48         if (m_hImpl)
  49             (void) store_releaseHandle (m_hImpl);
  50     }
  51
  52     /** Copy construction.
  53      */
  54     inline OStoreStream (OStoreStream const & rhs) SAL_THROW(())
  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) SAL_THROW(())
  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) SAL_THROW(())
  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 (void) const SAL_THROW(())
  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 (void) const SAL_THROW(())
  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         OUString const & rPath,
 103         OUString const & rName,
 104         storeAccessMode       eMode) SAL_THROW(())
 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 (void) SAL_THROW(())
 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) SAL_THROW(())
 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) SAL_THROW(())
 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 (void) const SAL_THROW(())
 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 SAL_THROW(())
 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) SAL_THROW(())
 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 (void) SAL_THROW(())
 206         : m_hImpl (0)
 207     {}
 208
 209     /** Destruction.
 210      */
 211     inline ~OStoreDirectory (void) SAL_THROW(())
 212     {
 213         if (m_hImpl)
 214             (void) store_releaseHandle (m_hImpl);
 215     }
 216
 217     /** Copy construction.
 218      */
 219     inline OStoreDirectory (OStoreDirectory const & rhs) SAL_THROW(())
 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) SAL_THROW(())
 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) SAL_THROW(())
 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(void) const SAL_THROW(())
 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 (void) const SAL_THROW(())
 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         OUString const & rPath,
 268         OUString const & rName,
 269         storeAccessMode       eMode) SAL_THROW(())
 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 (void) SAL_THROW(())
 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) SAL_THROW(())
 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) SAL_THROW(())
 312     {
 313         if (!m_hImpl)
 314             return store_E_InvalidHandle;
 315
 316         return store_findNext (m_hImpl, &it);
 317     }
 318
 319     /** Directory traversal helper.
 320         @see travel()
 321      */
 322     class traveller
 323     {
 324     public:
 325         /** Directory traversal callback.
 326             @param  it [in] current directory entry.
 327             @return sal_True to continue iteration, sal_False to stop.
 328          */
 329         virtual sal_Bool visit (const iterator& it) = 0;
 330
 331     protected:
 332         ~traveller() {}
 333     };
 334
 335     /** Directory traversal.
 336         @see store_findFirst()
 337         @see store_findNext()
 338
 339         @param  rTraveller [in] the traversal callback.
 340         @return store_E_NoMoreFiles upon end of iteration.
 341      */
 342     inline storeError travel (traveller & rTraveller) const
 343     {
 344         storeError eErrCode = store_E_InvalidHandle;
 345         if (m_hImpl)
 346         {
 347             iterator it;
 348             eErrCode = store_findFirst (m_hImpl, &it);
 349             while ((eErrCode == store_E_None) && rTraveller.visit(it))
 350                 eErrCode = store_findNext (m_hImpl, &it);
 351         }
 352         return eErrCode;
 353     }
 354
 355 private:
 356     /** Representation.
 357      */
 358     storeDirectoryHandle m_hImpl;
 359 };
 360
 361 /*========================================================================
 362  *
 363  * OStoreFile interface.
 364  *
 365  *======================================================================*/
 366 class OStoreFile
 367 {
 368 public:
 369     /** Construction.
 370      */
 371     inline OStoreFile (void) SAL_THROW(())
 372         : m_hImpl (0)
 373     {}
 374
 375     /** Destruction.
 376      */
 377     inline ~OStoreFile (void) SAL_THROW(())
 378     {
 379         if (m_hImpl)
 380             (void) store_releaseHandle (m_hImpl);
 381     }
 382
 383     /** Copy construction.
 384      */
 385     inline OStoreFile (OStoreFile const & rhs) SAL_THROW(())
 386         : m_hImpl (rhs.m_hImpl)
 387     {
 388         if (m_hImpl)
 389             (void) store_acquireHandle (m_hImpl);
 390     }
 391
 392     /** Assignment.
 393      */
 394     inline OStoreFile & operator= (OStoreFile const & rhs) SAL_THROW(())
 395     {
 396         if (rhs.m_hImpl)
 397             (void) store_acquireHandle (rhs.m_hImpl);
 398         if (m_hImpl)
 399             (void) store_releaseHandle (m_hImpl);
 400         m_hImpl = rhs.m_hImpl;
 401         return *this;
 402     }
 403
 404     /** Construction from File Handle.
 405      */
 406     inline explicit OStoreFile (storeFileHandle Handle) SAL_THROW(())
 407         : m_hImpl (Handle)
 408     {
 409         if (m_hImpl)
 410             (void) store_acquireHandle (m_hImpl);
 411     }
 412
 413     /** Conversion into File Handle.
 414      */
 415     inline operator storeFileHandle (void) const SAL_THROW(())
 416     {
 417         return m_hImpl;
 418     }
 419
 420     /** Check for a valid File Handle.
 421         @return sal_True if valid, sal_False otherwise.
 422      */
 423     inline bool isValid (void) const SAL_THROW(())
 424     {
 425         return (m_hImpl != 0);
 426     }
 427
 428     /** Open the file.
 429         @see store_openFile()
 430      */
 431     inline storeError create (
 432         OUString const & rFilename,
 433         storeAccessMode       eAccessMode,
 434         sal_uInt16            nPageSize = STORE_DEFAULT_PAGESIZE) SAL_THROW(())
 435     {
 436         if (m_hImpl)
 437         {
 438             (void) store_releaseHandle (m_hImpl);
 439             m_hImpl = 0;
 440         }
 441         return store_openFile (rFilename.pData, eAccessMode, nPageSize, &m_hImpl);
 442     }
 443
 444     /** Open the temporary file in memory.
 445         @see store_createMemoryFile()
 446      */
 447     inline storeError createInMemory (
 448         sal_uInt16 nPageSize = STORE_DEFAULT_PAGESIZE) SAL_THROW(())
 449     {
 450         if (m_hImpl)
 451         {
 452             (void) store_releaseHandle (m_hImpl);
 453             m_hImpl = 0;
 454         }
 455         return store_createMemoryFile (nPageSize, &m_hImpl);
 456     }
 457
 458     /** Close the file.
 459         @see store_closeFile()
 460      */
 461     inline void close (void) SAL_THROW(())
 462     {
 463         if (m_hImpl)
 464         {
 465             (void) store_closeFile (m_hImpl);
 466             m_hImpl = 0;
 467         }
 468     }
 469
 470     /** Flush the file.
 471         @see store_flushFile()
 472      */
 473     inline storeError flush (void) const SAL_THROW(())
 474     {
 475         if (!m_hImpl)
 476             return store_E_InvalidHandle;
 477
 478         return store_flushFile (m_hImpl);
 479     }
 480
 481     /** Get the number of referers to the file.
 482         @see store_getFileRefererCount()
 483      */
 484     inline storeError getRefererCount (sal_uInt32 & rnRefCount) const SAL_THROW(())
 485     {
 486         if (!m_hImpl)
 487             return store_E_InvalidHandle;
 488
 489         return store_getFileRefererCount (m_hImpl, &rnRefCount);
 490     }
 491
 492     /** Get the file size.
 493         @see store_getFileSize()
 494      */
 495     inline storeError getSize (sal_uInt32 & rnSize) const SAL_THROW(())
 496     {
 497         if (!m_hImpl)
 498             return store_E_InvalidHandle;
 499
 500         return store_getFileSize (m_hImpl, &rnSize);
 501     }
 502
 503     /** Set attributes of a file entry.
 504         @see store_attrib()
 505      */
 506     inline storeError attrib (
 507         OUString const & rPath,
 508         OUString const & rName,
 509         sal_uInt32            nMask1,
 510         sal_uInt32            nMask2,
 511         sal_uInt32          & rnAttrib) SAL_THROW(())
 512     {
 513         if (!m_hImpl)
 514             return store_E_InvalidHandle;
 515
 516         return store_attrib (m_hImpl, rPath.pData, rName.pData, nMask1, nMask2, &rnAttrib);
 517     }
 518
 519     /** Set attributes of a file entry.
 520         @see store_attrib()
 521      */
 522     inline storeError attrib (
 523         OUString const & rPath,
 524         OUString const & rName,
 525         sal_uInt32            nMask1,
 526         sal_uInt32            nMask2) SAL_THROW(())
 527     {
 528         if (!m_hImpl)
 529             return store_E_InvalidHandle;
 530
 531         return store_attrib (m_hImpl, rPath.pData, rName.pData, nMask1, nMask2, NULL);
 532     }
 533
 534     /** Insert a file entry as 'hard link' to another file entry.
 535         @see store_link()
 536      */
 537     inline storeError link (
 538         OUString const & rSrcPath, OUString const & rSrcName,
 539         OUString const & rDstPath, OUString const & rDstName) SAL_THROW(())
 540     {
 541         if (!m_hImpl)
 542             return store_E_InvalidHandle;
 543
 544         return store_link (
 545             m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 546     }
 547
 548     /** Insert a file entry as 'symbolic link' to another file entry.
 549         @see store_symlink()
 550      */
 551     inline storeError symlink (
 552         OUString const & rSrcPath, OUString const & rSrcName,
 553         OUString const & rDstPath, OUString const & rDstName) SAL_THROW(())
 554     {
 555         if (!m_hImpl)
 556             return store_E_InvalidHandle;
 557
 558         return store_symlink (m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 559     }
 560
 561     /** Rename a file entry.
 562         @see store_rename()
 563      */
 564     inline storeError rename (
 565         OUString const & rSrcPath, OUString const & rSrcName,
 566         OUString const & rDstPath, OUString const & rDstName) SAL_THROW(())
 567     {
 568         if (!m_hImpl)
 569             return store_E_InvalidHandle;
 570
 571         return store_rename (m_hImpl, rSrcPath.pData, rSrcName.pData, rDstPath.pData, rDstName.pData);
 572     }
 573
 574     /** Remove a file entry.
 575         @see store_remove()
 576      */
 577     inline storeError remove (
 578         OUString const & rPath, OUString const & rName) SAL_THROW(())
 579     {
 580         if (!m_hImpl)
 581             return store_E_InvalidHandle;
 582
 583         return store_remove (m_hImpl, rPath.pData, rName.pData);
 584     }
 585
 586 private:
 587     /** Representation.
 588      */
 589     storeFileHandle m_hImpl;
 590 };
 591
 592 /*========================================================================
 593  *
 594  * The End.
 595  *
 596  *======================================================================*/
 597
 598 } // namespace store
 599
 600 #endif /* ! INCLUDED_STORE_STORE_HXX */
 601
 602
 603
 604
 605 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */