QStdVector.hh

Go to the documentation of this file.

#ifndef _Q_STDVECTOR_HH_
#define _Q_STDVECTOR_HH_
 
#include "QObject.hh"
#include <vector>
#include <sstream>
 
Q_BEGIN_NAMESPACE
 
template<class T> class QStdVector : public std::vector<T>, public QObject 
{
 
    public:
       QStdVector() {}
 
       QStdVector(const std::vector<T>& rhs) { this->operator=(rhs); }
 
       QStdVector(const QStdVector<T>& rhs) { this->operator=(rhs); }
 
       void Clear() 
       {
           std::vector<T>::clear();
       }
 
       QError WriteOnStream (std::ostream &o) const
       {
           QError err = QERR_SUCCESS;
           o<<"fSize"<<"\t"<<std::vector<T>::size()<<std::endl;
           if(std::vector<T>::empty()) return err;
           o<<"fData";
           for(size_t i = 0; i < std::vector<T>::size(); i++) {
               o<<"\t"<<std::vector<T>::operator[](i);
           }
           o<<std::endl;
           return err;
       }
       QError ReadFromStream (std::istream &ob)
       {
           std::vector<T>::clear();
           QError err = QERR_SUCCESS;
           std::string tag; 
           int size = 0;
           ob>>tag>>size;
           if(tag != "fSize") {
               err = QERR_UNKNOWN_ERR;
               err.SetDescription(__FILE__,__LINE__,"Expected tag fFunction.fName");
               return err;
           }
           if(size < 0) {
               err = QERR_SIZE_NOT_MATCH;
               err.SetDescription(__FILE__,__LINE__,"Tag fSize cannot be negative");
           }
           if(size == 0) return err;
           std::vector<T>::resize(size);
 
           ob>>tag;
           if(tag != "fData") {
               err = QERR_UNKNOWN_ERR;
               err.SetDescription(__FILE__,__LINE__,"Expected tag fData after tag fSize");
               return err;
           }
 
           T element;
           for(size_t i = 0; i < (size_t)size; i++) {
               ob>>element;
               if(!ob.good()) {
                   err = QERR_SIZE_NOT_MATCH;
                   std::stringstream msg;
                   msg << "Cannot read element "<< i;
                   err.SetDescription(__FILE__,__LINE__,msg.str());
                   break;
               } else {
                   std::vector<T>::operator[](i) = element;
               }
           }
 
           return err;
 
 
       }
       void Dump(std::ostream& o) const { WriteOnStream(o);  }
 
        bool Fill(Diana::QObject* obj) const
        {
            QStdVector<T>* bt = dynamic_cast<QStdVector<T>* >(obj);
            if(bt) {
                *bt = *this; 
            }
            return bt != NULL;
        }
 
        QObject* Duplicate() const {
            QStdVector<T> * obj = new QStdVector<T>;
            return obj;
        }
 
        QStdVector<T>& operator=(const std::vector<T>& rhs)
        {
            std::vector<T>::operator=(rhs);
            Validate();
            return *this;
        }
 
    private:
 
       ClassDef(QStdVector,2);
 
};
 
Q_END_NAMESPACE
#endif