ngsview: 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( size_t n ) : v(n)
00047   {
00048   }
00049   ~TrapperVector()
00050   { }
00051   typedef QValueList< T > QualityList;
00052   vector<T> & stlVector()
00053   {
00054     return v;
00055   }
00056   
00057   void readDom( QDomElement & elem )
00058   {
00059     v.clear();
00060     
00061     QDomNode node = elem.firstChild();
00062     while ( !node.isNull() )
00063       {
00064         if ( node.isElement() && node.nodeName() == "trappervector" &&
00065              node.toElement().attribute("type") == name_of_type() )
00066           {
00067             QDomNode node2 = node.firstChild();
00068             while ( !node2.isNull() )
00069               {
00070                 if ( node2.isElement() && node2.nodeName() == "member" )
00071                   {
00072                     QDomElement elem2 = node2.toElement();
00073                     //                        QString name = name_of_type();
00074                     Q_ASSERT( elem2.hasAttribute( "value" ) );
00075                     QString valueStr = elem2.attribute( "value" );
00076                     T t = convertToTemplateType( valueStr );
00077                     v.push_back(t);
00078                   }
00079                 node2 = node2.nextSibling();
00080               }
00081             break;
00082           }
00083         node = node.nextSibling();
00084       }
00085   }
00086 
00087   void readAttributes(const QXmlAttributes& attr)
00088   {
00089     
00090     QString str = attr.value("trappervector");
00091     
00092     readString(str);
00093     
00094   }
00095   
00096   void readString(QString& str)
00097   {
00098     v.clear();
00099     
00100     QTextStream stream(&str, IO_ReadOnly);
00101     
00102     while ( !stream.atEnd() ) {
00103       T tmp;
00104       stream>>tmp;
00105       v.push_back(tmp);
00106     }
00107     
00108   }
00109   
00110   T convertToTemplateType( QString valueStr )
00111   {
00112     T t = valueStr;
00113     return t;
00114   }
00115   QString convertToString( T value )
00116   {
00117     QString s = value;
00118     return s;
00119   }
00120   
00121   void writeDom( QDomElement & elem )
00122   {
00123     QDomDocument doc = elem.ownerDocument();
00124     QDomElement array = doc.createElement("trappervector");
00125     array.setAttribute("type",name_of_type());
00126     elem.appendChild( array );
00127     typename vector<T>::iterator it;
00128     
00129     for ( it = v.begin(); it != v.end(); ++it )
00130       {
00131         QDomElement member = doc.createElement("member");
00132         array.appendChild( member );
00133         QString str = convertToString( *it );
00134             member.setAttribute( "value" , str );
00135       }
00136   }
00137   const char * data()
00138     {
00139         if (v.empty())
00140         {
00141             return NULL;
00142         }
00143         else
00144         {
00145             return ( char * ) &v[0];
00146         }
00147     }
00148     const uint size()
00149     {
00150         return (uint) ( v.size() * sizeof( T ));
00151     }
00152     void resize( Q_UINT32 & len )
00153     {
00154         v.resize( (size_t) (len / sizeof( T ))) ;
00155     }
00156 protected:
00157     vector<T> v;
00158     QString name_of_type()
00159     {
00160         //  return standardMemberName;
00161         return QString("unknownType");
00162     }
00163 };
00164 template<>
00165 inline QString TrapperVector<Q_UINT32>::name_of_type()
00166 {
00167   return QString("uint32");
00168 }
00169 template<>
00170 inline QString TrapperVector<char>::name_of_type()
00171 {
00172   return QString("char");
00173 }
00174 
00175 template<>
00176 inline QString TrapperVector<double>::name_of_type()
00177 {
00178   return QString("double");
00179 }
00180 
00181 template<>
00182 inline Q_UINT32 TrapperVector<Q_UINT32>::convertToTemplateType( QString valueStr )
00183 {
00184   Q_UINT32 t = valueStr.toUInt();
00185   return t;
00186 }
00187 
00188 template<>
00189 inline char TrapperVector<char>::convertToTemplateType( QString valueStr )
00190 {
00191   QChar qc = valueStr.at(0);
00192   char t = qc.latin1();
00193   return t;
00194 }
00195 
00196 template<>
00197 inline double TrapperVector<double>::convertToTemplateType( QString valueStr )
00198 {
00199   double t = valueStr.toDouble();
00200   return t;
00201   
00202 }
00203 
00204 template<>
00205 inline QString TrapperVector<char>::convertToString( char value )
00206 {
00207   QChar c(value);
00208   QString s(c);
00209   return s;
00210 }
00211 
00212 template<>
00213 inline QString TrapperVector<Q_UINT32>::convertToString( Q_UINT32 value )
00214 {
00215   QString s;
00216   s.setNum( value );
00217   return s;
00218 }
00219 
00220 template<>
00221 inline QString TrapperVector<double>::convertToString( double value )
00222 {
00223   QString s;
00224   s.setNum( value );
00225   return s;
00226 }
00227 
00228 
00229 /** Todo: But a problem with this approach might be that the endian awareness of QDataStream might be lost, when we don't serialize the
00230         types one by one. It might be a problem when moving berkeley dbs around archictures. But berkeley db probably doesn't allow this anyway? */
00231 
00232 
00233 template <class T>
00234 QDataStream & operator<< ( QDataStream & stream, TrapperVector<T> & t )
00235 {
00236   if ( t.size() > 0 ) {
00237     
00238     
00239     
00240     const char * dataPtr =  t.data() ;
00241     
00242 #if defined(QT_DEBUG)
00243     
00244     if ( t.size() != 0 ) {
00245       Q_CHECK_PTR( dataPtr );
00246     }
00247     int a = t.size();
00248     qDebug("stream.writeBytes , t.size()=%d",a);
00249 #endif
00250     
00251     stream.writeBytes( dataPtr, t.size() );
00252   }
00253   else {
00254     stream<<0;
00255   }
00256   
00257 
00258   return stream;
00259 }
00260 
00261 
00262     /** Todo: But a problem with this approach might be that the endian awareness of QDataStream might be lost, when we don't serialize the
00263         types one by one. It might be a problem when moving berkeley dbs around archictures. But berkeley db probably doesn't allow this anyway?*/
00264 
00265 
00266 template <class T>
00267 QDataStream & operator>> ( QDataStream & stream, TrapperVector<T> & t )
00268 {
00269     Q_UINT32 len;
00270     stream >> len;
00271 
00272     if ( len > 0 ) {
00273       t.resize( len );
00274       char * dataPtr =  const_cast< char * >( t.data() );
00275       Q_CHECK_PTR( dataPtr );
00276       if ( !dataPtr ) {
00277         cerr<<"len: "<<len<<endl;
00278       }
00279       
00280       
00281 #if defined(QT_DEBUG)
00282       // wrapping macro around should not be a must ... fix this
00283       qDebug("stream.readRawBytes, len=%d",len);
00284 #endif
00285       //     if ( dataPtr ) {
00286       stream.readRawBytes( dataPtr, len );
00287       //     }
00288     }
00289     
00290     return stream;
00291 }
00292 
00293 #endif