Eneboo - Documentación para desarrolladores
src/flbase/aqsobjects/AQSByteArray_p.h
Ir a la documentación de este archivo.
00001 /***************************************************************************
00002  AQSByteArray_p.h
00003  -------------------
00004  begin                : 24/02/2011
00005  copyright            : (C) 2003-2011 by InfoSiAL S.L.
00006  email                : mail@infosial.com
00007  ***************************************************************************/
00008 /***************************************************************************
00009  *   This program is free software; you can redistribute it and/or modify  *
00010  *   it under the terms of the GNU General Public License as published by  *
00011  *   the Free Software Foundation; version 2 of the License.               *
00012  ***************************************************************************/
00013 /***************************************************************************
00014  Este  programa es software libre. Puede redistribuirlo y/o modificarlo
00015  bajo  los  trminos  de  la  Licencia  Pblica General de GNU   en  su
00016  versin 2, publicada  por  la  Free  Software Foundation.
00017  ***************************************************************************/
00018 
00019 #ifndef AQSBYTEARRAY_P_H_
00020 #define AQSBYTEARRAY_P_H_
00021 
00022 #include "AQSAbstractMemArray_p.h"
00023 #include <qcstring.h>
00024 
00025 // @AQ_PTR_INDIRECTION@
00026 
00027 class AQSByteArray : public AQSAbstractMemArray
00028 {
00029   Q_OBJECT
00030 
00031   Q_PROPERTY(QString string READ string WRITE setString);
00032   Q_PROPERTY(QByteArray toVariant READ toVariant);
00033 
00034   AQ_DECLARE_AQS_VOID(ByteArray, AbstractMemArray);
00035 
00036 public:
00037   QByteArray toVariant() const {
00038     if (!o_)
00039       return QByteArray();
00040     return *o_;
00041   }
00042 
00043   virtual void setter(uint index, const QVariant &v) {
00044     if (!o_)
00045       return;
00046     (*o_)[index] = (char)v.toInt();
00047   }
00048   virtual QVariant getter(uint index) const {
00049     if (!o_)
00050       return 0;
00051     return (*o_)[index];
00052   }
00053 
00054 protected:
00055   void specializedInternalFinish() {
00056     if (!wrap_)
00057       delete o_;
00058   }
00059 
00060 public slots:
00061   QByteArray toHex() const {
00062     if (!o_)
00063       return QByteArray();
00064     return byteArrayToHex(o_);
00065   }
00066 
00067   QByteArray fromHex() const {
00068     if (!o_)
00069       return QByteArray();
00070     return byteArrayFromHex(o_);
00071   }
00072 
00073   QByteArray toBase64() const {
00074     if (!o_)
00075       return QByteArray();
00076     return byteArrayToBase64(o_);
00077   }
00078 
00079   QByteArray fromBase64() const {
00080     if (!o_)
00081       return QByteArray();
00082     return byteArrayFromBase64(o_);
00083   }
00084 
00085   QByteArray compress() const {
00086     if (!o_)
00087       return QByteArray();
00088     return qCompress(*o_);
00089   }
00090 
00091   QByteArray uncompress() const {
00092     if (!o_)
00093       return QByteArray();
00094     return qUncompress(*o_);
00095   }
00096 
00097   QByteArray encryptInternal() const {
00098     if (!o_)
00099       return QByteArray();
00100     return globalAQS->encryptInternal(o_);
00101   }
00102 
00103   QByteArray decryptInternal() const {
00104     if (!o_)
00105       return QByteArray();
00106     return globalAQS->decryptInternal(o_);
00107   }
00108 
00109   QString sha1() const {
00110     if (!o_)
00111       return QByteArray();
00112     return globalAQS->sha1(o_);
00113   }
00114 
00115   int rand() {
00116     if (!o_)
00117       return 0;
00118     return rand_bytes(o_);
00119   }
00120 
00121   int rand_pseudo() {
00122     if (!o_)
00123       return 0;
00124     return rand_pseudo_bytes(o_);
00125   }
00126 
00127   QByteArray aes256Encrypt(const QByteArray &key,
00128                            const QByteArray &iv) {
00129     if (!o_)
00130       return QByteArray();
00131     return aes_256_encrypt(o_, key, iv);
00132   }
00133 
00134   QByteArray aes256Decrypt(const QByteArray &key,
00135                            const QByteArray &iv) {
00136     if (!o_)
00137       return QByteArray();
00138     return aes_256_decrypt(o_, key, iv);
00139   }
00140 
00141   void setString(const QString &str) {
00142     if (!o_)
00143       return;
00144     QTextStream ts(*o_, IO_WriteOnly);
00145     ts << str;
00146   }
00147 
00148   QString string() const {
00149     if (!o_)
00150       return QString::null;
00151     return QString(*o_);
00152   }
00153 
00154   //@AQ_BEGIN_DEF_PUB_SLOTS@
00155 public slots:
00156   QVariant at(uint) const;
00157   uint nrefs() const;
00158   uint size() const;
00159   uint count() const;
00160   bool isEmpty() const;
00161   bool isNull() const;
00162   bool resize(uint);
00163   bool truncate(uint);
00164   bool fill(char, int = -1);
00165   QByteArray assign(QByteArray *);
00166   QByteArray assign(AQSByteArray *);
00167   QByteArray duplicate(QByteArray *);
00168   QByteArray duplicate(AQSByteArray *);
00169   int find(char, uint = 0) const;
00170   int contains(char) const;
00171   void sort();
00172   int bsearch(char) const;
00173   virtual void detach();
00174   QByteArray copy() const;
00175 
00176 protected:
00177   static void *construct(const QSArgumentList &args) {
00178     QMap<int, QStringList> candidates;
00179     candidates[0].append(QString::null);
00180     candidates[1].append(QString::fromLatin1("int"));
00181     candidates[1].append(QString::fromLatin1("QByteArray*"));
00182     QString sgt(castArgsSignature(args, candidates));
00183     if (sgt.isEmpty())
00184       return new QByteArray;
00185     if (sgt == QString::fromLatin1("int"))
00186       return new QByteArray(args[0].variant().toInt());
00187     if (sgt == QString::fromLatin1("QByteArray*"))
00188       return new QByteArray(*argValue<QByteArray *>(args[0]));
00189     return 0;
00190   }
00191 
00192 public:
00193   static QMap<int, QStringList> candidateConstructors() {
00194     QMap<int, QStringList> candidates;
00195     candidates[0].append(QString::null);
00196     candidates[1].append(QString::fromLatin1("int"));
00197     candidates[1].append(QString::fromLatin1("QByteArray*"));
00198     return candidates;
00199   }
00200   //@AQ_END_DEF_PUB_SLOTS@
00201 };
00202 
00203 //@AQ_BEGIN_IMP_PUB_SLOTS@
00204 inline QVariant AQSByteArray::at(uint arg0) const
00205 {
00206   AQ_CALL_RET_V(at(arg0), QVariant);
00207 }
00208 inline uint AQSByteArray::nrefs() const
00209 {
00210   AQ_CALL_RET_V(nrefs(), uint);
00211 }
00212 inline uint AQSByteArray::size() const
00213 {
00214   AQ_CALL_RET_V(size(), uint);
00215 }
00216 inline uint AQSByteArray::count() const
00217 {
00218   AQ_CALL_RET_V(count(), uint);
00219 }
00220 inline bool AQSByteArray::isEmpty() const
00221 {
00222   AQ_CALL_RET_V(isEmpty(), bool);
00223 }
00224 inline bool AQSByteArray::isNull() const
00225 {
00226   AQ_CALL_RET_V(isNull(), bool);
00227 }
00228 inline bool AQSByteArray::resize(uint arg0)
00229 {
00230   AQ_CALL_RET_V(resize(arg0), bool);
00231 }
00232 inline bool AQSByteArray::truncate(uint arg0)
00233 {
00234   AQ_CALL_RET_V(truncate(arg0), bool);
00235 }
00236 inline bool AQSByteArray::fill(char arg0,  int arg1)
00237 {
00238   AQ_CALL_RET_V(fill(arg0, arg1), bool);
00239 }
00240 inline QByteArray AQSByteArray::assign(QByteArray *arg0)
00241 {
00242   AQ_CALL_RET_V(assign(*arg0), QByteArray);
00243 }
00244 inline QByteArray AQSByteArray::assign(AQSByteArray *arg0)
00245 {
00246   AQ_CALL_RET_V(assign(*arg0), QByteArray);
00247 }
00248 inline QByteArray AQSByteArray::duplicate(QByteArray *arg0)
00249 {
00250   AQ_CALL_RET_V(duplicate(*arg0), QByteArray);
00251 }
00252 inline QByteArray AQSByteArray::duplicate(AQSByteArray *arg0)
00253 {
00254   AQ_CALL_RET_V(duplicate(*arg0), QByteArray);
00255 }
00256 inline int AQSByteArray::find(char arg0,  uint arg1) const
00257 {
00258   AQ_CALL_RET_V(find(arg0, arg1), int);
00259 }
00260 inline int AQSByteArray::contains(char arg0) const
00261 {
00262   AQ_CALL_RET_V(contains(arg0), int);
00263 }
00264 inline void AQSByteArray::sort()
00265 {
00266   AQ_CALL_VOID(sort());
00267 }
00268 inline int AQSByteArray::bsearch(char arg0) const
00269 {
00270   AQ_CALL_RET_V(bsearch(arg0), int);
00271 }
00272 inline void AQSByteArray::detach()
00273 {
00274   AQ_CALL_VOID(detach());
00275 }
00276 inline QByteArray AQSByteArray::copy() const
00277 {
00278   AQ_CALL_RET_V(copy(), QByteArray);
00279 }
00280 //@AQ_END_IMP_PUB_SLOTS@
00281 
00282 #endif /* AQSBYTEARRAY_P_H_ */
00283 // @AQSVOIDPTR@
 Todo Clases Namespaces Archivos Funciones Variables 'typedefs' Enumeraciones Valores de enumeraciones Propiedades Amigas 'defines'