interpreter/preprocessor/faust-0.9.47mr3/architecture/osclib/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 "OscTypes.h"
  34 #include "OscException.h"
  35
  36
  37 namespace osc{
  38
  39
  40 class MalformedMessageException : public Exception{
  41 public:
  42     MalformedMessageException( const char *w="malformed message" )
  43         : Exception( w ) {}
  44 };
  45
  46 class MalformedBundleException : public Exception{
  47 public:
  48     MalformedBundleException( const char *w="malformed bundle" )
  49         : Exception( w ) {}
  50 };
  51
  52 class WrongArgumentTypeException : public Exception{
  53 public:
  54     WrongArgumentTypeException( const char *w="wrong argument type" )
  55         : Exception( w ) {}
  56 };
  57
  58 class MissingArgumentException : public Exception{
  59 public:
  60     MissingArgumentException( const char *w="missing argument" )
  61         : Exception( w ) {}
  62 };
  63
  64 class ExcessArgumentException : public Exception{
  65 public:
  66     ExcessArgumentException( const char *w="too many arguments" )
  67         : Exception( w ) {}
  68 };
  69
  70
  71 class ReceivedPacket{
  72 public:
  73     ReceivedPacket( const char *contents, int32 size )
  74         : contents_( contents )
  75         , size_( size ) {}
  76
  77     bool IsMessage() const { return !IsBundle(); }
  78     bool IsBundle() const;
  79
  80     int32 Size() const { return size_; }
  81     const char *Contents() const { return contents_; }
  82
  83 private:
  84     const char *contents_;
  85     int32 size_;
  86 };
  87
  88
  89 class ReceivedBundleElement{
  90 public:
  91     ReceivedBundleElement( const char *size )
  92         : size_( size ) {}
  93
  94     friend class ReceivedBundleElementIterator;
  95
  96     bool IsMessage() const { return !IsBundle(); }
  97     bool IsBundle() const;
  98
  99     int32 Size() const;
 100     const char *Contents() const { return size_ + 4; }
 101
 102 private:
 103     const char *size_;
 104 };
 105
 106
 107 class ReceivedBundleElementIterator{
 108 public:
 109         ReceivedBundleElementIterator( const char *sizePtr )
 110         : value_( sizePtr ) {}
 111
 112         ReceivedBundleElementIterator operator++()
 113         {
 114         Advance();
 115         return *this;
 116         }
 117
 118     ReceivedBundleElementIterator operator++(int)
 119     {
 120         ReceivedBundleElementIterator old( *this );
 121         Advance();
 122         return old;
 123     }
 124
 125         const ReceivedBundleElement& operator*() const { return value_; }
 126
 127     const ReceivedBundleElement* operator->() const { return &value_; }
 128
 129         friend bool operator==(const ReceivedBundleElementIterator& lhs,
 130             const ReceivedBundleElementIterator& rhs );
 131
 132 private:
 133         ReceivedBundleElement value_;
 134
 135         void Advance() { value_.size_ = value_.Contents() + value_.Size(); }
 136
 137     bool IsEqualTo( const ReceivedBundleElementIterator& rhs ) const
 138     {
 139         return value_.size_ == rhs.value_.size_;
 140     }
 141 };
 142
 143 inline bool operator==(const ReceivedBundleElementIterator& lhs,
 144         const ReceivedBundleElementIterator& rhs )
 145 {
 146         return lhs.IsEqualTo( rhs );
 147 }
 148
 149 inline bool operator!=(const ReceivedBundleElementIterator& lhs,
 150         const ReceivedBundleElementIterator& rhs )
 151 {
 152         return !( lhs == rhs );
 153 }
 154
 155
 156 class ReceivedMessageArgument{
 157 public:
 158         ReceivedMessageArgument( const char *typeTag, const char *argument )
 159                 : typeTag_( typeTag )
 160                 , argument_( argument ) {}
 161
 162     friend class ReceivedMessageArgumentIterator;
 163
 164         const char TypeTag() const { return *typeTag_; }
 165
 166     // the unchecked methods below don't check whether the argument actually
 167     // is of the specified type. they should only be used if you've already
 168     // checked the type tag or the associated IsType() method.
 169
 170     bool IsBool() const
 171         { return *typeTag_ == TRUE_TYPE_TAG || *typeTag_ == FALSE_TYPE_TAG; }
 172     bool AsBool() const;
 173     bool AsBoolUnchecked() const;
 174
 175     bool IsNil() const { return *typeTag_ == NIL_TYPE_TAG; }
 176     bool IsInfinitum() const { return *typeTag_ == INFINITUM_TYPE_TAG; }
 177
 178     bool IsInt32() const { return *typeTag_ == INT32_TYPE_TAG; }
 179     int32 AsInt32() const;
 180     int32 AsInt32Unchecked() const;
 181
 182     bool IsFloat() const { return *typeTag_ == FLOAT_TYPE_TAG; }
 183     float AsFloat() const;
 184     float AsFloatUnchecked() const;
 185
 186     bool IsChar() const { return *typeTag_ == CHAR_TYPE_TAG; }
 187     char AsChar() const;
 188     char AsCharUnchecked() const;
 189
 190     bool IsRgbaColor() const { return *typeTag_ == RGBA_COLOR_TYPE_TAG; }
 191     uint32 AsRgbaColor() const;
 192     uint32 AsRgbaColorUnchecked() const;
 193
 194     bool IsMidiMessage() const { return *typeTag_ == MIDI_MESSAGE_TYPE_TAG; }
 195     uint32 AsMidiMessage() const;
 196     uint32 AsMidiMessageUnchecked() const;
 197
 198     bool IsInt64() const { return *typeTag_ == INT64_TYPE_TAG; }
 199     int64 AsInt64() const;
 200     int64 AsInt64Unchecked() const;
 201
 202     bool IsTimeTag() const { return *typeTag_ == TIME_TAG_TYPE_TAG; }
 203     uint64 AsTimeTag() const;
 204     uint64 AsTimeTagUnchecked() const;
 205
 206     bool IsDouble() const { return *typeTag_ == DOUBLE_TYPE_TAG; }
 207     double AsDouble() const;
 208     double AsDoubleUnchecked() const;
 209
 210     bool IsString() const { return *typeTag_ == STRING_TYPE_TAG; }
 211     const char* AsString() const;
 212     const char* AsStringUnchecked() const { return argument_; }
 213
 214     bool IsSymbol() const { return *typeTag_ == SYMBOL_TYPE_TAG; }
 215     const char* AsSymbol() const;
 216     const char* AsSymbolUnchecked() const { return argument_; }
 217
 218     bool IsBlob() const { return *typeTag_ == BLOB_TYPE_TAG; }
 219     void AsBlob( const void*& data, unsigned long& size ) const;
 220     void AsBlobUnchecked( const void*& data, unsigned long& size ) const;
 221
 222 private:
 223         const char *typeTag_;
 224         const char *argument_;
 225 };
 226
 227
 228 class ReceivedMessageArgumentIterator{
 229 public:
 230         ReceivedMessageArgumentIterator( const char *typeTags, const char *arguments )
 231         : value_( typeTags, arguments ) {}
 232
 233         ReceivedMessageArgumentIterator operator++()
 234         {
 235         Advance();
 236         return *this;
 237         }
 238
 239     ReceivedMessageArgumentIterator operator++(int)
 240     {
 241         ReceivedMessageArgumentIterator old( *this );
 242         Advance();
 243         return old;
 244     }
 245
 246         const ReceivedMessageArgument& operator*() const { return value_; }
 247
 248     const ReceivedMessageArgument* operator->() const { return &value_; }
 249
 250         friend bool operator==(const ReceivedMessageArgumentIterator& lhs,
 251             const ReceivedMessageArgumentIterator& rhs );
 252
 253 private:
 254         ReceivedMessageArgument value_;
 255
 256         void Advance();
 257
 258     bool IsEqualTo( const ReceivedMessageArgumentIterator& rhs ) const
 259     {
 260         return value_.typeTag_ == rhs.value_.typeTag_;
 261     }
 262 };
 263
 264 inline bool operator==(const ReceivedMessageArgumentIterator& lhs,
 265         const ReceivedMessageArgumentIterator& rhs )
 266 {
 267         return lhs.IsEqualTo( rhs );
 268 }
 269
 270 inline bool operator!=(const ReceivedMessageArgumentIterator& lhs,
 271         const ReceivedMessageArgumentIterator& rhs )
 272 {
 273         return !( lhs == rhs );
 274 }
 275
 276
 277 class ReceivedMessageArgumentStream{
 278     friend class ReceivedMessage;
 279     ReceivedMessageArgumentStream( const ReceivedMessageArgumentIterator& begin,
 280             const ReceivedMessageArgumentIterator& end )
 281         : p_( begin )
 282         , end_( end ) {}
 283
 284     ReceivedMessageArgumentIterator p_, end_;
 285
 286 public:
 287
 288     // end of stream
 289     bool Eos() const { return p_ == end_; }
 290
 291     ReceivedMessageArgumentStream& operator>>( bool& rhs )
 292     {
 293         if( Eos() )
 294             throw MissingArgumentException();
 295
 296         rhs = (*p_++).AsBool();
 297         return *this;
 298     }
 299
 300     // not sure if it would be useful to stream Nil and Infinitum
 301     // for now it's not possible
 302
 303     ReceivedMessageArgumentStream& operator>>( int32& rhs )
 304     {
 305         if( Eos() )
 306             throw MissingArgumentException();
 307
 308         rhs = (*p_++).AsInt32();
 309         return *this;
 310     }
 311
 312     ReceivedMessageArgumentStream& operator>>( float& rhs )
 313     {
 314         if( Eos() )
 315             throw MissingArgumentException();
 316
 317         rhs = (*p_++).AsFloat();
 318         return *this;
 319     }
 320
 321     ReceivedMessageArgumentStream& operator>>( char& rhs )
 322     {
 323         if( Eos() )
 324             throw MissingArgumentException();
 325
 326         rhs = (*p_++).AsChar();
 327         return *this;
 328     }
 329
 330     ReceivedMessageArgumentStream& operator>>( RgbaColor& rhs )
 331     {
 332         if( Eos() )
 333             throw MissingArgumentException();
 334
 335         rhs.value = (*p_++).AsRgbaColor();
 336         return *this;
 337     }
 338
 339     ReceivedMessageArgumentStream& operator>>( MidiMessage& rhs )
 340     {
 341         if( Eos() )
 342             throw MissingArgumentException();
 343
 344         rhs.value = (*p_++).AsMidiMessage();
 345         return *this;
 346     }
 347
 348     ReceivedMessageArgumentStream& operator>>( int64& rhs )
 349     {
 350         if( Eos() )
 351             throw MissingArgumentException();
 352
 353         rhs = (*p_++).AsInt64();
 354         return *this;
 355     }
 356
 357     ReceivedMessageArgumentStream& operator>>( TimeTag& rhs )
 358     {
 359         if( Eos() )
 360             throw MissingArgumentException();
 361
 362         rhs.value = (*p_++).AsTimeTag();
 363         return *this;
 364     }
 365
 366     ReceivedMessageArgumentStream& operator>>( double& rhs )
 367     {
 368         if( Eos() )
 369             throw MissingArgumentException();
 370
 371         rhs = (*p_++).AsDouble();
 372         return *this;
 373     }
 374
 375     ReceivedMessageArgumentStream& operator>>( Blob& rhs )
 376     {
 377         if( Eos() )
 378             throw MissingArgumentException();
 379
 380         (*p_++).AsBlob( rhs.data, rhs.size );
 381         return *this;
 382     }
 383
 384     ReceivedMessageArgumentStream& operator>>( const char*& rhs )
 385     {
 386         if( Eos() )
 387             throw MissingArgumentException();
 388
 389         rhs = (*p_++).AsString();
 390         return *this;
 391     }
 392
 393     ReceivedMessageArgumentStream& operator>>( Symbol& rhs )
 394     {
 395         if( Eos() )
 396             throw MissingArgumentException();
 397
 398         rhs.value = (*p_++).AsSymbol();
 399         return *this;
 400     }
 401
 402     ReceivedMessageArgumentStream& operator>>( MessageTerminator& )
 403     {
 404         if( !Eos() )
 405             throw ExcessArgumentException();
 406
 407         return *this;
 408     }
 409 };
 410
 411
 412 class ReceivedMessage{
 413     void Init( const char *bundle, unsigned long size );
 414 public:
 415     explicit ReceivedMessage( const ReceivedPacket& packet );
 416     explicit ReceivedMessage( const ReceivedBundleElement& bundleElement );
 417
 418         const char *AddressPattern() const { return addressPattern_; }
 419
 420         // Support for non-standad SuperCollider integer address patterns:
 421         bool AddressPatternIsUInt32() const;
 422         uint32 AddressPatternAsUInt32() const;
 423
 424         unsigned long ArgumentCount() const { return static_cast<unsigned long>(typeTagsEnd_ - typeTagsBegin_); }
 425
 426     const char *TypeTags() const { return typeTagsBegin_; }
 427
 428
 429     typedef ReceivedMessageArgumentIterator const_iterator;
 430
 431         ReceivedMessageArgumentIterator ArgumentsBegin() const
 432     {
 433         return ReceivedMessageArgumentIterator( typeTagsBegin_, arguments_ );
 434     }
 435
 436         ReceivedMessageArgumentIterator ArgumentsEnd() const
 437     {
 438         return ReceivedMessageArgumentIterator( typeTagsEnd_, 0 );
 439     }
 440
 441     ReceivedMessageArgumentStream ArgumentStream() const
 442     {
 443         return ReceivedMessageArgumentStream( ArgumentsBegin(), ArgumentsEnd() );
 444     }
 445
 446 private:
 447         const char *addressPattern_;
 448         const char *typeTagsBegin_;
 449         const char *typeTagsEnd_;
 450     const char *arguments_;
 451 };
 452
 453
 454 class ReceivedBundle{
 455     void Init( const char *message, unsigned long size );
 456 public:
 457     explicit ReceivedBundle( const ReceivedPacket& packet );
 458     explicit ReceivedBundle( const ReceivedBundleElement& bundleElement );
 459
 460     uint64 TimeTag() const;
 461
 462     unsigned long ElementCount() const { return elementCount_; }
 463
 464     typedef ReceivedBundleElementIterator const_iterator;
 465
 466         ReceivedBundleElementIterator ElementsBegin() const
 467     {
 468         return ReceivedBundleElementIterator( timeTag_ + 8 );
 469     }
 470
 471         ReceivedBundleElementIterator ElementsEnd() const
 472     {
 473         return ReceivedBundleElementIterator( end_ );
 474     }
 475
 476 private:
 477     const char *timeTag_;
 478     const char *end_;
 479     unsigned long elementCount_;
 480 };
 481
 482
 483 } // namespace osc
 484
 485
 486 #endif /* INCLUDED_OSCRECEIVEDELEMENTS_H */