• Skip to content
  • Skip to link menu
KDE 4.0 API Reference
  • KDE API Reference
  • KDE-PIM Libraries
  • Sitemap
  • Contact Us
 

qgpgme

dataprovider.cpp

00001 /* dataprovider.cpp
00002    Copyright (C) 2004 Klar�vdalens Datakonsult AB
00003 
00004    This file is part of QGPGME.
00005 
00006    QGPGME is free software; you can redistribute it and/or modify it
00007    under the terms of the GNU Library General Public License as published
00008    by the Free Software Foundation; either version 2 of the License, or
00009    (at your option) any later version.
00010 
00011    QGPGME is distributed in the hope that it will be useful, but
00012    WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU Library General Public License for more details.
00015 
00016    You should have received a copy of the GNU Library General Public License
00017    along with QGPGME; see the file COPYING.LIB.  If not, write to the
00018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00019    Boston, MA 02110-1301, USA. */
00020 
00021 // -*- c++ -*-
00022 
00023 #include <qgpgme/dataprovider.h>
00024 
00025 #include <stdio.h>
00026 #include <string.h>
00027 #include <errno.h>
00028 #include <assert.h>
00029 
00030 using namespace QGpgME;
00031 
00032 //
00033 //
00034 // QByteArrayDataProvider
00035 //
00036 //
00037 
00038 static bool resizeAndInit( QByteArray & ba, size_t newSize ) {
00039   const size_t oldSize = ba.size();
00040   ba.resize( newSize );
00041   const bool ok = ( newSize == static_cast<size_t>( ba.size() ) );
00042   if ( ok )
00043     memset( ba.data() + oldSize, 0, newSize - oldSize );
00044   return ok;
00045 }
00046 
00047 QByteArrayDataProvider::QByteArrayDataProvider()
00048   : GpgME::DataProvider(), mOff( 0 ) {}
00049 
00050 QByteArrayDataProvider::QByteArrayDataProvider( const QByteArray & initialData )
00051   : GpgME::DataProvider(), mArray( initialData ), mOff( 0 ) {}
00052 
00053 QByteArrayDataProvider::~QByteArrayDataProvider() {}
00054 
00055 ssize_t QByteArrayDataProvider::read( void * buffer, size_t bufSize ) {
00056 #ifndef NDEBUG
00057   //qDebug( "QByteArrayDataProvider::read( %p, %d )", buffer, bufSize );
00058 #endif
00059   if ( bufSize == 0 )
00060     return 0;
00061   if ( !buffer ) {
00062     errno = EINVAL;
00063     return -1;
00064   }
00065   if ( mOff >= mArray.size() )
00066     return 0; // EOF
00067   size_t amount = qMin( bufSize, static_cast<size_t>( mArray.size() - mOff ) );
00068   assert( amount > 0 );
00069   memcpy( buffer, mArray.data() + mOff, amount );
00070   mOff += amount;
00071   return amount;
00072 }
00073 
00074 ssize_t QByteArrayDataProvider::write( const void * buffer, size_t bufSize ) {
00075 #ifndef NDEBUG
00076     qDebug( "QByteArrayDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );
00077 #endif
00078   if ( bufSize == 0 )
00079     return 0;
00080   if ( !buffer ) {
00081     errno = EINVAL;
00082     return -1;
00083   }
00084   if ( mOff >= mArray.size() )
00085     resizeAndInit( mArray, mOff + bufSize );
00086   if ( mOff >= mArray.size() ) {
00087     errno = EIO;
00088     return -1;
00089   }
00090   assert( bufSize <= static_cast<size_t>(mArray.size()) - mOff );
00091   memcpy( mArray.data() + mOff, buffer, bufSize );
00092   mOff += bufSize;
00093   return bufSize;
00094 }
00095 
00096 off_t QByteArrayDataProvider::seek( off_t offset, int whence ) {
00097 #ifndef NDEBUG
00098   qDebug( "QByteArrayDataProvider::seek( %d, %d )", int(offset), whence );
00099 #endif
00100   int newOffset = mOff;
00101   switch ( whence ) {
00102   case SEEK_SET:
00103     newOffset = offset;
00104     break;
00105   case SEEK_CUR:
00106     newOffset += offset;
00107     break;
00108   case SEEK_END:
00109     newOffset = mArray.size() + offset;
00110     break;
00111   default:
00112     errno = EINVAL;
00113     return (off_t)-1;
00114   }
00115   return mOff = newOffset;
00116 }
00117 
00118 void QByteArrayDataProvider::release() {
00119 #ifndef NDEBUG
00120   qDebug( "QByteArrayDataProvider::release()" );
00121 #endif
00122   mArray = QByteArray();
00123 }
00124 
00125 
00126 //
00127 //
00128 // QIODeviceDataProvider
00129 //
00130 //
00131 
00132 QIODeviceDataProvider::QIODeviceDataProvider( QIODevice * io )
00133   : GpgME::DataProvider(),
00134     mIO( io ), mOwnsDevice( false )
00135 {
00136   assert( mIO );
00137 }
00138 
00139 QIODeviceDataProvider::~QIODeviceDataProvider() {
00140   if ( mOwnsDevice )
00141     delete mIO;
00142 }
00143 
00144 void QIODeviceDataProvider::setOwnsDevice( bool ownz ) {
00145   mOwnsDevice = ownz;
00146 }
00147 
00148 bool QIODeviceDataProvider::ownsDevice() const {
00149   return mOwnsDevice;
00150 }
00151 
00152 bool QIODeviceDataProvider::isSupported( Operation op ) const {
00153     switch ( op ) {
00154     case Read:    return mIO->isReadable();
00155     case Write:   return mIO->isWritable();
00156     case Seek:    return !mIO->isSequential();
00157     case Release: return true;
00158     default:      return false;
00159     }
00160 }
00161 
00162 ssize_t QIODeviceDataProvider::read( void * buffer, size_t bufSize ) {
00163 #ifndef NDEBUG
00164   //qDebug( "QIODeviceDataProvider::read( %p, %d )", buffer, bufSize );
00165 #endif
00166   if ( bufSize == 0 )
00167     return 0;
00168   if ( !buffer ) {
00169     errno = EINVAL;
00170     return -1;
00171   }
00172   return mIO->read( static_cast<char*>(buffer), bufSize );
00173 }
00174 
00175 ssize_t QIODeviceDataProvider::write( const void * buffer, size_t bufSize ) {
00176 #ifndef NDEBUG
00177   qDebug( "QIODeviceDataProvider::write( %p, %lu )", buffer, static_cast<unsigned long>( bufSize ) );
00178 #endif
00179   if ( bufSize == 0 )
00180     return 0;
00181   if ( !buffer ) {
00182      errno = EINVAL;
00183      return -1;
00184   }
00185   return mIO->write( static_cast<const char*>(buffer), bufSize );
00186 }
00187 
00188 off_t QIODeviceDataProvider::seek( off_t offset, int whence ) {
00189 #ifndef NDEBUG
00190   qDebug( "QIODeviceDataProvider::seek( %d, %d )", int(offset), whence );
00191 #endif
00192   if ( mIO->isSequential() ) {
00193     errno = ESPIPE;
00194     return (off_t)-1;
00195   }
00196   qint64 newOffset = mIO->pos();
00197   switch ( whence ) {
00198   case SEEK_SET:
00199     newOffset = offset;
00200     break;
00201   case SEEK_CUR:
00202     newOffset += offset;
00203     break;
00204   case SEEK_END:
00205     newOffset = mIO->size() + offset;
00206     break;
00207   default:
00208     errno = EINVAL;
00209     return (off_t)-1;
00210   }
00211   if ( !mIO->seek( newOffset ) ) {
00212     errno = EINVAL;
00213     return (off_t)-1;
00214   }
00215   return newOffset;
00216 }
00217 
00218 void QIODeviceDataProvider::release() {
00219 #ifndef NDEBUG
00220   qDebug( "QIODeviceDataProvider::release()" );
00221 #endif
00222   mIO->close();
00223 }

qgpgme

Skip menu "qgpgme"
  • Main Page
  • File List

KDE-PIM Libraries

Skip menu "KDE-PIM Libraries"
  • kabc
  • kblog
  • kcal
  • kimap
  • kioslave
  •   imap4
  •   mbox
  • kldap
  • kmime
  • kpimidentities
  • kpimutils
  • kresources
  • ktnef
  • kxmlrpcclient
  • mailtransport
  • qgpgme
  • syndication
  •   atom
  •   rdf
  •   rss2
Generated for KDE-PIM Libraries by doxygen 1.5.5
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal