/Users/dlarimer/dev/libs/rpc/include/boost/rpc/dynamic_raw.hpp

#ifndef _BOOST_RPC_DYNAMIC_RAW_HPP_
#define _BOOST_RPC_DYNAMIC_RAW_HPP_

namespace boost { namespace rpc { namespace dynamic {
  namespace raw {

    template<typename T>
    class parser;
    class parser_base;
    class skip_parser;

    class description_database {
      public:
        boost::optional<boost::rpc::description> get_description( const std::string& type_name )const {
          type_description_map::const_iterator itr = m_type_db.find(type_name);
          if( itr != m_type_db.end() ) 
            return itr->second;
          return boost::optional<boost::rpc::description>();
        }
        void set( const std::string& name, const boost::rpc::description& d ) {
          m_type_db[name]=d;
        }
        
        template<typename T>
        parser<T>* get_parser();        
        
        skip_parser* get_skip_parser(const std::string& type);        

      private:
        typedef std::map<std::string, boost::rpc::description> type_description_map;
        typedef std::map<std::string, skip_parser*>            type_skipper_map;
        typedef std::map<std::string, parser_base*>            type_parser_map;
        type_description_map m_type_db;
        type_skipper_map     m_skipper_db;
        type_parser_map      m_parser_db;
    };

    template<typename Class>
    class member_parser_base {
      public:
        virtual member_parser_base(){}
        virtual void unpack( std::istream& s, Class& self )=0;
        virtual void pack( std::ostream& s, const Class& self )=0;
    };

    template<typename T, typename Class>
    class member_parser : public member_parser_base<Class> {
      public:
        member_parser( T (Class::*m ), description_database& db )
        :member(m) {
            member_parser = db.get_parser<T>();    
        }

        void unpack( std::istream& s, Class& self ) {
            member_parser->unpack( s, self.*member );
        }
        void pack( std::ostream& s, const Class& self ) {
            member_parser->pack( s, self.*member );
        }

        parser<T>* member_parser;
        T (Class::*member);
    };

    struct create_member_parser {
      create_member_parser( boost::rpc::description::field& f, description_database& db )
      :m_parser(NULL), m_db(db), m_field(f){}

      template<typename T>
      inline void operator()( T (Class::*p), const char* name )const {
        if( std::string(name) == m_field.name ) {
           if( m_field.type == boost::reflect::get_typename<T>() )
               m_parser = new member_parser<T,Class>(p,m_db); 
           else {
              // consider ignoring this as if it was not present...
              throw "fields with same name have different types";
           }
        }
      }
      parser_base* m_parser;
      boost::rpc::description_database& m_db;
      boost::rpc::description::field& m_field;
    };

    template<typename Class>
    class skip_member_parser : public member_parser_base<Class> {
      public:
        skip_member_parser( boost::rpc::description::field& f, boost::rpc::description_database& db ) {
          m_parser = db.get_skip_parser( f.type );
        }
        void unpack( std::istream& s, Class& ) { m_parser->skip( s ); }
        void pack( std::ostream& s, const Class& ) { m_parser->skip( s ); }
      private:
        skip_parser* m_parser;
    };

    class skip_parser {
      public:
        skip_parser( boost::rpc::description& d, description_database& db ) {
          for( uint32_t i = 0; i < d.fields.size(); ++i ) {
            m_fields.push_back( db.get_skip_parser( d.feilds[i].type ) );
          }
        }

        template<typename Stream>
        void skip( Stream& s ) {
          std::vector<skip_parser*>::iterator itr = m_fields.begin();
          while( itr != m_fields.end() ) {
            (*itr)->skip(s);
            ++itr;
          }
        }
        std::vector<skip_parser*> m_fields;
    };
    class public_base {
      public:
        virtual ~public_base(){};  
    };

    template<typename T>
    class parser : public parser_base { 
      public:
        parser( boost::rpc::description& d, description_database& db ) {
          for( uint32_t i = 0; i < d.fields.size(); ++i ) {
            create_member_parser<T> v( d.fields[i], db );
            boost::reflect::reflector<T>::visit( v );
            // add the field to the parse order or create a skip parser
            m_fields.push_back( v.get_parser() ? v.get_parser() : new skip_member_parser<T>( d.fields[i], db ) );
          }
        }
        virtual void unpack( std::istream& s, T& v ) {
          for( uint32_t i = 0; i < m_fields.size(); ++i ) {
            m_fields[i]->unpack( s, v );
          }
        }
        virtual void pack( std::ostream& s, const T& v ) {
          for( uint32_t i = 0; i < m_fields.size(); ++i ) {
            m_fields[i]->pack( s, v );
          }
        }
      private:
        std::vector<member_parser<T>*>  m_fields;     
    };

  } // namespace raw
} } } // boost::rpc::dynamic

#endif