DataView.hpp

// <DataView> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <ios>
#include <iomanip>
#include <math.h>
 
#include "sparta/functional/ArchDataSegment.hpp"
#include "sparta/functional/ArchData.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
 
 
namespace sparta
{
    class DataView : public ArchDataSegment
    {
    public:
 
        typedef ArchDataSegment::offset_type offset_type; 
        typedef ArchDataSegment::ident_type ident_type; 
        typedef uint32_t index_type; 
 
        using ArchDataSegment::INVALID_ID;
 
        static const std::string DATAVIEW_UNPLACED_STR;
 
        DataView(ArchData* data,
                 ident_type id,
                 offset_type size,
                 ident_type subset_of=INVALID_ID,
                 offset_type subset_offset=0,
                 const uint8_t* initial_buf_le=nullptr) :
            ArchDataSegment(data, size, id, subset_of, subset_offset),
            adata_(data), offset_(0),
            line_(0),
            initial_buf_le_(initial_buf_le)
        {
            sparta_assert(data, "ArchData (data) must not be null");
            static_assert(sizeof(uint64_t) > sizeof(index_type),
                          "Must have a type larger than index_type in order to "
                          "perform bounds checking on index values which must "
                          "support the entire range from 0 to the maximum value");
 
            // Allowed, but no other segments can be a subset
            //if(id == INVALID_ID){
            //    throw SpartaException("Cannot construct DataView with identifier=INVALID_ID");
            //}
 
            if(subset_of == INVALID_ID && subset_offset != 0){
                throw SpartaException("Cannot construct DataView with a valid identifier and nonzero offset: 0x")
                    << std::hex << subset_offset << ". Change subset_offset to 0 or set subset_of to INVALID_ID";
            }
 
            adata_->registerSegment(this); // Add self
        }
 
 
        // Attributes (non-virtual access)
 
        ArchData* getArchData() const { return adata_; }
 
        offset_type getSize() const { return getLayoutSize(); }
 
        offset_type getOffset() const { return offset_; }
 
        ArchData::Line* getLine() const { return line_; } 
 
        ident_type getID() const { return getLayoutID(); }
 
 
        // I/O methods
 
