hffix.hpp

Go to the documentation of this file.

/*******************************************************************************************
Copyright 2011, T3 IP, LLC. All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are
permitted provided that the following conditions are met:
 
   1. Redistributions of source code must retain the above copyright notice, this list of
      conditions and the following disclaimer.
 
   2. Redistributions in binary form must reproduce the above copyright notice, this list
      of conditions and the following disclaimer in the documentation and/or other materials
      provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY T3 IP, LLC ``AS IS'' AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL T3 IP, LLC OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
The views and conclusions contained in the software and documentation are those of the
authors and should not be interpreted as representing official policies, either expressed
or implied, of T3 IP, LLC.
*******************************************************************************************/
 
#ifndef HFFIX_HPP
#define HFFIX_HPP
 
#include "hffix_fields.hpp" // for field and message tag names and properties. Needed for length_fields[].
#include <cstring>          // for memcpy
#include <string>           //
#include <algorithm>        // for is_tag_a_data_length
#include <numeric>          // for accumulate
#include <iostream>         // for operator<<()
#include <limits>           // for numeric_limits<>::is_signed
#include <stdexcept>        // for exceptions
#if __cplusplus >= 201703L
#include <string_view>      // for push_back_string()
#endif
#if __cplusplus >= 201103L
#include <cstdint>          // for std::uint8_t
#include <chrono>
#endif
 
#ifndef HFFIX_NO_BOOST_DATETIME
#ifdef DATE_TIME_TIME_HPP___ // The header include guard from boost/date_time/time.hpp
#ifdef DATE_TIME_DATE_HPP___ // The header include guard from boost/date_time/date.hpp
#define HFFIX_BOOST_DATETIME
#endif
#endif
#endif
 
