#include <iostream>
#include <iterator>
#include <string>
#include <vector>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix.hpp>

namespace karma = boost::spirit::karma;

typedef char byte;
typedef std::back_insert_iterator<std::string> Iterator;
typedef unsigned int size_type;
typedef   signed int integer;

int
main (int argc, char *argv[])
{
  size_type size_;

  karma::rule< Iterator, std::vector<byte> >  pascal_string_;
  karma::rule< Iterator, size_type >          pascal_string_size_;
  karma::rule< Iterator, std::vector<byte> >  pascal_string_payload_;
  karma::rule< Iterator >                     pascal_string_padding_;

  namespace ascii = karma::ascii;
  using boost::phoenix::ref;
  using karma::_val;
  using karma::_1;

  pascal_string_ %=
    pascal_string_size_         // [ _1 = _val.size () ]
    << pascal_string_payload_
    << pascal_string_padding_
    ;

  pascal_string_size_ %=
    karma::eps (_val <= 0xFFF)  // guard clause
    << karma::char_('h')
    << ascii::upper [ karma::right_align (3, '0')
                      [ karma::int_generator< integer, 16 > ()
                        [ ref(size_) = _val ] ] ]
    ;

  pascal_string_padding_ %=
    karma::repeat (3 - (ref (size_) + 3) % 4) [ karma::byte_(0) ]
    ;

  pascal_string_payload_ %=
    karma::repeat (ref (size_)) [ karma::byte_ ]
    ;

  std::vector<byte> v;
  v.push_back ('1');
  v.push_back ('2');
  v.push_back ('3');

  std::string s;

  bool r = karma::generate (std::back_inserter (s), pascal_string_, v);

  std::cout << "'" << s << "'"
            << std::endl;       // expecting 'h0031230'
}