trapper: trappervector.h Source File

00001 /*******************************************************************************
00002  *                                                                             *
00003  *   Copyright (C) 2003  Erik Sjolund,  (<html>Erik Sj&ouml;lund</html>)       *
00004  *                       Center for Genomics and Bioinformatics,               *
00005  *                       Karolinska Institutet,                                *
00006  *                       Stockholm,                                            *
00007  *                       Sweden                                                *
00008  *                                                                             *
00009  *  Author: Erik Sjolund                                                       *
00010  *  Email: erik.sjolund@adivo.se                                               *
00011  *                                                                             *
00012  *******************************************************************************
00013  */
00014 
00015 #ifndef TRAPPERVECTOR_H
00016 #define TRAPPERVECTOR_H
00017 
00018 #include <qcstring.h>
00019 #include <qvaluelist.h>
00020 #include <qdom.h>
00021 #include <qxml.h>
00022 
00023 #include <vector>
00024 
00025 #include <iostream>
00026 using namespace std;
00027 
00028 
00029 class QDataStream;
00030 class QString;
00031 
00032 /** \brief To store an array of values. It's a template class to be used in the serializing bytearray and import/export to dom tree 
00033  *
00034  */
00035 
00036 
00037 
00038 
00039 template <class T>
00040 class TrapperVector
00041 {
00042 public:
00043   TrapperVector()
00044   {
00045   }
00046   ~TrapperVector()
00047   { }
00048   typedef QValueList< T > QualityList;
00049   vector<T> & stlVector()
00050   {
00051     return v;
00052   }
00053   
00054   void readDom( QDomElement & elem )
00055   {
00056     v.clear();
00057     
00058     QDomNode node = elem.firstChild();
00059     while ( !node.isNull() )
00060       {
00061         if ( node.isElement() && node.nodeName() == "trappervector" &&
00062              node.toElement().attribute("type") == name_of_type() )
00063           {
00064             QDomNode node2 = node.firstChild();
00065             while ( !node2.isNull() )
00066               {
00067                 if ( node2.isElement() && node2.nodeName() == "member" )
00068                   {
00069                     QDomElement elem2 = node2.toElement();
00070                     //                        QString name = name_of_type();
00071                     Q_ASSERT( elem2.hasAttribute( "value" ) );
00072                     QString valueStr = elem2.attribute( "value" );
00073                     T t = convertToTemplateType( valueStr );
00074                     v.push_back(t);
00075                   }
00076                 node2 = node2.nextSibling();
00077               }
00078             break;
00079           }
00080         node = node.nextSibling();
00081       }
00082   }
00083 
00084   void readAttributes(const QXmlAttributes& attr)
00085   {
00086     
00087     QString str = attr.value("trappervector");
00088     
00089     readString(str);
00090     
00091   }
00092 
00093   void readString(QString& str)
00094   {
00095     v.clear();
00096 
00097     QTextStream stream(&str, IO_ReadOnly);
00098     
00099     while ( !stream.atEnd() ) {
00100       T tmp;
00101       stream>>tmp;
00102       v.push_back(tmp);
00103     }
00104     
00105   }
00106   
00107   T convertToTemplateType( QString valueStr )
00108   {
00109     T t = valueStr;
00110     return t;
00111   }
00112   QString convertToString( T value )
00113   {
00114     QString s = value;
00115     return s;
00116   }
00117   
00118   void writeDom( QDomElement & elem )
00119   {
00120     QDomDocument doc = elem.ownerDocument();
00121     QDomElement array = doc.createElement("trappervector");
00122     array.setAttribute("type",name_of_type());
00123     elem.appendChild( array );
00124     typename vector<T>::iterator it;
00125     
00126     for ( it = v.begin(); it != v.end(); ++it )
00127       {
00128         QDomElement member = doc.createElement("member");
00129         array.appendChild( member );
00130         QString str = convertToString( *it );
00131             member.setAttribute( "value" , str );
00132       }
00133   }
00134   const char * data()
00135     {
00136         if (v.empty())
00137         {
00138             return NULL;
00139         }
00140         else
00141         {
00142             return ( char * ) &v[0];
00143         }
00144     }
00145     const uint size()
00146     {
00147         return (uint) ( v.size() * sizeof( T ));
00148     }
00149     void resize( Q_UINT32 & len )
00150     {
00151         v.resize( (size_t) (len / sizeof( T ))) ;
00152     }
00153 protected:
00154     vector<T> v;
00155     QString name_of_type()
00156     {
00157         //  return standardMemberName;
00158         return QString("unknownType");
00159     }
00160 };
00161 template<>
00162 inline QString TrapperVector<Q_UINT32>::name_of_type()
00163 {
00164     return QString("uint32");
00165 }
00166 template<>
00167 inline QString TrapperVector<char>::name_of_type()
00168 {
00169     return QString("char");
00170 }
00171 
00172 template<>
00173 inline Q_UINT32 TrapperVector<Q_UINT32>::convertToTemplateType( QString valueStr )
00174 {
00175     Q_UINT32 t = valueStr.toUInt();
00176     return t;
00177 }
00178 
00179 template<>
00180 inline char TrapperVector<char>::convertToTemplateType( QString valueStr )
00181 {
00182     QChar qc = valueStr.at(0);
00183     char t = qc.latin1();
00184     return t;
00185 }
00186 
00187 template<>
00188 inline QString TrapperVector<char>::convertToString( char value )
00189 {
00190     QChar c(value);
00191     QString s(c);
00192     return s;
00193 }
00194 
00195 template<>
00196 inline QString TrapperVector<Q_UINT32>::convertToString( Q_UINT32 value )
00197 {
00198     QString s;
00199     s.setNum( value );
00200     return s;
00201 }
00202 
00203 
00204     /** Todo: But a problem with this approach might be that the endian awareness of QDataStream might be lost, when we don't serialize the
00205         types one by one. It might be a problem when moving berkeley dbs around archictures. But berkeley db probably doesn't allow this anyway? */
00206 
00207 
00208 template <class T>
00209 QDataStream & operator<< ( QDataStream & stream, TrapperVector<T> & t )
00210 {
00211   if ( t.size() > 0 ) {
00212     
00213     
00214     
00215     const char * dataPtr =  t.data() ;
00216     
00217 #if defined(QT_DEBUG)
00218     
00219     if ( t.size() != 0 ) {
00220       Q_CHECK_PTR( dataPtr );
00221     }
00222     int a = t.size();
00223     qDebug("stream.writeBytes , t.size()=%d",a);
00224 #endif
00225     
00226     stream.writeBytes( dataPtr, t.size() );
00227   }
00228   else {
00229     stream<<0;
00230   }
00231   
00232 
00233   return stream;
00234 }
00235 
00236 
00237     /** Todo: But a problem with this approach might be that the endian awareness of QDataStream might be lost, when we don't serialize the
00238         types one by one. It might be a problem when moving berkeley dbs around archictures. But berkeley db probably doesn't allow this anyway?*/
00239 
00240 
00241 template <class T>
00242 QDataStream & operator>> ( QDataStream & stream, TrapperVector<T> & t )
00243 {
00244     Q_UINT32 len;
00245     stream >> len;
00246 
00247     if ( len > 0 ) {
00248       t.resize( len );
00249       char * dataPtr =  const_cast< char * >( t.data() );
00250       Q_CHECK_PTR( dataPtr );
00251       if ( !dataPtr ) {
00252         cerr<<"len: "<<len<<endl;
00253       }
00254       
00255       
00256 #if defined(QT_DEBUG)
00257       // wrapping macro around should not be a must ... fix this
00258       qDebug("stream.readRawBytes, len=%d",len);
00259 #endif
00260       //     if ( dataPtr ) {
00261       stream.readRawBytes( dataPtr, len );
00262       //     }
00263     }
00264     
00265     return stream;
00266 }
00267 
00268 #endif