namespace hffix {
 
/* @cond EXCLUDE */
 
namespace details {
 
inline void throw_range_error() {
    throw std::out_of_range("hffix message_writer buffer full");
}
 
template <std::size_t N>
std::ptrdiff_t len(char const (&)[N]) { return std::ptrdiff_t(N - 1); }
 
/*
\brief Internal ascii-to-integer conversion.
 
Parses ascii and returns a (possibly negative) integer.
 
\tparam Int_type The type of integer to be returned.
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\return The ascii string represented as an integer of type Int_type.
*/
template<typename Int_type> Int_type atoi(char const* begin, char const* end)
{
    Int_type val(0);
    bool isnegative(false);
 
    if (begin < end && *begin == '-') {
        isnegative = true;
        ++begin;
    }
 
    for(; begin<end; ++begin) {
        val *= 10;
        val += (Int_type)(*begin - '0');
    }
 
    return isnegative ? -val : val;
}
 
 
/*
\brief Internal ascii-to-unsigned-integer conversion.
 
Parses ascii and returns an unsigned integer.
 
\tparam Uint_type The type of unsigned integer to be returned.
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\return The ascii string represented as an unsigned integer of type Uint_type.
*/
template<typename Uint_type> Uint_type atou(char const* begin, char const* end)
{
    Uint_type val(0);
 
    for(; begin<end; ++begin) {
        val *= 10u;
        val += (Uint_type)(*begin - '0');
    }
 
    return val;
}
 
 
/*
\brief Internal integer-to-ascii conversion.
 
Writes an integer out as ascii.
 
\tparam Int_type Type of integer to be converted.
\param number Value of the integer to be converted.
\param buffer Pointer to location for the ascii to be written.
\param end Past-the-end of the buffer, to check for overflow.
\return Pointer to past-the-end of the ascii that was written.
*/
template<typename Int_type> char* itoa(Int_type number, char* buffer, char* end)
{
    // Write out the digits in reverse order.
    bool isnegative(false);
    if (number < 0) {
        isnegative = true;
        number = -number;
    }
 
    char*b = buffer;
    do {
        if (b >= end) details::throw_range_error();
        *b++ = '0' + (number % 10);
        number /= 10;
    } while(number);
 
    if (isnegative) {
        if (b >= end) details::throw_range_error();
        *b++ = '-';
    }
 
    // Reverse the digits in-place.
    std::reverse(buffer, b);
 
    return b;
}
 
 
/*
\brief Internal unsigned-integer-to-ascii conversion.
 
Writes an unsigned integer out as ascii.
 
\tparam Int_type Type of integer to be converted.
\param number Value of the integer to be converted.
\param buffer Pointer to location for the ascii to be written.
\param end Past-the-end of the buffer, to check for overflow.
\return Pointer to past-the-end of the ascii that was written.
*/
template<typename Uint_type> char* utoa(Uint_type number, char* buffer, char* end)
{
    // Write out the digits in reverse order.
    char*b = buffer;
    do {
        if (b >= end) details::throw_range_error();
        *b++ = '0' + (number % 10);
        number /= 10;
    } while(number);
 
    // Reverse the digits in-place.
    std::reverse(buffer, b);
 
    return b;
}
 
/*
\brief Internal ascii-to-decimal conversion.
 
Converts an ascii string to a decimal float, of the form \htmlonly mantissa&times;10<sup>exponent</sup>\endhtmlonly.
 
Non-normalized. The exponent will always be less than or equal to zero.
If the decimal float is an integer, the exponent will be zero.
 
\tparam Int_type Signed integer type for the mantissa and exponent.
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param mantissa Reference to storage for the mantissa of the decimal float to be returned.
\param exponent Reference to storage for the exponent of the decimal float to be returned.
*/
template<typename Int_type> void atod(char const* begin, char const* end, Int_type& mantissa, Int_type& exponent)
{
    Int_type mantissa_ = 0;
    Int_type exponent_ = 0;
    bool isdecimal(false);
    bool isnegative(false);
 
    if (begin < end && *begin == '-') {
        isnegative = true;
        ++begin;
    }
 
    for(; begin < end; ++begin) {
        if (*begin == '.') {
            isdecimal = true;
        } else {
            mantissa_ *= 10;
            mantissa_ += (*begin - '0');
            if (isdecimal) --exponent_;
        }
    }
 
    if (isnegative) mantissa_ = -mantissa_;
    mantissa = mantissa_;
    exponent = exponent_;
}
 
/*
\brief Internal decimal-to-ascii conversion.
 
Converts a decimal float of the form \htmlonly mantissa&times;10<sup>exponent</sup>\endhtmlonly to ascii.
 
Non-normalized. The exponent parameter must be less than or equal to zero.
 
\tparam Int_type Integer type for the mantissa and exponent.
\param mantissa The mantissa of the decimal float.
\param exponent The exponent of the decimal float. Must be less than or equal to zero.
\param buffer Pointer to location for the ascii to be written.
\param end Past-the-end of the buffer, to check for overflow.
\return Pointer to past-the-end of the ascii that was written.
*/
template<typename Int_type> char* dtoa(Int_type mantissa, Int_type exponent, char* buffer, char* end)
{
    // Write out the digits in reverse order.
    bool isnegative(false);
    if (mantissa < 0) {
        isnegative = true;
        mantissa = -mantissa;
    }
 
    char*b = buffer;
    do {
        if (b >= end) details::throw_range_error();
        *b++ = '0' + (mantissa % 10);
        mantissa /= 10;
        if (++exponent == 0) {
            if (b >= end) details::throw_range_error();
            *b++ = '.';
        }
    } while(mantissa > 0 || exponent < 1);
 
    if (isnegative) {
        if (b >= end) details::throw_range_error();
        *b++ = '-';
    }
 
    // Reverse the digits in-place.
    std::reverse(buffer, b);
 
    return b;
}
 
 
/*
\brief Internal ascii-to-date conversion.
 
Parses ascii and returns a LocalMktDate or UTCDate.
 
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param[out] year Year.
\param[out] month Month.
\param[out] day Day.
\return True if successful and the out arguments were set.
*/
inline bool atodate(
    char const* begin,
    char const* end,
    int& year,
    int& month,
    int& day
)
{
    if (end - begin != 8) return false;
 
    year = details::atoi<int>(begin, begin + 4);
    month = details::atoi<int>(begin + 4, begin + 6);
    day = details::atoi<int>(begin + 6, begin + 8);
 
    return true;
}
 
 
/*
\brief Internal ascii-to-time conversion with millisecond precision.
 
Parses ascii and returns a time with millisecond precision.
 
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param[out] hour Hour.
\param[out] minute Minute.
\param[out] second Second.
\param[out] millisecond Millisecond.
\return True if successful and the out arguments were set.
*/
inline bool atotime(
    char const* begin,
    char const* end,
    int& hour,
    int& minute,
    int& second,
    int& millisecond
)
{
    if (end - begin != 8 && end - begin != 12) return false;
 
    hour = details::atoi<int>(begin, begin + 2);
    minute = details::atoi<int>(begin + 3, begin + 5);
    second = details::atoi<int>(begin + 6, begin + 8);
 
    if (end - begin == 12)
        millisecond = details::atoi<int>(begin + 9, begin + 12);
    else
        millisecond = 0;
    return true;
}
 
/*
\brief Internal ascii-to-time conversion with nanosecond precision.
 
Parses ascii and returns a time with nanosecond precision.
 
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param[out] hour Hour.
\param[out] minute Minute.
\param[out] second Second.
\param[out] nanosecond Nanosecond.
\return True if successful and the out arguments were set.
*/
inline bool atotime_nano(
    char const* begin,
    char const* end,
    int& hour,
    int& minute,
    int& second,
    int& nanosecond
)
{
    if (end - begin < 8)
        return false;
 
    hour = details::atoi<int>(begin, begin + 2);
    minute = details::atoi<int>(begin + 3, begin + 5);
    second = details::atoi<int>(begin + 6, begin + 8);
 
    switch (end - begin) {
    case 12: nanosecond = details::atoi<int>(begin + 9, begin + 12) * 1000000L; break;
    case 15: nanosecond = details::atoi<int>(begin + 9, begin + 15) * 1000L; break;
    case 18: nanosecond = details::atoi<int>(begin + 9, begin + 18); break;
    default: nanosecond = 0;
    }
    return true;
}
 
#if __cplusplus >= 201103L
/*
\brief SFINAE to check if type is std::chrono::time_point
 
\tparam Clock the clock on which this time point is measured
\tparam Duration a std::chrono::duration type used to measure the time since epoch
*/
template<typename T>
struct is_time_point : std::false_type {};
 
template<typename Clock, typename Duration>
struct is_time_point<std::chrono::time_point<Clock, Duration>> : std::true_type {};
 
/*
\brief Internal ascii-to-timepoint conversion with millisecond precision.
 
Parses ascii and returns a std::chrono::time_point.
 
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param[out] tp time_point.
\return True if successful and the out arguments were set.
*/
template <typename TimePoint>
inline typename std::enable_if<details::is_time_point<TimePoint>::value, bool>::type
atotimepoint(
    char const* begin,
    char const* end,
    TimePoint& tp
)
{
    // TODO: after c++20 this simplifies to
    //       std::chrono::parse("%Y%m%d-%T", tp);
    int year, month, day, hour, minute, second, millisecond;
    if (!atotime(begin + 9, end, hour, minute, second, millisecond))
        return false;
    if (!atodate(begin, begin + 8, year, month, day))
        return false;
 
    // from http://howardhinnant.github.io/date_algorithms.html
    year -= month <= 2;
    const unsigned era = (year >= 0 ? year : year - 399) / 400;
    const unsigned yoe = static_cast<unsigned>(year - era * 400);
    const unsigned doy = (153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1;
    const unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    const unsigned long days_since_epoch = era * 146097 + static_cast<unsigned>(doe) - 719468;
 
    tp = TimePoint(std::chrono::seconds(days_since_epoch * 24 * 3600) +
                   std::chrono::hours(hour) +
                   std::chrono::minutes(minute) +
                   std::chrono::seconds(second) +
                   std::chrono::milliseconds(millisecond));
 
    return true;
}
 
/*
\brief Internal ascii-to-timepoint conversion with nanosecond precision.
 
Parses ascii and returns a std::chrono::time_point.
 
\param begin Pointer to the beginning of the ascii string.
\param end Pointer to past-the-end of the ascii string.
\param[out] tp time_point.
\return True if successful and the out arguments were set.
*/
template <typename TimePoint>
inline typename std::enable_if<details::is_time_point<TimePoint>::value, bool>::type
atotimepoint_nano(
    char const* begin,
    char const* end,
    TimePoint& tp
)
{
    // TODO: after c++20 this simplifies to
    //       std::chrono::parse("%Y%m%d-%T", tp);
    int year, month, day, hour, minute, second, nanosecond;
    if (!atotime_nano(begin + 9, end, hour, minute, second, nanosecond))
        return false;
    if (!atodate(begin, begin + 8, year, month, day))
        return false;
 
    // from http://howardhinnant.github.io/date_algorithms.html
    year -= month <= 2;
    const unsigned era = (year >= 0 ? year : year - 399) / 400;
    const unsigned yoe = static_cast<unsigned>(year - era * 400);
    const unsigned doy = (153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1;
    const unsigned doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    const unsigned long days_since_epoch = era * 146097 + static_cast<unsigned>(doe) - 719468;
 
    tp = TimePoint(std::chrono::seconds(days_since_epoch * 24 * 3600) +
                   std::chrono::hours(hour) +
                   std::chrono::minutes(minute) +
                   std::chrono::seconds(second) +
                   std::chrono::nanoseconds(nanosecond));
 
    return true;
}
 
/*
\brief Internal ascii-to-timepoint conversion with millisecond precision.
 
Parses ascii and returns a std::chrono::time_point.
 
\param tp TimePoint to parse.
\param[out] year Year.
\param[out] month Month.
\param[out] day Day.
\param[out] hour Hour.
\param[out] minute Minute.
\param[out] second Second.
\param[out] millisecond Millisecond.
*/
template <typename TimePoint>
inline typename std::enable_if<details::is_time_point<TimePoint>::value, void>::type
timepointtoparts(TimePoint tp, int& year, int& month, int& day,
                 int& hour, int& minute, int& second, int& millisecond) noexcept
{
    auto epoch_sec = std::chrono::time_point_cast<
        std::chrono::seconds>(tp).time_since_epoch().count();
    auto day_sec = epoch_sec - (epoch_sec % 86400);
    auto days_since_epoch = day_sec / 86400;
 
    // see http://howardhinnant.github.io/date_algorithms.html
    days_since_epoch += 719468;
    const unsigned era = (days_since_epoch >= 0 ? days_since_epoch : days_since_epoch - 146096) / 146097;
    const unsigned doe = static_cast<unsigned>(days_since_epoch - era * 146097);
    const unsigned yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    year = static_cast<unsigned>(yoe) + era * 400;
    const unsigned doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    const unsigned mp = (5 * doy + 2) / 153;
    day = doy - (153 * mp + 2) / 5 + 1;
    month = mp + (mp < 10 ? 3 : -9);
    year += month <= 2;
 
    auto in_day = tp - std::chrono::seconds(day_sec);
    millisecond = std::chrono::time_point_cast<std::chrono::milliseconds>(
            in_day).time_since_epoch().count();
    hour = millisecond / (60 * 60 * 1000);
    millisecond -= hour * 60 * 60 * 1000;
    minute = millisecond / (60 * 1000);
    millisecond -= minute * 60 * 1000;
    second = millisecond / 1000;
    millisecond -= second * 1000;
}
 
/*
\brief Internal ascii-to-timepoint conversion with nanosecond precision.
 
Parses ascii and returns a std::chrono::time_point.
 
\param tp TimePoint to parse.
\param[out] year Year.
\param[out] month Month.
\param[out] day Day.
\param[out] hour Hour.
\param[out] minute Minute.
\param[out] second Second.
\param[out] nanosecond Nanosecond.
*/
template <typename TimePoint>
inline typename std::enable_if<details::is_time_point<TimePoint>::value, void>::type
timepointtoparts_nano(TimePoint tp, int& year, int& month, int& day,
                      int& hour, int& minute, int& second, int& nanosecond) noexcept
{
    auto epoch_sec = std::chrono::time_point_cast<
        std::chrono::seconds>(tp).time_since_epoch().count();
    auto day_sec = epoch_sec - (epoch_sec % 86400);
    auto days_since_epoch = day_sec / 86400;
 
    // see http://howardhinnant.github.io/date_algorithms.html
    days_since_epoch += 719468;
    const unsigned era = (days_since_epoch >= 0 ? days_since_epoch : days_since_epoch - 146096) / 146097;
    const unsigned doe = static_cast<unsigned>(days_since_epoch - era * 146097);
    const unsigned yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    year = static_cast<unsigned>(yoe) + era * 400;
    const unsigned doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    const unsigned mp = (5 * doy + 2) / 153;
    day = doy - (153 * mp + 2) / 5 + 1;
    month = mp + (mp < 10 ? 3 : -9);
    year += month <= 2;
 
    // the math here must be in higher precision, but at the end it fits in an int
    auto in_day = tp - std::chrono::seconds(day_sec);
    long lnanosecond = std::chrono::time_point_cast<std::chrono::nanoseconds>(
            in_day).time_since_epoch().count();
    hour = lnanosecond / (60 * 60 * 1000000000L);
    lnanosecond -= hour * 60 * 60 * 1000000000L;
    minute = lnanosecond / (60 * 1000000000L);
    lnanosecond -= minute * 60 * 1000000000L;
    second = lnanosecond / 1000000000L;
    lnanosecond -= second * 1000000000L;
    nanosecond = static_cast<int>(lnanosecond);
}
#endif
 
} // namespace details
 
/* @endcond*/
 
class message_writer {
public:
 
    message_writer(char* buffer, size_t size):
        buffer_(buffer),
        buffer_end_(buffer + size),
        next_(buffer),
        body_length_(NULL) {
    }
 
    message_writer(char* begin, char* end) :
        buffer_(begin),
        buffer_end_(end),
        next_(begin),
        body_length_(NULL) {
    }
 
    template<size_t N>
    message_writer(char(&buffer)[N]) :
        buffer_(buffer),
        buffer_end_(&(buffer[N])),
        next_(buffer),
        body_length_(NULL) {
    }
 
 
    ~message_writer() {}
 
 
    size_t message_size() const {
        return next_ - buffer_;
    }
 
    char* message_begin() const {
        return buffer_;
    }
    char* message_end() const {
        return next_;
    }
 
    size_t buffer_size() const {
        return buffer_end_ - buffer_;
    }
 
    size_t buffer_size_remaining() const {
        return buffer_end_ - next_;
    }
 
 
 
    void push_back_header(char const* begin_string_version) {
        if (body_length_) throw std::logic_error("hffix message_writer.push_back_header called twice");
        if (buffer_end_ - next_ < 2 + std::ptrdiff_t(strlen(begin_string_version)) + 3 + 7) {
            details::throw_range_error();
        }
        memcpy(next_, "8=", 2);
        next_ += 2;
        memcpy(next_, begin_string_version, std::strlen(begin_string_version));
        next_ += std::strlen(begin_string_version);
        *(next_++) = '\x01';
        memcpy(next_, "9=", 2);
        next_ += 2;
        body_length_ = next_;
        next_ += 6; // 6 characters reserved for BodyLength.
        *next_++ = '\x01';
    }
 
#if __cplusplus >= 201703L
    void push_back_header(std::string_view begin_string_version) {
        if (body_length_) throw std::logic_error("hffix message_writer.push_back_header called twice");
        if (buffer_end_ - next_ < 2 + std::ptrdiff_t(begin_string_version.size()) + 3 + 7) {
            details::throw_range_error();
        }
        memcpy(next_, "8=", 2);
        next_ += 2;
        memcpy(next_, begin_string_version.data(), begin_string_version.size());
        next_ += begin_string_version.size();
        *(next_++) = '\x01';
        memcpy(next_, "9=", 2);
        next_ += 2;
        body_length_ = next_;
        next_ += 6; // 6 characters reserved for BodyLength.
        *next_++ = '\x01';
    }
#endif
 
    void push_back_trailer(bool calculate_checksum = true) {
        // Calculate and write out the BodyLength.
        // BodyLength does not include the SOH character after the BodyLength field.
        // BodyLength does not include the SOH character before the CheckSum field.
        if (!body_length_) {
            throw std::logic_error("hffix message_writer.push_back_trailer called before message_writer.push_back_header");
        }
 
        size_t const len = next_ - (body_length_ + 7);
        body_length_[0] = '0' + (len / 100000) % 10;
        body_length_[1] = '0' + (len / 10000) % 10;
        body_length_[2] = '0' + (len / 1000) % 10;
        body_length_[3] = '0' + (len / 100) % 10;
        body_length_[4] = '0' + (len / 10) % 10;
        body_length_[5] = '0' + len % 10;
 
        if (buffer_end_ - next_ < 7) {
            details::throw_range_error();
        }
 
        // write out the CheckSum after optionally calculating it
        if (calculate_checksum) {
#if __cplusplus >= 201103L
            using std::uint8_t;
#else
            typedef unsigned char uint8_t;
#endif
            uint8_t const checksum = std::accumulate(buffer_, next_, uint8_t(0));
 
            memcpy(next_, "10=", 3);
            next_ += 3;
            next_[0] = '0' + ((checksum / 100) % 10);
            next_[1] = '0' + ((checksum / 10) % 10);
            next_[2] = '0' + (checksum % 10);
 
            next_ += 3;
            *next_++ = '\x01';
        } else {
            memcpy(next_, "10=000\x01", 7);
            next_ += 7;
        }
 
    }
 
 
 
    void push_back_string(int tag, char const* begin, char const* end) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < (end - begin) + 2) {
            details::throw_range_error();
        }
        *next_++ = '=';
        memcpy(next_, begin, end - begin);
        next_ += (end - begin);
        *next_++ = '\x01';
    }
 
