.. _program_listing_file_decoder.hpp:

Program Listing for File decoder.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file_decoder.hpp>` (``decoder.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef FELIX_DECODER_H_
   #define FELIX_DECODER_H_
   
   #include <string>
   #include <memory>
   #include "device.hpp"
   #include "elink.hpp"
   #include "tohost_monitor.hpp"
   #include "block.hpp"
   #include "publisher.hpp"
   #include "l0id_decoder.hpp"
   
   
   struct chunk_buffer
   {
       std::uint8_t m_status_byte{};
       size_t chunk_size{};
       std::vector<iovec> iov;
   
       chunk_buffer() : m_status_byte(0), chunk_size(0){
           iov.emplace_back(&m_status_byte, 1);
       };
   
       void push_back(iovec&& x) {
           iov.push_back(x);
           chunk_size += x.iov_len;
       }
       
       void clear() noexcept {
           iov.resize(1);
           chunk_size = 0;
           m_status_byte = 0;
       }
   
       bool empty() const noexcept {
           // Status byte
           return iov.size() == 1;
       }
   
       void remove_last_entry() {
           chunk_size -= iov.back().iov_len;
           iov.resize(iov.size()-1);
       }
   
       void update_status_byte(uint8_t status) {
           m_status_byte |= status;
       }
   
       uint8_t get_status_byte() const {
           return m_status_byte;
       }
   
       size_t byte_size() {
           return chunk_size;
       }
   
       size_t iov_len() {
           return iov.size();
       }
   
       iovec* iov_addr() {
           return iov.data();
       }
   
   };
   
   
   class Decoder
   {
       public:
           Decoder(const Decoder&) = delete;
           Decoder& operator=(const Decoder&) = delete;
   
           Decoder(Decoder&&) = default;
           Decoder& operator=(Decoder&&) = default;
   
           Decoder(const Elink &elink, Publisher &publisher, flx_tohost_format fmt,
               int l0id_decoder_fmt, unsigned int block_size, uint64_t buf_vaddr);
   
           uint32_t get_last_block(){return m_last_block;}
   
           uint64_t get_fid(){return m_elink.fid;}
   
           void set_block_size(unsigned int block_size){m_block_size = block_size;}
   
           Publisher::Result decode(Block & block);
   
           ToHostElinkStats get_decoder_stats(){return m_stats;}
   
           ToHostElinkStats get_decoder_stats_increment(ToHostElinkStats & previous);
   
       private:
           enum SubchunkType {
               NIL = 0, FIRST, LAST, WHOLE, MIDDLE, TIMEOUT, OOB
           };
   
           Publisher::Result post_subchunk(uint8_t *data, uint32_t length, SubchunkType type, uint8_t err);
   
           [[nodiscard]] Publisher::Result check_block_integrity(Block & block);
   
   
           Publisher::Result decode_subchunk_headers(Block & block);
   
           Publisher::Result decode_subchunk_trailers(Block & block);
   
           void on_successful_send();
   
       private:
           ToHostElinkStats m_stats;
           Elink m_elink;
           Publisher &m_publisher;
           uint64_t m_buffer_vaddr;
           unsigned int m_block_size;
   
           uint8_t m_seqnr_err = 0;
           uint8_t m_last_seqnr = 0;
           uint32_t m_last_block = 0;
           uint16_t m_chunk_position = 0;
           std::function< Publisher::Result(Block & block)> m_decode;
   
   
           std::unique_ptr<L0Decoder> m_l0id_checker;
           std::vector<std::pair<uint16_t, uint32_t>> m_subchunks;
           chunk_buffer m_scratch;
   };
   
   #endif /* FELIX_DECODER_H_ */