external_libraries/oscpack/osc/OscReceivedElements.h

   1 /*
   2         oscpack -- Open Sound Control packet manipulation library
   3         http://www.audiomulch.com/~rossb/oscpack
   4
   5         Copyright (c) 2004-2005 Ross Bencina <rossb@audiomulch.com>
   6
   7         Permission is hereby granted, free of charge, to any person obtaining
   8         a copy of this software and associated documentation files
   9         (the "Software"), to deal in the Software without restriction,
  10         including without limitation the rights to use, copy, modify, merge,
  11         publish, distribute, sublicense, and/or sell copies of the Software,
  12         and to permit persons to whom the Software is furnished to do so,
  13         subject to the following conditions:
  14
  15         The above copyright notice and this permission notice shall be
  16         included in all copies or substantial portions of the Software.
  17
  18         Any person wishing to distribute modifications to the Software is
  19         requested to send the modifications to the original developer so that
  20         they can be incorporated into the canonical version.
  21
  22         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23         EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24         MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25         IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  26         ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  27         CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28         WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 */
  30 #ifndef INCLUDED_OSCRECEIVEDELEMENTS_H
  31 #define INCLUDED_OSCRECEIVEDELEMENTS_H
  32
  33 #include <cstddef>
  34
  35 #include "OscTypes.h"
  36 #include "OscException.h"
  37
  38
  39 namespace osc{
  40
  41
  42 class MalformedMessageException : public Exception{
  43 public:
  44     MalformedMessageException( const char *w="malformed message" )
  45         : Exception( w ) {}
  46 };
  47
  48 class MalformedBundleException : public Exception{
  49 public:
  50     MalformedBundleException( const char *w="malformed bundle" )
  51         : Exception( w ) {}
  52 };
  53
  54 class WrongArgumentTypeException : public Exception{
  55 public:
  56     WrongArgumentTypeException( const char *w="wrong argument type" )
  57         : Exception( w ) {}
  58 };
  59
  60 class MissingArgumentException : public Exception{
  61 public:
  62     MissingArgumentException( const char *w="missing argument" )
  63         : Exception( w ) {}
  64 };
  65
  66 class ExcessArgumentException : public Exception{
  67 public:
  68     ExcessArgumentException( const char *w="too many arguments" )
  69         : Exception( w ) {}
  70 };
  71
  72
  73 class ReceivedPacket{
  74 public:
  75     ReceivedPacket( const char *contents, int32 size )
  76         : contents_( contents )
  77         , size_( size ) {}
  78
  79     bool IsMessage() const { return !IsBundle(); }
  80     bool IsBundle() const;
  81
  82     int32 Size() const { return size_; }
  83     const char *Contents() const { return contents_; }
  84
  85 private:
  86     const char *contents_;
  87     int32 size_;
  88 };
  89
  90
  91 class ReceivedBundleElement{
  92 public:
  93     ReceivedBundleElement( const char *size )
  94         : size_( size ) {}
  95
  96     friend class ReceivedBundleElementIterator;
  97
  98     bool IsMessage() const { return !IsBundle(); }
  99     bool IsBundle() const;
 100
 101     int32 Size() const;
 102     const char *Contents() const { return size_ + 4; }
 103
 104 private:
 105     const char *size_;
 106 };
 107
 108
 109 class ReceivedBundleElementIterator{
 110 public:
 111         ReceivedBundleElementIterator( const char *sizePtr )
 112         : value_( sizePtr ) {}
 113
 114         ReceivedBundleElementIterator operator++()
 115         {
 116         Advance();
 117         return *this;
 118         }
 119
 120     ReceivedBundleElementIterator operator++(int)
 121     {
 122         ReceivedBundleElementIterator old( *this );
 123         Advance();
 124         return old;
 125     }
 126
 127         const ReceivedBundleElement& operator*() const { return value_; }
 128
 129     const ReceivedBundleElement* operator->() const { return &value_; }
 130
 131         friend bool operator==(const ReceivedBundleElementIterator& lhs,
 132             const ReceivedBundleElementIterator& rhs );
 133
 134 private:
 135         ReceivedBundleElement value_;
 136
 137         void Advance() { value_.size_ = value_.Contents() + value_.Size(); }
 138
 139     bool IsEqualTo( const ReceivedBundleElementIterator& rhs ) const
 140     {
 141         return value_.size_ == rhs.value_.size_;
 142     }
 143 };
 144
 145 inline bool operator==(const ReceivedBundleElementIterator& lhs,
 146         const ReceivedBundleElementIterator& rhs )
 147 {
 148         return lhs.IsEqualTo( rhs );
 149 }
 150
 151 inline bool operator!=(const ReceivedBundleElementIterator& lhs,
 152         const ReceivedBundleElementIterator& rhs )
 153 {
 154         return !( lhs == rhs );
 155 }
 156
 157
 158 class ReceivedMessageArgument{
 159 public:
 160         ReceivedMessageArgument( const char *typeTag, const char *argument )
 161                 : typeTag_( typeTag )
 162                 , argument_( argument ) {}
 163
 164     friend class ReceivedMessageArgumentIterator;
 165
 166         const char TypeTag() const { return *typeTag_; }
 167
 168     // the unchecked methods below don't check whether the argument actually
 169     // is of the specified type. they should only be used if you've already
 170     // checked the type tag or the associated IsType() method.
 171
 172     bool IsBool() const
 173         { return *typeTag_ == TRUE_TYPE_TAG || *typeTag_ == FALSE_TYPE_TAG; }
 174     bool AsBool() const;
 175     bool AsBoolUnchecked() const;
 176
 177     bool IsNil() const { return *typeTag_ == NIL_TYPE_TAG; }
 178     bool IsInfinitum() const { return *typeTag_ == INFINITUM_TYPE_TAG; }
 179
 180     bool IsInt32() const { return *typeTag_ == INT32_TYPE_TAG; }
 181     int32 AsInt32() const;
 182     int32 AsInt32Unchecked() const;
 183
 184     bool IsFloat() const { return *typeTag_ == FLOAT_TYPE_TAG; }
 185     float AsFloat() const;
 186     float AsFloatUnchecked() const;
 187
 188     bool IsChar() const { return *typeTag_ == CHAR_TYPE_TAG; }
 189     char AsChar() const;
 190     char AsCharUnchecked() const;
 191
 192     bool IsRgbaColor() const { return *typeTag_ == RGBA_COLOR_TYPE_TAG; }
 193     uint32 AsRgbaColor() const;
 194     uint32 AsRgbaColorUnchecked() const;
 195
 196     bool IsMidiMessage() const { return *typeTag_ == MIDI_MESSAGE_TYPE_TAG; }
 197     uint32 AsMidiMessage() const;
 198     uint32 AsMidiMessageUnchecked() const;
 199
 200     bool IsInt64() const { return *typeTag_ == INT64_TYPE_TAG; }
 201     int64 AsInt64() const;
 202     int64 AsInt64Unchecked() const;
 203
 204     bool IsTimeTag() const { return *typeTag_ == TIME_TAG_TYPE_TAG; }
 205     uint64 AsTimeTag() const;
 206     uint64 AsTimeTagUnchecked() const;
 207
 208     bool IsDouble() const { return *typeTag_ == DOUBLE_TYPE_TAG; }
 209     double AsDouble() const;
 210     double AsDoubleUnchecked() const;
 211
 212     bool IsString() const { return *typeTag_ == STRING_TYPE_TAG; }
 213     const char* AsString() const;
 214     const char* AsStringUnchecked() const { return argument_; }
 215
 216     bool IsSymbol() const { return *typeTag_ == SYMBOL_TYPE_TAG; }
 217     const char* AsSymbol() const;
 218     const char* AsSymbolUnchecked() const { return argument_; }
 219
 220     bool IsBlob() const { return *typeTag_ == BLOB_TYPE_TAG; }
 221     void AsBlob( const void*& data, unsigned long& size ) const;
 222     void AsBlobUnchecked( const void*& data, unsigned long& size ) const;
 223
 224     bool IsArrayStart() const { return *typeTag_ == ARRAY_START_TYPE_TAG; }
 225     bool IsArrayEnd() const { return *typeTag_ == ARRAY_END_TYPE_TAG; }
 226
 227     std::size_t ArraySize() const;
 228
 229 private:
 230         const char *typeTag_;
 231         const char *argument_;
 232 };
 233
 234
 235 class ReceivedMessageArgumentIterator{
 236 public:
 237         ReceivedMessageArgumentIterator( const char *typeTags, const char *arguments )
 238         : value_( typeTags, arguments ) {}
 239
 240         ReceivedMessageArgumentIterator operator++()
 241         {
 242         Advance();
 243         return *this;
 244         }
 245
 246     ReceivedMessageArgumentIterator operator++(int)
 247     {
 248         ReceivedMessageArgumentIterator old( *this );
 249         Advance();
 250         return old;
 251     }
 252
 253         const ReceivedMessageArgument& operator*() const { return value_; }
 254
 255     const ReceivedMessageArgument* operator->() const { return &value_; }
 256
 257         friend bool operator==(const ReceivedMessageArgumentIterator& lhs,
 258             const ReceivedMessageArgumentIterator& rhs );
 259
 260 private:
 261         ReceivedMessageArgument value_;
 262
 263         void Advance();
 264
 265     bool IsEqualTo( const ReceivedMessageArgumentIterator& rhs ) const
 266     {
 267         return value_.typeTag_ == rhs.value_.typeTag_;
 268     }
 269 };
 270
 271 inline bool operator==(const ReceivedMessageArgumentIterator& lhs,
 272         const ReceivedMessageArgumentIterator& rhs )
 273 {
 274         return lhs.IsEqualTo( rhs );
 275 }
 276
 277 inline bool operator!=(const ReceivedMessageArgumentIterator& lhs,
 278         const ReceivedMessageArgumentIterator& rhs )
 279 {
 280         return !( lhs == rhs );
 281 }
 282
 283
 284 class ReceivedMessageArgumentStream{
 285     friend class ReceivedMessage;
 286     ReceivedMessageArgumentStream( const ReceivedMessageArgumentIterator& begin,
 287             const ReceivedMessageArgumentIterator& end )
 288         : p_( begin )
 289         , end_( end ) {}
 290
 291     ReceivedMessageArgumentIterator p_, end_;
 292
 293 public:
 294
 295     // end of stream
 296     bool Eos() const { return p_ == end_; }
 297
 298     ReceivedMessageArgumentStream& operator>>( bool& rhs )
 299     {
 300         if( Eos() )
 301             throw MissingArgumentException();
 302
 303         rhs = (*p_++).AsBool();
 304         return *this;
 305     }
 306
 307     // not sure if it would be useful to stream Nil and Infinitum
 308     // for now it's not possible
 309     // same goes for array boundaries
 310
 311     ReceivedMessageArgumentStream& operator>>( int32& rhs )
 312     {
 313         if( Eos() )
 314             throw MissingArgumentException();
 315
 316         rhs = (*p_++).AsInt32();
 317         return *this;
 318     }
 319
 320     ReceivedMessageArgumentStream& operator>>( float& rhs )
 321     {
 322         if( Eos() )
 323             throw MissingArgumentException();
 324
 325         rhs = (*p_++).AsFloat();
 326         return *this;
 327     }
 328
 329     ReceivedMessageArgumentStream& operator>>( char& rhs )
 330     {
 331         if( Eos() )
 332             throw MissingArgumentException();
 333
 334         rhs = (*p_++).AsChar();
 335         return *this;
 336     }
 337
 338     ReceivedMessageArgumentStream& operator>>( RgbaColor& rhs )
 339     {
 340         if( Eos() )
 341             throw MissingArgumentException();
 342
 343         rhs.value = (*p_++).AsRgbaColor();
 344         return *this;
 345     }
 346
 347     ReceivedMessageArgumentStream& operator>>( MidiMessage& rhs )
 348     {
 349         if( Eos() )
 350             throw MissingArgumentException();
 351
 352         rhs.value = (*p_++).AsMidiMessage();
 353         return *this;
 354     }
 355
 356     ReceivedMessageArgumentStream& operator>>( int64& rhs )
 357     {
 358         if( Eos() )
 359             throw MissingArgumentException();
 360
 361         rhs = (*p_++).AsInt64();
 362         return *this;
 363     }
 364
 365     ReceivedMessageArgumentStream& operator>>( TimeTag& rhs )
 366     {
 367         if( Eos() )
 368             throw MissingArgumentException();
 369
 370         rhs.value = (*p_++).AsTimeTag();
 371         return *this;
 372     }
 373
 374     ReceivedMessageArgumentStream& operator>>( double& rhs )
 375     {
 376         if( Eos() )
 377             throw MissingArgumentException();
 378
 379         rhs = (*p_++).AsDouble();
 380         return *this;
 381     }
 382
 383     ReceivedMessageArgumentStream& operator>>( Blob& rhs )
 384     {
 385         if( Eos() )
 386             throw MissingArgumentException();
 387
 388         (*p_++).AsBlob( rhs.data, rhs.size );
 389         return *this;
 390     }
 391
 392     ReceivedMessageArgumentStream& operator>>( const char*& rhs )
 393     {
 394         if( Eos() )
 395             throw MissingArgumentException();
 396
 397         rhs = (*p_++).AsString();
 398         return *this;
 399     }
 400
 401     ReceivedMessageArgumentStream& operator>>( Symbol& rhs )
 402     {
 403         if( Eos() )
 404             throw MissingArgumentException();
 405
 406         rhs.value = (*p_++).AsSymbol();
 407         return *this;
 408     }
 409
 410     ReceivedMessageArgumentStream& operator>>( MessageTerminator& rhs )
 411     {
 412         if( !Eos() )
 413             throw ExcessArgumentException();
 414
 415         return *this;
 416     }
 417 };
 418
 419
 420 class ReceivedMessage{
 421     void Init( const char *bundle, unsigned long size );
 422 public:
 423     explicit ReceivedMessage( const ReceivedPacket& packet );
 424     explicit ReceivedMessage( const ReceivedBundleElement& bundleElement );
 425
 426         const char *AddressPattern() const { return addressPattern_; }
 427
 428         // Support for non-standad SuperCollider integer address patterns:
 429         bool AddressPatternIsUInt32() const;
 430         uint32 AddressPatternAsUInt32() const;
 431
 432         unsigned long ArgumentCount() const { return static_cast<unsigned long>(typeTagsEnd_ - typeTagsBegin_); }
 433
 434     const char *TypeTags() const { return typeTagsBegin_; }
 435
 436
 437     typedef ReceivedMessageArgumentIterator const_iterator;
 438
 439         ReceivedMessageArgumentIterator ArgumentsBegin() const
 440     {
 441         return ReceivedMessageArgumentIterator( typeTagsBegin_, arguments_ );
 442     }
 443
 444         ReceivedMessageArgumentIterator ArgumentsEnd() const
 445     {
 446         return ReceivedMessageArgumentIterator( typeTagsEnd_, 0 );
 447     }
 448
 449     ReceivedMessageArgumentStream ArgumentStream() const
 450     {
 451         return ReceivedMessageArgumentStream( ArgumentsBegin(), ArgumentsEnd() );
 452     }
 453
 454 private:
 455         const char *addressPattern_;
 456         const char *typeTagsBegin_;
 457         const char *typeTagsEnd_;
 458     const char *arguments_;
 459 };
 460
 461
 462 class ReceivedBundle{
 463     void Init( const char *message, unsigned long size );
 464 public:
 465     explicit ReceivedBundle( const ReceivedPacket& packet );
 466     explicit ReceivedBundle( const ReceivedBundleElement& bundleElement );
 467
 468     uint64 TimeTag() const;
 469
 470     unsigned long ElementCount() const { return elementCount_; }
 471
 472     typedef ReceivedBundleElementIterator const_iterator;
 473
 474         ReceivedBundleElementIterator ElementsBegin() const
 475     {
 476         return ReceivedBundleElementIterator( timeTag_ + 8 );
 477     }
 478
 479         ReceivedBundleElementIterator ElementsEnd() const
 480     {
 481         return ReceivedBundleElementIterator( end_ );
 482     }
 483
 484 private:
 485     const char *timeTag_;
 486     const char *end_;
 487     unsigned long elementCount_;
 488 };
 489
 490
 491 } // namespace osc
 492
 493
 494 #endif /* INCLUDED_OSCRECEIVEDELEMENTS_H */