        template <typename T, ByteOrder BO=LE>
        T read(index_type idx=0) const {
            sparta_assert(idx < (getSize() / sizeof(T)), // Avoids overflow with large indexes
                              "read index " << idx << " and type " << demangle(typeid(T).name())
                              << " (size " << sizeof(T) << ") is invalid for this DataView of size " << getSize());
            return readUnsafe<T, BO>(idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        T readUnsafe(index_type idx=0) const {
            sparta_assert(line_, "There is no line pointer set for this DataView. ArchData likely has not been laid out yet. Tree probably needs to be finalized first.");
            return line_->read<T, BO>(offset_, idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        T readPadded(index_type idx=0) const {
            sparta_assert(sizeof(T) * ((uint64_t)idx) <= getSize(),
                              "readPadded index " << idx << " and type " << demangle(typeid(T).name())
                              << " (size " << sizeof(T) << ") is invalid for this DataView of size " << getSize());
            return readPaddedUnsafe<T, BO>(idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        T readPaddedUnsafe(index_type idx=0) const {
            sparta_assert(line_, "There is no line pointer set for this DataView. ArchData likely has not been laid out yet. Tree probably needs to be finalized first.");
            offset_type max_bytes = getSize() - (sizeof(T) * idx); // Must always be a power of 2
            sparta_assert(isPowerOf2(max_bytes));
 
            T result;
            if(max_bytes >= 8){
                result = line_->read<uint64_t, BO>(offset_, idx);
            }else if(max_bytes == 4){
                result = line_->read<uint32_t, BO>(offset_, idx);
            }else if(max_bytes == 2){
                result = line_->read<uint16_t, BO>(offset_, idx);
            }else if(max_bytes == 1){
                result = line_->read<uint8_t,  BO>(offset_, idx);
            }else{
                sparta_assert(max_bytes == 0);
                result = 0;
            }
 
            return result;
        }
 
        template <typename T, ByteOrder BO=LE>
        void write(T val, index_type idx=0) {
            sparta_assert(idx < (getSize() / sizeof(T)), // Avoids overflow with large indexes
                              "write index " << idx << " and type " << demangle(typeid(T).name())
                              << " (size " << sizeof(T) << ") is invalid for this DataView of size " << getSize());
 
            writeUnsafe<T, BO>(val, idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        void writeUnsafe(T val, index_type idx=0) {
            sparta_assert(line_, "There is no line pointer set for this DataView. ArchData likely has not been laid out yet. Tree probably needs to be finalized first.");
 
            line_->write<T, BO>(offset_, val, idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        void writeTruncated(T val, uint32_t idx=0) {
            sparta_assert(sizeof(T) * ((uint64_t)idx) <= getSize(),
                              "writeTruncated index " << idx << " and type " << demangle(typeid(T).name())
                              << " (size " << sizeof(T) << ") is invalid for this DataView of size " << getSize());
 
            writeTruncatedUnsafe<T, BO>(val, idx);
        }
 
        template <typename T, ByteOrder BO=LE>
        void writeTruncatedUnsafe(T val, uint32_t idx=0) {
            sparta_assert(line_, "There is no line pointer set for this DataView. ArchData likely has not been laid out yet. Tree probably needs to be finalized first.");
            offset_type max_bytes = getSize() - (sizeof(T) * idx); // Must always be a power of 2
            sparta_assert(isPowerOf2(max_bytes));
 
            if(max_bytes >= 8){
                line_->write<uint64_t, BO>(offset_, (uint64_t)val, idx);
            }else if(max_bytes == 4){
                line_->write<uint32_t, BO>(offset_, (uint32_t)val, idx);
            }else if(max_bytes == 2){
                line_->write<uint16_t, BO>(offset_, (uint16_t)val, idx);
            }else if(max_bytes == 1){
                line_->write<uint8_t,  BO>(offset_, (uint8_t)val, idx);
            }else{
                sparta_assert(max_bytes == 0);
            }
        }
 
        DataView& operator=(const DataView& rhp) {
            if(getSize() != rhp.getSize()){
                throw SpartaException("Cannot copy data between DataViews using operator= because the sizes differ");
            }
            if(rhp.line_ == nullptr){
                throw SpartaException("Cannot copy data between DataViews using operator= because the right-hand operand is not laid out");
            }
            if(line_ == nullptr){
                throw SpartaException("Cannot copy data between DataViews using operator= because the left-hand operand is not laid out");
            }
 
            const uint8_t* const src = rhp.line_->getDataPointer(rhp.offset_);
            line_->write(offset_, getSize(), src);
 
            return *this;
        }
 
        std::string getByteString() const {
            sparta_assert(isPlaced(), "DataView has not been placed");
 
            std::stringstream o;
            o.fill('0');
            for(offset_type i=0; i<getSize(); ++i){
                o << std::setw(2) << std::hex << (uint16_t)read<uint8_t, LE>(i) << ' ';
            }
            return o.str();
        }
 
        template <ByteOrder BO=LE>
        std::string getValueAsString() const {
            sparta_assert(isPlaced(), "DataView has not been placed");
 
            std::stringstream ss;
            ss << "0x" << std::hex << std::setw(getSize()*2) << std::setfill('0');
            switch(getSize()){
            case 1:
                ss << (uint32_t)read<uint8_t, BO>();
                break;
            case 2:
                ss << (uint32_t)read<uint16_t, BO>();
                break;
            case 4:
                ss << read<uint32_t, BO>();
                break;
            default: // 8 or more bytes
                assembleIndexedReadsToValue_<BO>(ss);
            }
            return ss.str();
        }
 
    protected:
 
 
        virtual void place_(offset_type offset) override {
            adata_->checkSegment(offset, getSize());
            line_ = &adata_->getLine(offset);
            offset_ = offset - line_->getOffset(); // Store locally for faster 'read' calls
        }
 
        virtual void writeInitial_() override {
            // Write initial value
            if(initial_buf_le_){
#if __BYTE_ORDER == __LITTLE_ENDIAN
                for(offset_type i=0; i<getSize(); ++i){
                    write<uint8_t>(initial_buf_le_[i], i);
                }
#else // #if __BYTE_ORDER == __LITTLE_ENDIAN
                for(offset_type i=getSize(); i>0; --i){
                    write<uint8_t>(initial_buf_le_[i], i);
                }
#endif // else // #if __BYTE_ORDER == __LITTLE_ENDIAN
            }
        }
 
 
    private:
 
        template <ByteOrder BO=LE>
        void assembleIndexedReadsToValue_(std::stringstream& ss) const {
            ss << "<unknown byte-order: " << BO << ">";
        }
 
        ArchData* const adata_;   
        offset_type offset_;      
        ArchData::Line* line_;    
 
        const uint8_t* const initial_buf_le_;
    }; // class DataView
 
    template <>
    inline void DataView::assembleIndexedReadsToValue_<LE>(std::stringstream& ss) const {
        for(offset_type i=(getSize()/8); i>0; --i){
            ss << std::setw(16) << read<uint64_t, LE>(i-1);
        }
    }
 
    template <>
    inline void DataView::assembleIndexedReadsToValue_<BE>(std::stringstream& ss) const {
        for(offset_type i=0; i<getSize()/8; ++i){
            ss << std::setw(16) << read<uint64_t, BE>(i);
        }
    }
 
} // namespace sparta
 
#define SPARTA_DATAVIEW_BODY                                              \
    const std::string sparta::DataView::DATAVIEW_UNPLACED_STR = "dataview-unplaced";