use message string i/o

protocol/osc/bundle.cpp

@@ -36,48 +36,63 @@ size_t Bundle::streamSize() const
 }
 
 
-void Bundle::iStream(std::shared_ptr<bufferstream> stream)
+void Bundle::iStream(std::shared_ptr<bufferstream> buffer)
 {
+  auto element = [&](std::shared_ptr<Message> msg, uint32_t size) {
+    msg->iStream(buffer);
+    // The element, as read, must match the prescribed size.
+    if (!buffer->fail())
+      {
+      if (msg->streamSize() == size)
+        elements.push_back(msg);
+      else
+        buffer->setstate(std::ios::failbit);
+      }
+    };
+
+  /// An OSC Bundle consists of the OSC-string “#bundle”
   std::string header;
-  stream->readString(header);
+  Message::readString(buffer, header);
   if (header.compare(address_pattern) != 0)
-    return stream->setstate(std::ios::failbit);
+    return buffer->setstate(std::ios::failbit);
 
-  time_tag.iStream(stream);
+  /// ... followed by an OSC Time Tag
+  time_tag.iStream(buffer);
 
-  while (stream->available() && stream->good())
+  /// ... followed by zero or more OSC Bundle Elements.
+  while (buffer->available() && buffer->good())
   {
-    int32_t length;
-    *stream >> length;
-    switch (stream->peek()) {
+    /// > \cite Spec10 An OSC Bundle Element consists of its size and its contents.
+
+    /// > \cite Spec10 The size is an int32 representing the number of 8-bit bytes
+    /// > in the contents, and will always be a multiple of 4.
+    uint32_t size = buffer->readType<int32_t>();
+    if (size % 4 != 0)
+        return buffer->setstate(std::ios::failbit);
+
+    /// > \cite Spec10 The contents are either an OSC Message or an OSC Bundle.
+    switch (buffer->peek()) {
     case '/':
-      elements.emplace_back(std::make_shared<Message>());
+      element(std::make_shared<Message>(), size);
       break;
     case '#':
-      elements.emplace_back(std::make_shared<Bundle>());
+      element(std::make_shared<Bundle>(), size);
       break;
     default:
-      stream->setstate(std::ios::failbit);
+      buffer->setstate(std::ios::failbit);
     }
-    if (!stream->good())
-      break;
-
-    elements.back()->iStream(stream);
-    if ((uint)length != elements.back()->streamSize())
-      return stream->setstate(std::ios::failbit);
   }
 }
 
 
-void Bundle::oStream(std::shared_ptr<bufferstream> stream) const
+void Bundle::oStream(std::shared_ptr<bufferstream> buffer) const
 {
-  stream->writeString(address_pattern);
-  time_tag.oStream(stream);
-
+  Message::writeString(buffer, address_pattern);
+  time_tag.oStream(buffer);
   for (const auto &element: elements)
   {
-    stream->writeType<int32_t>(element->streamSize());
-    element->oStream(stream);
+    buffer->writeType<int32_t>(element->streamSize());
+    element->oStream(buffer);
   }
 }