37 #ifndef INCLUDED_OSCPACK_OSCRECEIVEDELEMENTS_H
38 #define INCLUDED_OSCPACK_OSCRECEIVEDELEMENTS_H
45 #include "OscException.h"
51 class MalformedPacketException :
public Exception{
53 MalformedPacketException(
const char *w=
"malformed packet" )
57 class MalformedMessageException :
public Exception{
59 MalformedMessageException(
const char *w=
"malformed message" )
63 class MalformedBundleException :
public Exception{
65 MalformedBundleException(
const char *w=
"malformed bundle" )
69 class WrongArgumentTypeException :
public Exception{
71 WrongArgumentTypeException(
const char *w=
"wrong argument type" )
75 class MissingArgumentException :
public Exception{
77 MissingArgumentException(
const char *w=
"missing argument" )
81 class ExcessArgumentException :
public Exception{
83 ExcessArgumentException(
const char *w=
"too many arguments" )
95 ReceivedPacket(
const char *contents, osc_bundle_element_size_t size )
96 : contents_( contents )
97 , size_( ValidateSize(size) ) {}
99 ReceivedPacket(
const char *contents, std::size_t size )
100 : contents_( contents )
101 , size_( ValidateSize( (osc_bundle_element_size_t)size ) ) {}
103 #if !(defined(__x86_64__) || defined(_M_X64))
104 ReceivedPacket(
const char *contents,
int size )
105 : contents_( contents )
106 , size_( ValidateSize( (osc_bundle_element_size_t)size ) ) {}
109 bool IsMessage()
const {
return !IsBundle(); }
110 bool IsBundle()
const;
112 osc_bundle_element_size_t Size()
const {
return size_; }
113 const char *Contents()
const {
return contents_; }
116 const char *contents_;
117 osc_bundle_element_size_t size_;
119 static osc_bundle_element_size_t ValidateSize( osc_bundle_element_size_t size )
123 assert(
sizeof(osc::int32) == 4 );
124 assert(
sizeof(osc::uint32) == 4 );
125 assert(
sizeof(osc::int64) == 8 );
126 assert(
sizeof(osc::uint64) == 8 );
128 if( !IsValidElementSizeValue(size) )
129 throw MalformedPacketException(
"invalid packet size" );
132 throw MalformedPacketException(
"zero length elements not permitted" );
134 if( !IsMultipleOf4(size) )
135 throw MalformedPacketException(
"element size must be multiple of four" );
142 class ReceivedBundleElement{
144 ReceivedBundleElement(
const char *sizePtr )
145 : sizePtr_( sizePtr ) {}
147 friend class ReceivedBundleElementIterator;
149 bool IsMessage()
const {
return !IsBundle(); }
150 bool IsBundle()
const;
152 osc_bundle_element_size_t Size()
const;
153 const char *Contents()
const {
return sizePtr_ + osc::OSC_SIZEOF_INT32; }
156 const char *sizePtr_;
160 class ReceivedBundleElementIterator{
162 ReceivedBundleElementIterator(
const char *sizePtr )
163 : value_( sizePtr ) {}
165 ReceivedBundleElementIterator operator++()
171 ReceivedBundleElementIterator operator++(
int)
173 ReceivedBundleElementIterator old( *
this );
178 const ReceivedBundleElement& operator*()
const {
return value_; }
180 const ReceivedBundleElement* operator->()
const {
return &value_; }
182 friend bool operator==(
const ReceivedBundleElementIterator& lhs,
183 const ReceivedBundleElementIterator& rhs );
186 ReceivedBundleElement value_;
188 void Advance() { value_.sizePtr_ = value_.Contents() + value_.Size(); }
190 bool IsEqualTo(
const ReceivedBundleElementIterator& rhs )
const
192 return value_.sizePtr_ == rhs.value_.sizePtr_;
196 inline bool operator==(
const ReceivedBundleElementIterator& lhs,
197 const ReceivedBundleElementIterator& rhs )
199 return lhs.IsEqualTo( rhs );
202 inline bool operator!=(
const ReceivedBundleElementIterator& lhs,
203 const ReceivedBundleElementIterator& rhs )
205 return !( lhs == rhs );
209 class ReceivedMessageArgument{
211 ReceivedMessageArgument(
const char *typeTagPtr,
const char *argumentPtr )
212 : typeTagPtr_( typeTagPtr )
213 , argumentPtr_( argumentPtr ) {}
215 friend class ReceivedMessageArgumentIterator;
217 char TypeTag()
const {
return *typeTagPtr_; }
224 {
return *typeTagPtr_ == TRUE_TYPE_TAG || *typeTagPtr_ == FALSE_TYPE_TAG; }
226 bool AsBoolUnchecked()
const;
228 bool IsNil()
const {
return *typeTagPtr_ == NIL_TYPE_TAG; }
229 bool IsInfinitum()
const {
return *typeTagPtr_ == INFINITUM_TYPE_TAG; }
231 bool IsInt32()
const {
return *typeTagPtr_ == INT32_TYPE_TAG; }
232 int32 AsInt32()
const;
233 int32 AsInt32Unchecked()
const;
235 bool IsFloat()
const {
return *typeTagPtr_ == FLOAT_TYPE_TAG; }
236 float AsFloat()
const;
237 float AsFloatUnchecked()
const;
239 bool IsChar()
const {
return *typeTagPtr_ == CHAR_TYPE_TAG; }
241 char AsCharUnchecked()
const;
243 bool IsRgbaColor()
const {
return *typeTagPtr_ == RGBA_COLOR_TYPE_TAG; }
244 uint32 AsRgbaColor()
const;
245 uint32 AsRgbaColorUnchecked()
const;
247 bool IsMidiMessage()
const {
return *typeTagPtr_ == MIDI_MESSAGE_TYPE_TAG; }
248 uint32 AsMidiMessage()
const;
249 uint32 AsMidiMessageUnchecked()
const;
251 bool IsInt64()
const {
return *typeTagPtr_ == INT64_TYPE_TAG; }
252 int64 AsInt64()
const;
253 int64 AsInt64Unchecked()
const;
255 bool IsTimeTag()
const {
return *typeTagPtr_ == TIME_TAG_TYPE_TAG; }
256 uint64 AsTimeTag()
const;
257 uint64 AsTimeTagUnchecked()
const;
259 bool IsDouble()
const {
return *typeTagPtr_ == DOUBLE_TYPE_TAG; }
260 double AsDouble()
const;
261 double AsDoubleUnchecked()
const;
263 bool IsString()
const {
return *typeTagPtr_ == STRING_TYPE_TAG; }
264 const char* AsString()
const;
265 const char* AsStringUnchecked()
const {
return argumentPtr_; }
267 bool IsSymbol()
const {
return *typeTagPtr_ == SYMBOL_TYPE_TAG; }
268 const char* AsSymbol()
const;
269 const char* AsSymbolUnchecked()
const {
return argumentPtr_; }
271 bool IsBlob()
const {
return *typeTagPtr_ == BLOB_TYPE_TAG; }
272 void AsBlob(
const void*& data, osc_bundle_element_size_t& size )
const;
273 void AsBlobUnchecked(
const void*& data, osc_bundle_element_size_t& size )
const;
275 bool IsArrayBegin()
const {
return *typeTagPtr_ == ARRAY_BEGIN_TYPE_TAG; }
276 bool IsArrayEnd()
const {
return *typeTagPtr_ == ARRAY_END_TYPE_TAG; }
279 std::size_t ComputeArrayItemCount()
const;
282 const char *typeTagPtr_;
283 const char *argumentPtr_;
287 class ReceivedMessageArgumentIterator{
289 ReceivedMessageArgumentIterator(
const char *typeTags,
const char *arguments )
290 : value_( typeTags, arguments ) {}
292 ReceivedMessageArgumentIterator operator++()
298 ReceivedMessageArgumentIterator operator++(
int)
300 ReceivedMessageArgumentIterator old( *
this );
305 const ReceivedMessageArgument& operator*()
const {
return value_; }
307 const ReceivedMessageArgument* operator->()
const {
return &value_; }
309 friend bool operator==(
const ReceivedMessageArgumentIterator& lhs,
310 const ReceivedMessageArgumentIterator& rhs );
313 ReceivedMessageArgument value_;
317 bool IsEqualTo(
const ReceivedMessageArgumentIterator& rhs )
const
319 return value_.typeTagPtr_ == rhs.value_.typeTagPtr_;
323 inline bool operator==(
const ReceivedMessageArgumentIterator& lhs,
324 const ReceivedMessageArgumentIterator& rhs )
326 return lhs.IsEqualTo( rhs );
329 inline bool operator!=(
const ReceivedMessageArgumentIterator& lhs,
330 const ReceivedMessageArgumentIterator& rhs )
332 return !( lhs == rhs );
336 class ReceivedMessageArgumentStream{
337 friend class ReceivedMessage;
338 ReceivedMessageArgumentStream(
const ReceivedMessageArgumentIterator& begin,
339 const ReceivedMessageArgumentIterator& end )
343 ReceivedMessageArgumentIterator p_, end_;
348 bool Eos()
const {
return p_ == end_; }
350 ReceivedMessageArgumentStream& operator>>(
bool& rhs )
353 throw MissingArgumentException();
355 rhs = (*p_++).AsBool();
363 ReceivedMessageArgumentStream& operator>>( int32& rhs )
366 throw MissingArgumentException();
368 rhs = (*p_++).AsInt32();
372 ReceivedMessageArgumentStream& operator>>(
float& rhs )
375 throw MissingArgumentException();
377 rhs = (*p_++).AsFloat();
381 ReceivedMessageArgumentStream& operator>>(
char& rhs )
384 throw MissingArgumentException();
386 rhs = (*p_++).AsChar();
390 ReceivedMessageArgumentStream& operator>>( RgbaColor& rhs )
393 throw MissingArgumentException();
395 rhs.value = (*p_++).AsRgbaColor();
399 ReceivedMessageArgumentStream& operator>>( MidiMessage& rhs )
402 throw MissingArgumentException();
404 rhs.value = (*p_++).AsMidiMessage();
408 ReceivedMessageArgumentStream& operator>>( int64& rhs )
411 throw MissingArgumentException();
413 rhs = (*p_++).AsInt64();
417 ReceivedMessageArgumentStream& operator>>( TimeTag& rhs )
420 throw MissingArgumentException();
422 rhs.value = (*p_++).AsTimeTag();
426 ReceivedMessageArgumentStream& operator>>(
double& rhs )
429 throw MissingArgumentException();
431 rhs = (*p_++).AsDouble();
435 ReceivedMessageArgumentStream& operator>>( Blob& rhs )
438 throw MissingArgumentException();
440 (*p_++).AsBlob( rhs.data, rhs.size );
444 ReceivedMessageArgumentStream& operator>>(
const char*& rhs )
447 throw MissingArgumentException();
449 rhs = (*p_++).AsString();
453 ReceivedMessageArgumentStream& operator>>( Symbol& rhs )
456 throw MissingArgumentException();
458 rhs.value = (*p_++).AsSymbol();
462 ReceivedMessageArgumentStream& operator>>( MessageTerminator& rhs )
467 throw ExcessArgumentException();
474 class ReceivedMessage{
475 void Init(
const char *bundle, osc_bundle_element_size_t size );
477 explicit ReceivedMessage(
const ReceivedPacket& packet );
478 explicit ReceivedMessage(
const ReceivedBundleElement& bundleElement );
480 const char *AddressPattern()
const {
return addressPattern_; }
483 bool AddressPatternIsUInt32()
const;
484 uint32 AddressPatternAsUInt32()
const;
486 uint32 ArgumentCount()
const {
return static_cast<uint32
>(typeTagsEnd_ - typeTagsBegin_); }
488 const char *TypeTags()
const {
return typeTagsBegin_; }
491 typedef ReceivedMessageArgumentIterator const_iterator;
493 ReceivedMessageArgumentIterator ArgumentsBegin()
const
495 return ReceivedMessageArgumentIterator( typeTagsBegin_, arguments_ );
498 ReceivedMessageArgumentIterator ArgumentsEnd()
const
500 return ReceivedMessageArgumentIterator( typeTagsEnd_, 0 );
503 ReceivedMessageArgumentStream ArgumentStream()
const
505 return ReceivedMessageArgumentStream( ArgumentsBegin(), ArgumentsEnd() );
509 const char *addressPattern_;
510 const char *typeTagsBegin_;
511 const char *typeTagsEnd_;
512 const char *arguments_;
516 class ReceivedBundle{
517 void Init(
const char *message, osc_bundle_element_size_t size );
519 explicit ReceivedBundle(
const ReceivedPacket& packet );
520 explicit ReceivedBundle(
const ReceivedBundleElement& bundleElement );
522 uint64 TimeTag()
const;
524 uint32 ElementCount()
const {
return elementCount_; }
526 typedef ReceivedBundleElementIterator const_iterator;
528 ReceivedBundleElementIterator ElementsBegin()
const
530 return ReceivedBundleElementIterator( timeTag_ + 8 );
533 ReceivedBundleElementIterator ElementsEnd()
const
535 return ReceivedBundleElementIterator( end_ );
539 const char *timeTag_;
541 uint32 elementCount_;
bool TTFOUNDATION_EXPORT operator!=(const TTObject &anObject, const TTObject &anotherObject)
Compare two objects for inequality.
bool TTFOUNDATION_EXPORT operator==(const TTObject &anObject, const TTObject &anotherObject)
Compare two objects for equality.