Header parser iterator

Header parser iterator
Prev	Chapter 74. Parsing MIME documents	Next

The x::mime::header_iter template instantiates an output iterator that takes the output sequence from x::mime::bodystart_iter. The template parameter is another output iterator class, over an int output sequence. Instantiated by create(), the constructor takes an instance of the output iterator class, which ends up iterating over the output sequence that x::mime::header_iter received, and x::mime::header_iter adds additional values into the output sequence:

The name of each header gets preceded by an x::mime::header_name_start and followed by an x::mime::header_name_end.
The contents of each header gets preceded by an x::mime::header_contents_start and followed by an x::mime::header_contents_end. x::mime::header_name_start and x::mime::header_name_end are always followed by x::mime::header_contents_start and x::mime::header_contents_end, but x::mime::header_contents_start does not immediately follow a x::mime::header_name_end.
The portion of the output sequence delimited by x::mime::header_contents_start and x::mime::header_contents_end excludes the colon and whitespace that separates the header name from its contents. x::mime::header_iter does not remove values from the output sequence it receives, it only adds these additional values.
For multiline header contents, the sequence delimited by an x::mime::header_contents_start and an x::mime::header_contents_end has additional x::mime::header_fold_start and an x::mime::header_fold_end values that delimiter the start and the end of the newline and leading spaces on the continued header line. For the purpose of parsing the headers contents, the output sequence between and including x::mime::header_fold_start and x::mime::header_fold_end is logically equivalent to a single space character (as already mentioned, x::mime::header_iter does not remove values from the output sequence it receives, it only adds dditional values).
After x::mime::header_iter iterates over a x::mime::body_start, the x::mime::header_iter passes it, and the rest of the output sequence, with no further parsing or action.

examples/mime/headeriter.C

#include <x/mime/newlineiter.H>
#include <x/mime/bodystartiter.H>
#include <x/mime/headeriter.H>
#include <map>
#include <iterator>
#include <iostream>

class headercollector : public std::iterator<std::output_iterator_tag,
					     void, void, void, void> {

public:
	std::multimap<std::string, std::string> *h;
	std::string name;

	bool seen_contents_start;
	bool in_header_name;
	bool in_newline;
	bool in_fold;

	std::multimap<std::string, std::string>::iterator value;
	headercollector(std::multimap<std::string, std::string> *hArg)
		: h(hArg), in_header_name(false), seen_contents_start(false)
	{
	}

	void operator=(int c)
	{
		switch (c) {
		case x::mime::header_name_start:
			name.clear();
			in_header_name=true;
			return;
		case x::mime::header_name_end:
			value=h->insert(std::make_pair(name, ""));
			in_header_name=false;
			return;
		case x::mime::header_contents_start:
			seen_contents_start=true;
			in_newline=false;
			in_fold=false;
			return;
		case x::mime::header_contents_end:
			seen_contents_start=false;
			return;
		case x::mime::header_fold_start:
			in_fold=true;
			return;
		case x::mime::header_fold_end:
			in_fold=false;
			value->second.push_back(' ');
			return;
		case x::mime::newline_start:
			in_newline=true;
			return;
		case x::mime::newline_end:
			in_newline=false;
			return;
		}

		if (!x::mime::nontoken(c))
			return;

		if (in_header_name)
		{
			name.push_back(c);
			return;
		}

		if (!seen_contents_start || in_fold || in_newline)
			return;

		value->second.push_back(c);
	}

	headercollector &operator*()
	{
		return *this;
	}

	headercollector &operator++()
	{
		return *this;
	}

	headercollector &operator++(int)
	{
		return *this;
	}
};

int main()
{
	std::multimap<std::string, std::string> h;

	typedef x::mime::header_iter<headercollector> header_iter_t;

	typedef x::mime::bodystart_iter<header_iter_t> bodystart_iter_t;

	typedef x::mime::newline_iter<bodystart_iter_t> newline_iter_t;

	auto iter=std::copy(std::istreambuf_iterator<char>(std::cin),
			    std::istreambuf_iterator<char>(),
			    newline_iter_t::create
			    (bodystart_iter_t::create
			     (header_iter_t::create(&h))));

	iter.get()->eof();

	for (const auto &c:h)
	{
		std::cout << "Header: " << c.first << ", value: "
			  << c.second << std::endl;
	}
	return 0;
}

This example constructs a simple output iterator that receives the output sequence from a x::mime::header_iter, collects all headers in a std::multimap, then shows them:


      

$ cat headeriter.txt

Mime-Version: 1.0

Subject: subject line

   folded header



test

$ ./headeriter <headeriter.txt

Header: Mime-Version, value: 1.0

Header: Subject, value: subject line folded header

`x::mime::header_collector`

x::mime::header_collector implements a basic output iterator that turns the output sequence from a x::mime::header_iter into calls to a lambda or a functor:

examples/mime/headercollector.C

#include <x/mime/newlineiter.H>
#include <x/mime/bodystartiter.H>
#include <x/mime/headeriter.H>
#include <x/mime/headercollector.H>
#include <map>
#include <iterator>
#include <iostream>

int main()
{
	typedef x::mime::header_iter<x::mime::header_collector> header_iter_t;

	typedef x::mime::bodystart_iter<header_iter_t> bodystart_iter_t;

	typedef x::mime::newline_iter<bodystart_iter_t> newline_iter_t;

	auto iter=std::copy(std::istreambuf_iterator<char>(std::cin),
			    std::istreambuf_iterator<char>(),
			    newline_iter_t::create
			    (bodystart_iter_t::create
			     (header_iter_t::create
			      (x::mime::header_collector::create
			       ([] (const std::string &name,
				    const std::string &name_lc,
				    const std::string &value)
		{
			std::cout << "Header: " << name
			<< ", value: " << value
			<< std::endl;
		})))));

	iter.get()->eof();
	return 0;
}

This produces the same results as the previous example, with two small, but important, differences.

x::mime::header_collector::create() instantiates an output iterator over the sequence from x::mime::header_iter, and calls the lambda or the functor that's passed to create(). The functor/lambda gets invoked with three parameters: the header name, the header name converted to lowercase, and the contents of the header.
x::mime::header_collector does not store the headers from the MIME object it iterates over into a container of any kind. The functor/lambda gets invoked as soon as the entire header name and contents get iterated over.

Prev	Up	Next
Detecting start of a MIME document's body	Table Of Contents	MIME section information