MvdTestBeam/Tools/mrfdata_8b.h

Go to the documentation of this file.

/*============================================================*/
/* mrfdata.h                                                  */
/* MVD Readout Framework Data Storage                         */
/*                                               M.C. Mertens */
/*============================================================*/


#ifndef __MRFDATA_8b_H__
#define __MRFDATA_8b_H__


// #include "mrfgal.h"
#include <vector>
#include "mrfbase.h"
#include <string>
#include <map>
#include <climits>

#ifndef __CINT__
#include <boost/archive/archive_exception.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/vector.hpp>
#endif

//#include "mrf_confitem.h"

namespace mrfdata_8b_error {
        static const UInt_t success = 0;
        static const UInt_t out_of_bounds = 1;
        static const UInt_t size_mismatch = 2;
        static const UInt_t not_found = 4;
}


class TMrfData_8b
{
        public:
                TMrfData_8b();

                TMrfData_8b(UInt_t _reglengthbits,UInt_t _reglengthwords,UInt_t _lastreglengthbits,std::vector<UChar_t> _regdata );

                //TMrfData_8b(const TMrfData_8b& rhs);

                //TMrfData_8b& operator=(const TMrfData_8b& rhs);


                void setNumBits(const UInt_t& length);


                const UInt_t& getNumBits() const;


                void setNumWords(const UInt_t& length);


                const UInt_t& getNumWords() const;


                void setBit(const UInt_t& position, const bool& state);


                bool getBit(const UInt_t& position) const;


                const UInt_t& appendBit(const bool& state);


                void setWord(const UInt_t& position, const UChar_t& dataword, const bool& truncate_ok = false);


                void setWordMasked(const UInt_t& position, const UChar_t& dataword, const UChar_t& mask = ~0, const bool& truncate_ok = false);


                const UChar_t& getWord(const UInt_t& position) const;
                
                const UChar_t& appendWord(const UChar_t &dataword);


                void setBitBlock(const UInt_t& position, const UInt_t& length, const UChar_t& value, const UInt_t& offset = 0, const bool& reverse = false);

                const UInt_t& getBitBlock(const UInt_t& position, const UInt_t& length, const UInt_t& offset = 0, const bool& reverse = false) const;

                // Copies a size Bits long Data fragment to position.
                //void copyFragment(const UInt_t sourcestart, const UInt_t destposition, const UInt_t size, const mrf::registertype value);


                UInt_t bitInBlock(const UInt_t& position) const;

                //void setItemValue(const std::string& item, const std::map<const std::string, TConfItem>& bitmap, const mrf::registertype& value, const UInt_t& offset = 0);

                //UInt_t getItemValue(const std::string& item, const std::map<const std::string, TConfItem>& bitmap, const UInt_t& offset = 0) const;

                void clearDataStream();

                bool sameDataStream(const TMrfData_8b& other) const;


                void importBinString(const std::string& data, const UInt_t& offset = 0);

                // Imports a data stream from a string representing hexadecimal digits
                /*
                \param data String consiting only of characters representing hexadecimal digits to be imported as binary data stream.
                \param offset Optional offset (unit is bits) to change the import start position in the binary data stream.
                */
                //void importHexString(const std::string data, const UInt_t offset = 0);


                const std::string& exportBinString() const;


                void resample(const UInt_t& offset, const UInt_t& factor, const bool& reverse = false, const UInt_t& cutoff = 0);

                // Exports a data stream to a string representing hexadecimal digits
                /*
                \return A string containing a hexadecimal representation of the binary data stream.
                */
                //const std::string exportHexString() const;


                const UInt_t& getLastError() const;


                bool lastActionSuccessful() const;
//      private:
                UInt_t reglengthbits;
                UInt_t reglengthwords;
                UInt_t lastreglengthbits;
                static const UInt_t zeroval = 0;
                mutable UInt_t _bitblock;
                mutable std::string _data;

                // Allow serialization to access non-public data members
        #ifndef __CINT__
                friend class boost::serialization::access;
        #endif
                template<class Archive>
                void serialize(Archive & ar, const unsigned int )
                {
                    ar & reglengthbits;
                    ar & reglengthwords;
                    ar & lastreglengthbits;
                    ar & regdata;

                }

//      protected:

                mutable UInt_t errcode;

                static const UInt_t bitsinablock = sizeof(UChar_t) * CHAR_BIT;


                std::vector<UChar_t> regdata;
                //void copyBlock(const UInt_t sourcestart, const UInt_t length, const UInt_t deststart, const UInt_t value);
};



#endif // __MRFDATA_8b_H__