Hey, this looks fantastic. I was thinking of writing a new block myself
as I find the previous implementation can be a speed bottleneck but the
design of this version looks like it will overcome that.
I haven't had a chance to test it but I have a small comment
regarding the interface.
I use OSC all the time, particularly when prototyping things, and
it's nice to be able to construct and send an OSC message in a
single line.
There are two ways I can suggest to do this.
The first is to define the << operator to append arguments
for each argument type
- Message&
operator<<(Message&, std::string const& arg);
letting you work like this:
- mSender.send(Message("/foo")
<< 1 << "hello" << int64_t(bigNumber));
Alternatively, you can define a variadic template function to
create methods which could potentially be optimised a bit down the
line as you'll know when constructing the message how big its
buffer should be. Something like:
-
template
<
typename
... Args>
Message createMessage(std::string
oscAddress, Args &&... args);
which gives you one simple function to create any OSC message.
Something less frequently used but also useful that I've done
before is to provide a variadic template function to parse the message
into variables as well, like this:
- template
<typename... Args> bool Message::parse(Args&&... args);
- //
used as
- int a;
- string b;
- if
(message.parse(a, b))
- doAction(a,b);
- else
- printError();
This is useful because 99% of the time I'm using OSC I'm
assuming a specific typetag given an address and only want to act if
that typetag is matched. The above interface is a nice way to
quickly grab your arguments and also check they're all of the
right format at the same time.
If you like the above, let me know if you'd like me to
implement them and submit a pull request.
Loading User Profile...
), which is why it took so long for me
to reply. I don't exactly remember the exact stuff for the
matching but you can look 