    void push_back_string(int tag, char const* cstring) {
        // Find the end of the cstring, like strlen, but throw if the cstring
        // is longer than the remaining buffer.
        char const* cstring_end = (char const*)memchr(cstring, 0, buffer_end_ - next_);
        if (cstring_end) push_back_string(tag, cstring, cstring_end);
        else details::throw_range_error();
    }
 
    void push_back_string(int tag, std::string const& s) {
        push_back_string(tag, s.data(), s.data() + s.size());
    }
 
 
#if __cplusplus >= 201703L
    void push_back_string(int tag, std::string_view s) {
        push_back_string(tag, s.data(), s.data() + s.length());
    }
#endif
 
    void push_back_char(int tag, char character) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < 3) {
            details::throw_range_error();
        }
        *next_++ = '=';
        *next_++ = character;
        *next_++ = '\x01';
    }
 
    template<typename Int_type> void push_back_int(int tag, Int_type number) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (next_ >= buffer_end_) details::throw_range_error();
        *next_++ = '=';
        next_ = details::itoa(number, next_, buffer_end_);
        if (next_ >= buffer_end_) details::throw_range_error();
        *next_++ = '\x01';
    }
 
 
 
    template<typename Int_type> void push_back_decimal(int tag, Int_type mantissa, Int_type exponent) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (next_ >= buffer_end_) details::throw_range_error();
        *next_++ = '=';
        next_ = details::dtoa(mantissa, exponent, next_, buffer_end_);
        if (next_ >= buffer_end_) details::throw_range_error();
        *next_++ = '\x01';
    }
 
 
 
    void push_back_date(int tag, int year, int month, int day) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=YYYYMMDD|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(year, next_, next_ + 4);
        next_ += 4;
        itoa_padded(month, next_, next_ + 2);
        next_ += 2;
        itoa_padded(day, next_, next_ + 2);
        next_ += 2;
        *next_++ = '\x01';
    }
    void push_back_monthyear(int tag, int year, int month) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=YYYYMM|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(year, next_, next_ + 4);
        next_ += 4;
        itoa_padded(month, next_, next_ + 2);
        next_ += 2;
        *next_++ = '\x01';
    }
 
    void push_back_timeonly(int tag, int hour, int minute, int second) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=HH:MM:SS|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '\x01';
    }
 
    void push_back_timeonly(int tag, int hour, int minute, int second, int millisecond) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=HH:MM:SS.sss|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '.';
        itoa_padded(millisecond, next_, next_ + 3);
        next_ += 3;
        *next_++ = '\x01';
    }
 
    void push_back_timeonly_nano(int tag, int hour, int minute, int second, int nanosecond) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=HH:MM:SS.sssssssss|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '.';
        itoa_padded(nanosecond, next_, next_ + 9);
        next_ += 9;
        *next_++ = '\x01';
    }
 
    void push_back_timestamp(int tag, int year, int month, int day, int hour, int minute, int second) {
        next_ = details::itoa(tag, next_, buffer_end_);
 
        if (buffer_end_ - next_ < details::len("=YYYYMMDD-HH:MM:SS|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(year, next_, next_ + 4);
        next_ += 4;
        itoa_padded(month, next_, next_ + 2);
        next_ += 2;
        itoa_padded(day, next_, next_ + 2);
        next_ += 2;
        *next_++ = '-';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '\x01';
    }
 
    void push_back_timestamp(int tag, int year, int month, int day, int hour, int minute, int second, int millisecond) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=YYYYMMDD-HH:MM:SS.sss|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(year, next_, next_ + 4);
        next_ += 4;
        itoa_padded(month, next_, next_ + 2);
        next_ += 2;
        itoa_padded(day, next_, next_ + 2);
        next_ += 2;
        *next_++ = '-';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '.';
        itoa_padded(millisecond, next_, next_ + 3);
        next_ += 3;
        *next_++ = '\x01';
    }
 
    void push_back_timestamp_nano(int tag, int year, int month, int day, int hour, int minute, int second, int nanosecond) {
        next_ = details::itoa(tag, next_, buffer_end_);
        if (buffer_end_ - next_ < details::len("=YYYYMMDD-HH:MM:SS.sssssssss|")) {
            details::throw_range_error();
        }
        *next_++ = '=';
        itoa_padded(year, next_, next_ + 4);
        next_ += 4;
        itoa_padded(month, next_, next_ + 2);
        next_ += 2;
        itoa_padded(day, next_, next_ + 2);
        next_ += 2;
        *next_++ = '-';
        itoa_padded(hour, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(minute, next_, next_ + 2);
        next_ += 2;
        *next_++ = ':';
        itoa_padded(second, next_, next_ + 2);
        next_ += 2;
        *next_++ = '.';
        itoa_padded(nanosecond, next_, next_ + 9);
        next_ += 9;
        *next_++ = '\x01';
    }
 
#ifdef HFFIX_BOOST_DATETIME
 
 
    void push_back_date(int tag, boost::gregorian::date date) {
        if (!date.is_not_a_date())
            push_back_date(tag, date.year(), date.month(), date.day());
    }
 
    void push_back_timeonly(int tag, boost::posix_time::time_duration timeonly) {
        if (!timeonly.is_not_a_date_time())
            push_back_timeonly(
                tag,
                timeonly.hours(),
                timeonly.minutes(),
                timeonly.seconds(),
                static_cast<int>(timeonly.fractional_seconds() * 1000 / boost::posix_time::time_duration::ticks_per_second())
            );
    }
 
    void push_back_timeonly_nano(int tag, boost::posix_time::time_duration timeonly) {
        if (!timeonly.is_not_a_date_time())
            push_back_timeonly_nano(
                tag,
                timeonly.hours(),
                timeonly.minutes(),
                timeonly.seconds(),
                static_cast<int>(timeonly.fractional_seconds() * 1000000000L / boost::posix_time::time_duration::ticks_per_second())
            );
    }
 
    void push_back_timestamp(int tag, boost::posix_time::ptime timestamp) {
        if (!timestamp.is_not_a_date_time())
            push_back_timestamp(
                tag,
                timestamp.date().year(),
                timestamp.date().month(),
                timestamp.date().day(),
                timestamp.time_of_day().hours(),
                timestamp.time_of_day().minutes(),
                timestamp.time_of_day().seconds(),
                static_cast<int>(timestamp.time_of_day().fractional_seconds() * 1000 / boost::posix_time::time_duration::ticks_per_second())
            );
        else
            throw std::logic_error("push_back_timestamp called with not_a_date_time.");
    }
 
    void push_back_timestamp_nano(int tag, boost::posix_time::ptime timestamp) {
        if (!timestamp.is_not_a_date_time())
            push_back_timestamp_nano(
                tag,
                timestamp.date().year(),
                timestamp.date().month(),
                timestamp.date().day(),
                timestamp.time_of_day().hours(),
                timestamp.time_of_day().minutes(),
                timestamp.time_of_day().seconds(),
                static_cast<int>(timestamp.time_of_day().fractional_seconds() * 1000000000L / boost::posix_time::time_duration::ticks_per_second())
            );
        else
            throw std::logic_error("push_back_timestamp_nano called with not_a_date_time.");
    }
#endif // HFFIX_BOOST_DATETIME
 
#if __cplusplus >= 201103L
 
    template<typename Clock, typename Duration>
    void push_back_timestamp(int tag, std::chrono::time_point<Clock,Duration> tp) {
        // TODO: with c++20, we can use std::chrono::format
        int year, month, day, hour, minute, second, millisecond;
        details::timepointtoparts(tp, year, month, day, hour, minute, second, millisecond);
        push_back_timestamp(tag, year, month, day, hour, minute, second, millisecond);
    }
 
    template<typename Clock, typename Duration>
    void push_back_timestamp_nano(int tag, std::chrono::time_point<Clock,Duration> tp) {
        // TODO: with c++20, we can use std::chrono::format
        int year, month, day, hour, minute, second, nanosecond;
        details::timepointtoparts_nano(tp, year, month, day, hour, minute, second, nanosecond);
        push_back_timestamp_nano(tag, year, month, day, hour, minute, second, nanosecond);
    }
 
    template<typename Rep, typename Period>
    void push_back_timeonly(int tag, std::chrono::duration<Rep,Period> timeonly) {
        using namespace std::chrono;
 
        push_back_timeonly(
            tag,
            duration_cast<hours>       (timeonly).count(),
            duration_cast<minutes>     (timeonly %   hours(1)).count(),
            duration_cast<seconds>     (timeonly % minutes(1)).count(),
            duration_cast<milliseconds>(timeonly % seconds(1)).count()
            );
    }
 
    template<typename Rep, typename Period>
    void push_back_timeonly_nano(int tag, std::chrono::duration<Rep,Period> timeonly) {
        using namespace std::chrono;
 
        push_back_timeonly_nano(
            tag,
            duration_cast<hours>      (timeonly).count(),
            duration_cast<minutes>    (timeonly %   hours(1)).count(),
            duration_cast<seconds>    (timeonly % minutes(1)).count(),
            duration_cast<nanoseconds>(timeonly % seconds(1)).count()
            );
    }
#endif
 
 
 
    void push_back_data(int tag_data_length, int tag_data, char const* begin, char const* end) {
        next_ = details::itoa(tag_data_length, next_, buffer_end_);
        if (next_ == buffer_end_) details::throw_range_error();
        *next_++ = '=';
        next_ = details::itoa(end - begin, next_, buffer_end_);
        if (next_ == buffer_end_) details::throw_range_error();
        *next_++ = '\x01';
        next_ = details::itoa(tag_data, next_, buffer_end_);
 
        if (buffer_end_ - next_ < (end - begin) + 2) {
            details::throw_range_error();
        }
        *next_++ = '=';
        memcpy(next_, begin, end - begin);
        next_ += end - begin;
        *next_++ = '\x01';
    }
 
 
private:
    static void itoa_padded(int x, char* b, char* e) {
        while (e > b) {
            *--e = '0' + (x % 10);
            x /= 10;
        }
    }
 
    char* buffer_;
    char* buffer_end_;
    char* next_;
    char* body_length_; // Pointer to the location at which the BodyLength should be written, once the length of the message is known. 6 chars, which allows for messagelength up to 999,999.
};
 
class message_reader;
class message_reader_const_iterator;
 
class field_value {
public:
 
    char const* begin() const {
        return begin_;
    }
 
    char const* end() const {
        return end_;
    }
 
    size_t size() const {
        return end_ - begin_;
    }
 
 
    inline friend bool operator==(field_value const& that, char const* cstring) {
        return !strncmp(that.begin(), cstring, that.size()) && !cstring[that.size()];
        // TODO Is this correct? Maybe getting too fancy here trying to avoid call to strlen.
    }
 
    inline friend bool operator==(char const* cstring, field_value const& that) {
        return that == cstring;
    }
 
    inline friend bool operator!=(field_value const& that, char const* cstring) {
        return !(that == cstring);
    }
 
    inline friend bool operator!=(char const* cstring, field_value const& that) {
        return !(that == cstring);
    }
 
    inline friend bool operator==(field_value const& that, std::string const& s) {
        return that.size() == s.size() && !strncmp(that.begin(), s.data(), that.size());
    }
 
    inline friend bool operator==(std::string const& s, field_value const& that) {
        return that == s;
    }
 
    inline friend bool operator!=(field_value const& that, std::string const& s) {
        return !(that == s);
    }
 
    inline friend bool operator!=(std::string const& s, field_value const& that) {
        return !(that == s);
    }
 
#if __cplusplus >= 201703L
    inline friend bool operator==(field_value const& that, std::string_view s) {
        return std::equal(that.begin(), that.end(), s.begin(), s.end());
    }
 
    inline friend bool operator==(std::string_view s, field_value const& that) {
        return that == s;
    }
 
    inline friend bool operator!=(field_value const& that, std::string_view s) {
        return !(that == s);
    }
 
    inline friend bool operator!=(std::string_view s, field_value const& that) {
        return !(that == s);
    }
#endif
 
    friend std::ostream& operator<<(std::ostream& os, field_value const& that) {
        return os.write(that.begin(), that.size());
    }
 
 
    std::string as_string() const {
        return std::string(begin(), end());
    }
 
#if __cplusplus >= 201703L
    std::string_view as_string_view() const {
        return std::string_view(begin(), size());
    }
#endif
 
    char as_char() const {
        return *begin();
    }
 
 
 
 
    template<typename Int_type> void as_decimal(Int_type& mantissa, Int_type& exponent) const {
        details::atod<Int_type>(begin(), end(), mantissa, exponent);
    }
 
private:
    template <typename Int_type, bool Is_signed_integer>
    struct as_int_selector {
    };
 
    template <typename Int_type>
    struct as_int_selector<Int_type, true> {
        static Int_type call_as_int(char const* begin, char const* end) {
            return details::atoi<Int_type>(begin, end);
        }
    };
 
    template <typename Int_type>
    struct as_int_selector<Int_type, false> {
        static Int_type call_as_int(char const* begin, char const* end) {
            return details::atou<Int_type>(begin, end);
        }
    };
 
public:
 
 
    template<typename Int_type> Int_type as_int() const {
        return as_int_selector<Int_type, std::numeric_limits<Int_type>::is_signed>::call_as_int(begin(), end());
    }
 
 
 
    bool as_date(
        int& year,
        int& month,
        int& day
    ) const {
        return details::atodate(begin(), end(), year, month, day);
    }
 
 
    bool as_monthyear(
        int& year,
        int& month
    ) const {
        if (end() - begin() != 6) return false;
 
        year = details::atoi<int>(begin(), begin() + 4);
        month = details::atoi<int>(begin() + 4, begin() + 6);
 
        return true;
    }
 
 
    bool as_timeonly(
        int& hour,
        int& minute,
        int& second,
        int& millisecond
    ) const {
        return details::atotime(begin(), end(), hour, minute, second, millisecond);
    }
 
    bool as_timeonly_nano(
        int& hour,
        int& minute,
        int& second,
        int& nanosecond
    ) const {
        return details::atotime_nano(begin(), end(), hour, minute, second, nanosecond);
    }
 
    bool as_timestamp(
        int& year,
        int& month,
        int& day,
        int& hour,
        int& minute,
        int& second,
        int& millisecond
    ) const {
        return
            details::atotime(begin() + 9, end(), hour, minute, second, millisecond)
            && details::atodate(begin(), begin() + 8, year, month, day); // take advantage of short-circuit && to check field length
    }
 
    bool as_timestamp_nano(
        int& year,
        int& month,
        int& day,
        int& hour,
        int& minute,
        int& second,
        int& nanosecond
    ) const {
        return
            details::atotime_nano(begin() + 9, end(), hour, minute, second, nanosecond)
            && details::atodate(begin(), begin() + 8, year, month, day); // take advantage of short-circuit && to check field length
    }
 
 
#ifdef HFFIX_BOOST_DATETIME
 
 
    boost::gregorian::date as_date() const {
        int year, month, day;
        if (as_date(year, month, day)) {
            try {
                return boost::gregorian::date(year, month, day);
            } catch(std::exception& ex) {
                return boost::gregorian::date(boost::posix_time::not_a_date_time);
            }
        } else
            return boost::gregorian::date(boost::posix_time::not_a_date_time);
    }
 
    boost::posix_time::time_duration as_timeonly() const {
        int hour, minute, second, millisecond;
        if (as_timeonly(hour, minute, second, millisecond)) {
            try {
                return boost::posix_time::time_duration(hour, minute, second, boost::posix_time::time_duration::ticks_per_second() * millisecond / 1000);
            } catch(std::exception& ex) {
                return boost::posix_time::time_duration(boost::posix_time::not_a_date_time);
            }
        } else
            return boost::posix_time::time_duration(boost::posix_time::not_a_date_time);
    }
 
    boost::posix_time::time_duration as_timeonly_nano() const {
        int hour, minute, second, nanosecond;
        if (as_timeonly_nano(hour, minute, second, nanosecond)) {
            try {
                return boost::posix_time::time_duration(hour, minute, second, boost::posix_time::time_duration::ticks_per_second() * nanosecond / 1000000000L);
            } catch(std::exception& ex) {
                return boost::posix_time::time_duration(boost::posix_time::not_a_date_time);
            }
        } else
            return boost::posix_time::time_duration(boost::posix_time::not_a_date_time);
    }
 
    boost::posix_time::ptime as_timestamp() const {
        int year, month, day, hour, minute, second, millisecond;
 
        if (details::atotime(begin() + 9, end(), hour, minute, second, millisecond)
                && details::atodate(begin(), begin() + 8, year, month, day)) {
            try {
                return boost::posix_time::ptime(
                           boost::gregorian::date(year, month, day),
                           boost::posix_time::time_duration(hour, minute, second, boost::posix_time::time_duration::ticks_per_second() * millisecond / 1000)
                       );
            } catch(std::exception& ex) {
                return boost::posix_time::not_a_date_time;
            }
        } else
            return boost::posix_time::not_a_date_time;
    }
 
    boost::posix_time::ptime as_timestamp_nano() const {
        int year, month, day, hour, minute, second, nanosecond;
 
        if (details::atotime_nano(begin() + 9, end(), hour, minute, second, nanosecond)
                && details::atodate(begin(), begin() + 8, year, month, day)) {
            try {
                return boost::posix_time::ptime(
                           boost::gregorian::date(year, month, day),
                           boost::posix_time::time_duration(hour, minute, second, boost::posix_time::time_duration::ticks_per_second() * nanosecond / 1000000000L)
                       );
            } catch(std::exception& ex) {
                return boost::posix_time::not_a_date_time;
            }
        } else
            return boost::posix_time::not_a_date_time;
    }
 
 
#endif // HFFIX_BOOST_DATETIME
 
#if __cplusplus >= 201103L
 
    template<typename Clock, typename Duration>
    bool as_timestamp(std::chrono::time_point<Clock,Duration>& tp) const {
        if (details::atotimepoint(begin(), end(), tp))
            return true;
        else
            return false;
    }
 
    template<typename Clock, typename Duration>
    bool as_timestamp_nano(std::chrono::time_point<Clock,Duration>& tp) const {
        if (details::atotimepoint_nano(begin(), end(), tp))
            return true;
        else
            return false;
    }
 
    template<typename Rep, typename Period>
    bool as_timeonly(std::chrono::duration<Rep,Period>& dur) const {
        int hour, minute, second, millisecond;
        if (as_timeonly(hour, minute, second, millisecond)) {
            dur = std::chrono::hours(hour) +
                  std::chrono::minutes(minute) +
                  std::chrono::seconds(second) +
                  std::chrono::milliseconds(millisecond);
            return true;
        }
        else
            return false;
    }
 
    template<typename Rep, typename Period>
    bool as_timeonly_nano(std::chrono::duration<Rep,Period>& dur) const {
        int hour, minute, second, nanosecond;
        if (as_timeonly_nano(hour, minute, second, nanosecond)) {
            dur = std::chrono::hours(hour) +
                  std::chrono::minutes(minute) +
                  std::chrono::seconds(second) +
                  std::chrono::nanoseconds(nanosecond);
            return true;
        }
        else
            return false;
    }
#endif
 
 
private:
    friend class field;
    friend class message_reader_const_iterator;
    friend class message_reader;
    char const* begin_;
    char const* end_;
};
 
class field {
public:
 
    int tag() const {
        return tag_;
    }
 
    field_value const& value() const {
        return value_;
    }
 
    friend std::ostream& operator<<(std::ostream& os, field const& that) {
        os << that.tag_ << "=";
        return os.write(that.value_.begin(), that.value_.size());
    }
 
private:
    friend class message_reader_const_iterator;
    friend class message_reader;
    int tag_;
    field_value value_;
};
 
class message_reader_const_iterator {
 
public:
 
    message_reader_const_iterator() {}
private:
 
    message_reader_const_iterator(message_reader const& container, char const* buffer) :
        message_reader_(&container),
        buffer_(buffer),
        current_() {
    }
 
public:
 
    typedef ::std::input_iterator_tag iterator_category;
    typedef field value_type;
    typedef std::ptrdiff_t difference_type;
    typedef field* pointer;
    typedef field& reference;
 
 
    field const& operator*() const {
        return current_;
    }
 
    field const* operator->() const {
        return &current_;
    }
 
 
    friend bool operator==(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ == b.buffer_;
    }
 
    friend bool operator!=(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ != b.buffer_;
    }
 
    friend bool operator<(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ < b.buffer_;
    }
 
    friend bool operator>(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ > b.buffer_;
    }
 
    friend bool operator<=(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ <= b.buffer_;
    }
 
    friend bool operator>=(message_reader_const_iterator const& a, message_reader_const_iterator const& b) {
        return a.buffer_ >= b.buffer_;
    }
 
    message_reader_const_iterator operator++(int) {
        message_reader_const_iterator i(*this);
        ++(*this);
        return i;
    }
 
    message_reader_const_iterator& operator++() {
        increment();
        return *this;
    }
 
    friend message_reader_const_iterator operator+(message_reader_const_iterator a, int addend) {
        if (addend < 0) throw std::logic_error("message_reader::const_iterator is a Forward Iterator, so only positive addends are allowed.");
        for (int i = 0; i < addend; ++i)
            ++a;
 
        return a;
    }
 
 
    friend message_reader_const_iterator operator+(int addend, message_reader_const_iterator a) {
        return a + addend;
    }
 
private:
    friend class message_reader;
    message_reader const* message_reader_; // pointer to the message_reader for this iterator
    char const* buffer_; // pointer to the first character of the ascii tag number for the current_ field
    field current_;
 
    void increment();
};
 
 
struct tag_equal {
    tag_equal(int tag) : tag(tag) {}
    int tag;
    bool operator()(field const& v) const {
        return v.tag() == tag;
    }
};
 
 
template <typename ForwardIterator, typename UnaryPredicate>
inline bool find_with_hint(ForwardIterator begin, ForwardIterator end, UnaryPredicate predicate, ForwardIterator & i) {
    ForwardIterator j = std::find_if(i, end, predicate);
    if (j != end) {
        i = j;
        return true;
    }
    j = std::find_if(begin, i, predicate);
    if (j != i) {
        i = j;
        return true;
    }
    return false;
}
 
 
class message_reader {
 
public:
 
    typedef field value_type;
    typedef field const& const_reference;
    typedef message_reader_const_iterator const_iterator;
    typedef field const* const_pointer;
    typedef size_t size_type;
 
    message_reader(char const* buffer, size_t size) :
        buffer_(buffer),
        buffer_end_(buffer + size),
        begin_(*this, 0),
        end_(*this, 0),
        is_complete_(false),
        is_valid_(true) {
        init();
    }
 
    message_reader(char const* begin, char const* end) :
        buffer_(begin),
        buffer_end_(end),
        begin_(*this, 0),
        end_(*this, 0),
        is_complete_(false),
        is_valid_(true) {
        init();
    }
 
    message_reader(message_reader const& that) :
        buffer_(that.buffer_),
        buffer_end_(that.buffer_end_),
        begin_(*this, 0),
        end_(*this, 0),
        is_complete_(that.is_complete_),
        is_valid_(that.is_valid_) {
        init();
    }
 
    message_reader& operator = (const message_reader& that)
    {
        buffer_= that.buffer_;
        buffer_end_ = that.buffer_end_;
        // This can't be the default assignment operator because begin_ and end_ are const_iterators which
        // point back to 'this'. If we copy them as is they will point back to the previous 'that'.
        begin_ = const_iterator(*this, 0);
        end_ = const_iterator(*this, 0);
        is_complete_ = that.is_complete_;
        is_valid_ = that.is_valid_;
        init();
        return *this;
    }
 
    message_reader(message_writer const& that) :
        buffer_(that.message_begin()),
        buffer_end_(that.message_end()),
        begin_(*this, 0),
        end_(*this, 0),
        is_complete_(false),
        is_valid_(true) {
        init();
    }
 
    template<size_t N>
    message_reader(const char(&buffer)[N]) :
        buffer_(buffer),
        buffer_end_(&(buffer[N])),
        begin_(*this, 0),
        end_(*this, 0),
        is_complete_(false),
        is_valid_(true) {
        init();
    }
 
    ~message_reader() {
    }
 
    bool is_complete() const {
        return is_complete_;
    }
    bool is_valid() const {
        return is_valid_;
    }
 
 
    message_reader next_message_reader() const {
        if (!is_complete_) {
            throw std::logic_error("Can't call next_message_reader on an incomplete message.");
        }
 
        if (!is_valid_) { // this message isn't valid, so we have to try to search for the beginning of the next message.
            char const* b = buffer_ + 1;
            while(b < buffer_end_ - 10) {
                if (!std::memcmp(b, "8=FIX", 5))
                    break;
                ++b;
            }
            return message_reader(b, buffer_end_);
        }
 
        return message_reader(end_.current_.value_.end_ + 1, buffer_end_);
    }
 
    unsigned char calculate_check_sum() {
        // return iterator for beginning of nonmutable sequence
        if (!is_valid_) throw std::logic_error("hffix Cannot calculate checksum for an invalid message.");
        return std::accumulate(buffer_, end_.buffer_, (unsigned char)(0));
    }
 
    const_iterator begin() const {
        // return iterator for beginning of nonmutable sequence
        if (!is_valid_) throw std::logic_error("hffix Cannot return iterator for an invalid message.");
        return begin_;
    }
 
    const_iterator end() const {
        // return iterator for end of nonmutable sequence
        if (!is_valid_) throw std::logic_error("hffix Cannot return iterator for an invalid message.");
        return end_;
    }
 
    const_iterator message_type() const {
        // return iterator for beginning of nonmutable sequence
        if (!is_valid_) throw std::logic_error("hffix Cannot return iterator for an invalid message.");
        return begin_;
    }
 
    const_iterator check_sum() const {
        // return iterator for end of nonmutable sequence
        if (!is_valid_) throw std::logic_error("hffix Cannot return iterator for an invalid message.");
        return end_;
    }
 
    char const* prefix_begin() const {
        return buffer_ + 2;
    }
 
    char const* prefix_end() const {
        return prefix_end_;
    }
 
    size_t prefix_size() const {
        return prefix_end_ - buffer_ - 2;
    }
 
    bool find_with_hint(int tag, const_iterator& i) const {
        return hffix::find_with_hint(begin(), end(), tag_equal(tag), i);
    }
 
 
 
    char const* buffer_begin() const {
        return buffer_;
    }
    char const* buffer_end() const {
        return buffer_end_;
    }
 
    size_t buffer_size() const {
        return buffer_end_ - buffer_;
    }
 
    char const* message_begin() const {
        return buffer_;
    }
    char const* message_end() const {
        if (!is_valid_) throw std::logic_error("hffix Cannot determine size of an invalid message.");
        return end_.current_.value_.end_ + 1;
    }
 
    size_t message_size() const {
        if (!is_valid_) throw std::logic_error("hffix Cannot determine size of an invalid message.");
        return end_.current_.value_.end_ - buffer_ + 1;
    }
 
 
private:
    friend class message_reader_const_iterator;
 
    void init() {
 
        // Skip the version prefix string "8=FIX.4.2" or "8=FIXT.1.1", et cetera.
        char const* b = buffer_ + 9; // look for the first '\x01'
 
        while(true) {
            if (b >= buffer_end_) {
                is_complete_ = false;
                return;
            }
            if (*b == '\x01') {
                prefix_end_ = b;
                break;
            }
            if (b - buffer_ > 11) {
                invalid();
                return;
            }
            ++b;
        }
 
        if (b + 1 >= buffer_end_) {
            is_complete_ = false;
            return;
        }
        if (b[1] != '9') { // next field must be tag 9 BodyLength
            invalid();
            return;
        }
        b += 3; // skip the " 9=" for tag 9 BodyLength
 
        size_t bodylength(0); // the value of tag 9 BodyLength
 
        while(true) {
            if (b >= buffer_end_) {
                is_complete_ = false;
                return;
            }
            if (*b == '\x01') break;
            if (*b < '0' || *b > '9') { // this is the only time we need to check for numeric ascii.
                invalid();
                return;
            }
            bodylength *= 10;
            bodylength += *b++ - '0'; // we know that 0 <= (*b - '0') <= 9, so rvalue will be positive.
        }
 
        ++b;
        if (b + 3 >= buffer_end_) {
            is_complete_ = false;
            return;
        }
 
        if (*b != '3' || b[1] != '5') { // next field must be tag 35 MsgType
            invalid();
            return;
        }
 
        char const* checksum = b + bodylength;
 
        if (checksum + 7 > buffer_end_) {
            is_complete_ = false;
            return;
        }
 
        if (*(checksum - 1) != '\x01') { // check for SOH before the checksum.
                                         // this guarantees that at least
                                         // there is one SOH in the message
                                         // which will prevent us from
                                         // falling off of the end of
                                         // a malformed message while
                                         // iterating.
            invalid();
            return;
        }
 
        if (*(checksum + 6) != '\x01') { // check for trailing SOH
            invalid();
            return;
        }
 
        begin_.buffer_ = b;
        begin_.current_.tag_ = 35; // MsgType
        b += 3;
        begin_.current_.value_.begin_ = b;
        while(*++b != '\x01') {
            if (b >= checksum) {
                invalid();
                return;
            }
        }
        begin_.current_.value_.end_ = b;
 
        end_.buffer_ = checksum;
        end_.current_.tag_ = 10; //CheckSum
        end_.current_.value_.begin_ = checksum + 3;
        end_.current_.value_.end_ = checksum + 6;
 
        is_complete_ = true;
    }
 
    char const* buffer_;
    char const* buffer_end_;
    const_iterator begin_;
    const_iterator end_;
    bool is_complete_;
    bool is_valid_;
    char const* prefix_end_; // Points after the 8=FIX... Prefix field.
 
    void invalid() {
        is_complete_ = true; // invalid messages are considered complete, for use of the message_reader::operator++()
        is_valid_ = false;
    }
};
 
 
namespace details {
bool is_tag_a_data_length(int tag);
}
inline void message_reader_const_iterator::increment()
{
    buffer_ = current_.value_.end_ + 1;
    current_.value_.begin_ = buffer_;
    current_.tag_ = 0;
 
    while(*current_.value_.begin_ != '=' && *current_.value_.begin_ != '\x01') {
        current_.tag_ *= 10;
        current_.tag_ += (*current_.value_.begin_ - '0');
        ++current_.value_.begin_;
    }
 
    // we expect to see a '='. if we see a '\x01' at this point then this field
    // has no value and the message is invalid, so we're doomed. it's too
    // late to set is_invalid, though, so let's just say that this field
    // has a null value.
    if (*current_.value_.begin_ == '\x01') {
        current_.value_.end_ = current_.value_.begin_;
        return;
    }
 
    // move past the '='.
    ++current_.value_.begin_;
 
    // find the end of the field value
    current_.value_.end_ = std::find(current_.value_.begin_, message_reader_->message_end(), '\x01');
    if (details::is_tag_a_data_length(current_.tag_)) {
        size_t data_len = details::atou<size_t>(current_.value_.begin_, current_.value_.end_);
 
        buffer_ = current_.value_.end_ + 1;
        current_.value_.begin_ = buffer_;
        current_.tag_ = 0;
 
        while(*current_.value_.begin_ != '=') {
            current_.tag_ *= 10;
            current_.tag_ += (*current_.value_.begin_ - '0');
            ++current_.value_.begin_;
        }
 
        current_.value_.end_ = ++current_.value_.begin_ + data_len;
    }
}
 
/* @cond EXCLUDE */
 
namespace details {
 
 
// A predicate constructed with an int which returns true if the int passed to
// the predicate is greater than or equal to the int passed to the constructor.
struct int_gte {
    int_gte(int tag) : tag(tag) {}
    int tag;
    bool operator()(int that) const {
        return that >= tag;
    }
};
 
// Returns true if the argument exists in the length_fields array.
//
// We have to call this function every time a message_reader iterator
// is incremented, so we want it to be fast.
//
// Instead of doing std::binary_search on the sorted range of length_fields,
// we'll take advantage of an assumption that most tags are low-numbered
// tags, and search from the beginning of length_fields, hoping that
// our search will usually end quickly.
//
// TODO: This has not yet been benchmarked against any alternatives.
// The benchmark results would depend on the distrubution of tags
// in the FIX data set.
inline bool is_tag_a_data_length(int tag)
{
    int* length_fields_end = length_fields + (sizeof(length_fields)/sizeof(length_fields[0]));
    int* i = std::find_if(length_fields, length_fields_end, int_gte(tag));
    if (i == length_fields_end) return false;
    return (*i == tag);
}
 
// \brief std::ostream-able type returned by hffix::field_name function.
template <typename AssociativeContainer> struct field_name_streamer {
    int tag;
    AssociativeContainer const& field_dictionary;
    bool number_alternative;
 
    field_name_streamer(int tag, AssociativeContainer const& field_dictionary, bool number_alternative) : tag(tag), field_dictionary(field_dictionary), number_alternative(number_alternative) {}
 
    friend std::ostream& operator<<(std::ostream& os, field_name_streamer that) {
        typename AssociativeContainer::const_iterator i = that.field_dictionary.find(that.tag);
        if (i != that.field_dictionary.end())
            os << i->second;
        else if (that.number_alternative)
            os << that.tag;
        return os;
    }
};
 
}
/* @endcond */
 
template <typename AssociativeContainer> details::field_name_streamer<AssociativeContainer> field_name(int tag, AssociativeContainer const& field_dictionary, bool or_number = true)
{
    return details::field_name_streamer<AssociativeContainer>(tag, field_dictionary, or_number);
}
 
} // namespace hffix
 
#endif