lovehtml.h

#ifndef LOVEHTML_H
#define LOVEHTML_H
 
#include <filesystem>
#include <map>
#include <string>
#include <vector>
 
class ToHTML
{
public:
  enum class MHTMLHeaderType: std::size_t {
    Origin,
    Location,
    Subject,
    Date,
    MIMEVersion,
    ContentType,
    CTType,
    CTBoundary
  };
 
  enum class MHTMLPartHeaderType: std::size_t {
    Type,
    ID,
    Encoding,
    Location
  };
 
  enum class ContentType {
    TextHTML,
    TextCss,
    ImageSvgXml,
    ImagePng,
    ImageJpeg,
    ImageXCitrixJpeg,
    MultipartRelated
  };
 
  enum class Encoding {
    QuotedPrintable,
    Base64
  };
 
  enum class LoadError {
    InputNotFound,
    UnableToOpenInput
  };
 
  enum class ParseError {
    InputEmpty,
    HeaderNotFound,
    BoundaryEmpty,
    LineIndexOutOfBounds,
    UnsupportedEncoding,
    UnsupportedContentType,
    MissingPartLocation,
    MissingPartEncoding
  };
 
  enum class BuildError {
    EmptyDocumentBody,
    MissingPartContentType,
    UnsupportedPartContentType,
    MissingPartEncoding
  };
 
  enum class DecodeError {
    InvalidHexASCIIEncoding
  };
 
  class MHTMLPart {
  public:
    std::map<MHTMLPartHeaderType, std::string> header;
    std::vector<std::string> content;
  };
 
  class MHTML {
  public:
    std::map<MHTMLHeaderType, std::string> header;
    std::map<MHTMLPartHeaderType, std::string> bodyHeader;
    std::string body;
    std::map<std::string, MHTMLPart> resources;
  };
 
  template<typename T>
  class MHTMLHeaderLine {
  public:
    T type;
    std::string_view content;
  };
 
  using MHTMLHeader = std::map<MHTMLHeaderType, std::string>;
  using MHTMLPartHeader = std::map<MHTMLPartHeaderType, std::string>;
  using MHTMLParseResult = std::variant<MHTML, ParseError>;
  using HeaderLineParseResult = std::variant<MHTMLHeaderLine<MHTMLHeaderType>, ParseError>;
  using PartHeaderLineParseResult = std::variant<MHTMLHeaderLine<MHTMLPartHeaderType>, ParseError>;
  using PartParseResult = std::variant<MHTMLPart, ParseError>;
  using HeaderParseResult = std::variant<MHTMLHeader, ParseError>;
  using PartHeaderParseResult = std::variant<MHTMLPartHeader, ParseError>;
  using FileLoadResult = std::variant<std::vector<std::string>, LoadError>;
  using PartDecodeResult = std::variant<std::vector<std::string>, DecodeError>;
  using LineDecodeResult = std::variant<std::string, DecodeError>;
  using CharDecodeResult = std::variant<char, DecodeError>;
  using EncodingParseResult = std::variant<Encoding, ParseError>;
  using ContentTypeParseResult = std::variant<ContentType, ParseError>;
  using BuildResult = std::variant<std::string, BuildError>;
 
  explicit ToHTML(const std::filesystem::path& mhtml_file);
  explicit ToHTML(const std::vector<std::string>& mhtml);
  virtual ~ToHTML();
 
  std::string input();
  std::string output();
 
private:
  static FileLoadResult LoadFile(const std::filesystem::path& path);
 
  static MHTMLParseResult ParseMHTML(const std::vector<std::string>& mhtml);
  static HeaderLineParseResult ParseHeaderLine(std::string_view line);
  static PartParseResult ParsePart(const std::vector<std::string>& mhtml, std::size_t& index, const std::string_view& boundary);
  static PartHeaderParseResult ParsePartHeader(const std::vector<std::string>& mhtml, std::size_t& index, const std::string_view& boundary);
  static PartHeaderLineParseResult ParsePartHeaderLine(std::string_view line);
  static EncodingParseResult EncodingFromString(const std::string_view& str);
  static ContentTypeParseResult ContentTypeFromString(const std::string_view& str);
 
  template<Encoding enc> static PartDecodeResult DecodePart(const std::vector<std::string>& mhtml, std::size_t& index, const std::string_view& boundary);
  template<Encoding enc> static LineDecodeResult DecodeLine(std::string_view mhtml);
  static CharDecodeResult HexToASCII(const std::string& hex);
 
  static BuildResult BuildHTML(const MHTML& mhtml);
  template<ContentType ct> static BuildResult BuildSubstitute(const MHTMLPart& part, const std::string_view& contentType);
  static BuildResult BuildImageSubstitute(const MHTMLPart& part, const std::string_view& contentType);
 
  static void RemovePrefix(std::string_view& str, const std::string_view& prefix);
  static void RemoveSuffix(std::string_view& str, const std::string_view& prefix);
 
  static bool IsBoundary(std::string_view line, const std::string_view& boundary);
  static bool IsHexadecimal(std::string_view line);
 
  static std::string GetEncoding(const MHTMLPartHeader& header);
  static std::string GetContentType(const MHTMLPartHeader& header);
 
  static constexpr std::string_view WHITE_SPACE = " \t\n\r\f\v";
  static constexpr std::array<std::string_view, static_cast<std::size_t>(MHTMLHeaderType::CTBoundary) + 1> meta_starts =
  {
      "From:",
      "Snapshot-Content-Location:",
      "Subject:",
      "Date:",
      "MIME-Version:",
      "Content-Type:",
      "type=",
      "boundary="
  };
  static constexpr std::array<std::string_view, static_cast<std::size_t>(MHTMLPartHeaderType::Location) + 1> part_starts =
  {
      "Content-Type:",
      "Content-ID:",
      "Content-Transfer-Encoding:",
      "Content-Location:"
  };
 
private:
  std::string m_input;
  std::string m_output;
};
 
#endif // LOVEHTML_H