message.h

Go to the documentation of this file.

/* vim: set et sw=3 tw=0 fo=croqlaw cino=t0:
 *
 * Astxx, the Asterisk C++ API and Utility Library.
 * Copyright (C) 2005-2007  Matthew A. Nicholson
 * Copyright (C) 2005-2007  Digium, Inc.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef ASTXX_MANAGER_MESSAGE_H
#define ASTXX_MANAGER_MESSAGE_H

#include <astxx/manager/error.h>
#include <map>
#include <string>
#include <sstream>

namespace astxx {
   namespace manager {
      namespace message {
         class header_missing : public manager::error {
            public:
               explicit header_missing(const std::string& header) throw() : manager::error("missing " + header + " header"), m_header(header) { }
               virtual ~header_missing() throw() { }

               std::string header() const { return m_header; }

            private:
               std::string m_header;

         };

         template<typename message_traits>
         class basic_message {
            public:
               // have to use a multimap here because messages can contain 
               // multiple headers with the same key
               typedef std::multimap<std::string, std::string> header_t;
               typedef std::pair<std::string, std::string> header_pair_t;

               message_traits traits;

               std::string data;

            public:

               basic_message(const std::string& value) {
                  this->operator[](traits.main_header()) = value;
               }

               explicit basic_message(const header_t& headers) : headers(headers) { }

               explicit basic_message(const std::map<std::string, std::string>& headers) : headers(headers.begin(), headers.end()) { }
               
               explicit basic_message(const header_t::iterator begin, const header_t::iterator end) : headers(begin, end) { }

               std::string& operator[](const std::string& key) {
                  std::pair<header_t::iterator, header_t::iterator> ii = headers.equal_range(key);
                  if (ii.first != ii.second)
                     return ii.first->second;

                  return headers.insert(std::make_pair(key, ""))->second;
               }

               bool operator==(const std::string& s) const {
                  return (main_header() == s);
               }

               bool operator!=(const std::string& s) const {
                  return !(*this == s);
               }

               header_t::iterator insert(const header_pair_t& pair) {
                  return headers.insert(pair);
               }
               
               void insert(header_t::iterator begin, header_t::iterator end) {
                  return headers.insert(begin, end);
               }

               std::pair<header_t::iterator, header_t::iterator> equal_range(const std::string& key) {
                  return headers.equal_range(key);
               }

               header_t::iterator begin() {
                  return headers.begin();
               }

               header_t::iterator end() {
                  return headers.end();
               }

               std::string format() {
                  if (this->operator[](traits.main_header()).empty()) {
                     throw message::header_missing(traits.main_header());
                  }

                  std::stringstream ss;

                  // put the main header first
                  ss << traits.main_header() << ": " << this->operator[](traits.main_header()) << "\r\n";

                  for (header_t::iterator i = headers.begin(); i != headers.end(); ++i) {
                     // don't repeat the main header
                     if (i->first != traits.main_header()) {
                        ss << i->first << ": " << i->second << "\r\n";
                     }
                  }

                  ss << "\r\n";

                  return ss.str();
               }

               std::string main_header() const {
                  std::pair<header_t::const_iterator, header_t::const_iterator> ii = headers.equal_range(traits.main_header());
                  if (ii.first != ii.second)
                     return ii.first->second;

                  throw message::header_missing(traits.main_header());
               }
            
            private:
               header_t headers;

         };

         template<typename message_traits>
         bool operator==(const std::string& s, const basic_message<message_traits>& m) {
            return (s == m.main_header());
         }

         template<typename message_traits>
         bool operator!=(const std::string& s, const basic_message<message_traits>& m) {
            return !(s == m);
         }

         class message_traits {
            public:
               explicit message_traits(const std::string& key) : key(key) { }
               std::string main_header() const { return key; }

            private:
               std::string key;
         };

         class action_traits : public message_traits {
            public:
               action_traits() : message_traits("Action") { }
         };

         class response_traits : public message_traits {
            public:
               response_traits() : message_traits("Response") { }
         };

         class event_traits : public message_traits {
            public:
               event_traits() : message_traits("Event") { }
         };

         typedef basic_message<action_traits> action;     
         typedef basic_message<response_traits> response; 
         typedef basic_message<event_traits> event;       
      }
   }
}

#endif