server/supernova/utilities/osc_dispatcher.hpp

   1 //  osc responder class
   2 //  Copyright (C) 2008 Tim Blechmann
   3 //
   4 //  This program is free software; you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation; either version 2 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program; see the file COPYING.  If not, write to
  16 //  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17 //  Boston, MA 02111-1307, USA.
  18
  19 #ifndef OSC_RESPONDER_HPP
  20 #define OSC_RESPONDER_HPP
  21
  22 #include <string>
  23 #include <map>
  24 #include "exists.hpp"
  25 #include "branch_hints.hpp"
  26
  27 #include <boost/tuple/tuple.hpp>
  28
  29 #include "osc/OscReceivedElements.h"
  30
  31 namespace nova
  32 {
  33
  34
  35 class osc_responder
  36 {
  37 public:
  38     virtual ~osc_responder()
  39     {}
  40
  41     virtual void run(osc::ReceivedMessageArgumentIterator begin,
  42                      osc::ReceivedMessageArgumentIterator const & end) = 0;
  43 };
  44
  45
  46 class osc_dispatcher
  47 {
  48     typedef std::string string;
  49     typedef std::size_t size_t;
  50     typedef std::multimap<string, osc_responder*> responder_map_t;
  51
  52 public:
  53     static bool is_pattern(const char * pattern)
  54     {
  55         for(;;)
  56         {
  57             if (unlikely(*pattern == 0))
  58                 return false;
  59             if (unlikely((*pattern == '?') or (*pattern == '*')))
  60                 return true;
  61             ++pattern;
  62         }
  63     }
  64
  65     static unsigned int first_pattern_char(const char * pattern)
  66     {
  67         assert(is_pattern(pattern));
  68
  69         unsigned int ret = 0;
  70         for(;;)
  71         {
  72             if (unlikely((*pattern == '?') or (*pattern == '*')))
  73                 return ret;
  74             ++ret;
  75             ++pattern;
  76         }
  77         assert(false);
  78     }
  79
  80     static bool match_pattern(const char * pattern, const char * address)
  81     {
  82         const char pc = *pattern;
  83         const char ac = *address;
  84
  85         if ((pc == 0) and (ac == 0))
  86             return true;
  87
  88         if ((pc == 0) or (ac == 0))
  89             return false;
  90
  91         if (pc == '?')
  92             return match_pattern(++pattern, ++address);
  93
  94         if (pc == '*')
  95         {
  96             for(;;)
  97             {
  98                 if (match_pattern(pattern+1, address+1))
  99                     return true;
 100                 ++address;
 101                 if (*address == 0)
 102                     return *(pattern+1) == 0;
 103             }
 104         }
 105
 106         if (pc != ac)
 107             return false;
 108         else
 109             return match_pattern(++pattern, ++address);
 110     }
 111
 112     void add_responder(string const & address, osc_responder * resp)
 113     {
 114         responder_map.insert(std::make_pair(address, resp));
 115     }
 116
 117     void remove_responder(string const & address, osc_responder * resp)
 118     {
 119         assert(exists(responder_map, address));
 120
 121         responder_map_t::iterator it, end;
 122         boost::tie(it, end) = responder_map.equal_range(address);
 123
 124         for(; it != end; ++it)
 125         {
 126             if (it->second == resp)
 127             {
 128                 responder_map.erase(it);
 129                 return;
 130             }
 131         }
 132         assert(false);
 133     }
 134
 135     void handle_packet(const char * data, size_t length)
 136     {
 137         assert(length);
 138         if (data[0] == '#')
 139             handle_bundle(data, length);
 140         else
 141             handle_message(data, length);
 142     }
 143
 144 private:
 145     void handle_message(const char * data, size_t length)
 146     {
 147         osc::ReceivedMessage msg(osc::ReceivedPacket(data, length));
 148         handle_message(msg.AddressPattern(), msg.ArgumentsBegin(), msg.ArgumentsEnd());
 149     }
 150
 151     void handle_bundle(const char * data, size_t length)
 152     {
 153         osc::ReceivedBundle bundle(osc::ReceivedPacket(data, length));
 154         handle_bundle(bundle.ElementsBegin(), bundle.ElementsEnd());
 155     }
 156
 157     void handle_bundle(osc::ReceivedBundleElementIterator const & begin,
 158                        osc::ReceivedBundleElementIterator const & end)
 159     {
 160         for (osc::ReceivedBundleElementIterator it = begin; it != end; ++it)
 161         {
 162             if (it->IsBundle())
 163             {
 164                 osc::ReceivedBundle bundle(*it);
 165                 handle_bundle(bundle.ElementsBegin(), bundle.ElementsEnd());
 166             }
 167             else
 168             {
 169                 osc::ReceivedMessage msg(*it);
 170                 handle_message(msg.AddressPattern(), msg.ArgumentsBegin(), msg.ArgumentsEnd());
 171             }
 172         }
 173     }
 174
 175     void handle_message(char const * pattern, osc::ReceivedMessageArgumentIterator const & begin,
 176                         osc::ReceivedMessageArgumentIterator const & end)
 177     {
 178         if (is_pattern(pattern))
 179             handle_pattern(pattern, begin, end);
 180         else
 181             handle_address(pattern, begin, end);
 182     }
 183
 184
 185     void handle_pattern(const char * pattern, osc::ReceivedMessageArgumentIterator const & begin,
 186                         osc::ReceivedMessageArgumentIterator const & end)
 187     {
 188         responder_map_t::iterator it;
 189         const unsigned int pattern_begin = first_pattern_char(pattern);
 190
 191         const string pattern_root(pattern, pattern_begin);
 192
 193         it = responder_map.lower_bound(pattern_root);
 194
 195         for(; it != responder_map.end(); ++it)
 196         {
 197             if (match_pattern(pattern, it->first.c_str()))
 198             {
 199                 osc_responder * resp = it->second;
 200                 resp->run(begin, end);
 201                 continue;
 202             }
 203
 204             if (it->first.compare(0, pattern_begin, pattern_root))
 205                 return;
 206         }
 207     }
 208
 209     void handle_address(const char * address, osc::ReceivedMessageArgumentIterator const & begin,
 210                         osc::ReceivedMessageArgumentIterator const & end)
 211     {
 212         responder_map_t::iterator it, it_end;
 213         boost::tie(it, it_end) = responder_map.equal_range(address);
 214
 215         for(; it != it_end; ++it)
 216         {
 217             osc_responder * resp = it->second;
 218             resp->run(begin, end);
 219         }
 220     }
 221
 222     responder_map_t responder_map;
 223 };
 224
 225 } /* namespace nova */
 226
 227 #endif /* OSC_RESPONDER_HPP */