intel_hex.h

#pragma once
#ifndef PFLIB_UTILITY_INTEL_HEX_H
#define PFLIB_UTILITY_INTEL_HEX_H
 
#include <cstdint>
#include <cstdio>
#include <fstream>
#include <string>
#include <type_traits>
#include <vector>
 
namespace pflib::utility {
 
namespace intel_hex {
 
class DataRecord {
  std::vector<uint8_t> data_;
  uint16_t addr_;
 
 public:
  void from_bytes(uint16_t addr, std::vector<uint8_t> data);
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  void from(uint16_t addr, WordType value) {
    addr_ = addr;
    data_.resize(sizeof(WordType));
    for (int i_byte{0}; i_byte < sizeof(WordType); i_byte++) {
      data_[i_byte] = static_cast<uint8_t>(
          (value >> 8 * (sizeof(WordType) - i_byte - 1)) & 0xff);
    }
  }
  const std::vector<uint8_t>& get_bytes() const;
  template <typename WordType,
            std::enable_if_t<std::is_integral<WordType>::value, bool> = true>
  WordType get() {
    WordType word = 0;
    for (int i_byte{0}; i_byte < get_bytes().size(); i_byte++) {
      word |= (static_cast<WordType>(get_bytes().at(i_byte))
               << 8 * (sizeof(WordType) - i_byte - 1));
    }
    return word;
  }
  const uint16_t& addr() const;
};
 
class Reader {
  std::ifstream input_file_;
  DataRecord current_record_;
  std::size_t error_count_;
 
 public:
  Reader(const Reader&) = delete;
  Reader& operator=(const Reader&) = delete;
  ~Reader() = default;
  Reader(const std::string& input_filepath);
  std::size_t errors() const;
  bool next();
  const DataRecord& get();
};
 
class Writer {
  FILE* output_file_;
 
 public:
  Writer(const Writer&) = delete;
  Writer& operator=(const Writer&) = delete;
  Writer(const std::string& output_filepath);
  ~Writer();
  void add(const DataRecord& data);
  void close();
};
 
}  // namespace intel_hex
 
}  // namespace pflib::utility
 
#endif