303 lines
7.6 KiB
C++
303 lines
7.6 KiB
C++
/*
|
|
osc/message.cpp
|
|
|
|
Copyright (c) 2022 Kevin Matz (kevin.matz@gmail.com)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
#include <cassert>
|
|
#include "message.h"
|
|
|
|
namespace OSC {
|
|
|
|
/**
|
|
* @brief Message::type_tag
|
|
* @return
|
|
*/
|
|
std::string Message::type_tag() const
|
|
{
|
|
std::string types = ",";
|
|
for (const auto & argument: arguments)
|
|
types += argument->type();
|
|
return types;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::createArguments
|
|
* @param types
|
|
* @return
|
|
*/
|
|
std::vector<std::shared_ptr<Argument>> Message::createArguments(std::string types)
|
|
{
|
|
auto args = std::vector<std::shared_ptr<Argument>>();
|
|
for (std::string::size_type pos = 0; pos < types.size(); pos++)
|
|
{
|
|
switch (types.at(pos)) {
|
|
case 'i':
|
|
args.emplace_back(std::make_shared<int32>());
|
|
break;
|
|
case 'f':
|
|
args.emplace_back(std::make_shared<float32>());
|
|
break;
|
|
case 's':
|
|
case 'S':
|
|
args.emplace_back(std::make_shared<string>());
|
|
break;
|
|
case 'b':
|
|
args.emplace_back(std::make_shared<blob>());
|
|
break;
|
|
case 'h':
|
|
args.emplace_back(std::make_shared<int64>());
|
|
break;
|
|
case 't':
|
|
args.emplace_back(std::make_shared<timetag>());
|
|
break;
|
|
case 'd':
|
|
args.emplace_back(std::make_shared<float64>());
|
|
break;
|
|
case 'c':
|
|
args.emplace_back(std::make_shared<character>());
|
|
break;
|
|
case 'r':
|
|
args.emplace_back(std::make_shared<rgba>());
|
|
break;
|
|
case 'm':
|
|
args.emplace_back(std::make_shared<midi>());
|
|
break;
|
|
case 'T':
|
|
args.emplace_back(std::make_shared<True>());
|
|
break;
|
|
case 'F':
|
|
args.emplace_back(std::make_shared<False>());
|
|
break;
|
|
case 'N':
|
|
args.emplace_back(std::make_shared<Null>());
|
|
break;
|
|
case 'I':
|
|
args.emplace_back(std::make_shared<impulse>());
|
|
break;
|
|
case '[':
|
|
{
|
|
args.emplace_back(std::make_shared<array>());
|
|
auto arg = std::static_pointer_cast<array>(args.back());
|
|
std::string::size_type close = ++pos;
|
|
int depth = 1;
|
|
while (depth > 0)
|
|
{
|
|
close = types.find_first_of("[]", close);
|
|
if (close == std::string::npos) // no closing brace, use all the remaining types
|
|
{
|
|
close = types.size()-1;
|
|
break;
|
|
}
|
|
if (types.at(close) == '[') // nested braces, keep going
|
|
{
|
|
close++;
|
|
depth++;
|
|
continue;
|
|
}
|
|
if (types.at(close) == ']') // closed this level of nesting
|
|
{
|
|
close++;
|
|
depth--;
|
|
}
|
|
}
|
|
arg->setTypes(types.substr(pos, close-(pos)));
|
|
pos = close;
|
|
}
|
|
break;
|
|
default:
|
|
continue;
|
|
}
|
|
}
|
|
return args;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::readString
|
|
* @param buffer
|
|
* @param string
|
|
*/
|
|
void Message::readString(std::shared_ptr<bufferstream> buffer, std::string &string)
|
|
{
|
|
buffer->readString(string, 0, true); // variable-length, null terminated
|
|
uint_fast8_t remainder = (string.size()+1) % 4;
|
|
for (int i = remainder ? 4 - remainder : 0; i > 0; i--) // 32-bit aligned
|
|
buffer->get();
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::writeString
|
|
* @param buffer
|
|
* @param string
|
|
*/
|
|
void Message::writeString(std::shared_ptr<bufferstream> buffer, const std::string &string)
|
|
{
|
|
uint_fast8_t remainder = (string.size()+1) % 4;
|
|
uint_fast8_t padding = remainder ? 4 - remainder : 0;
|
|
buffer->writeString(string, string.size()+1+padding, true); // null terminated, 32-bit aligned
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param arg
|
|
*/
|
|
void Message::addArgument(std::shared_ptr<Argument> arg)
|
|
{
|
|
arguments.push_back(arg);
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param val
|
|
*/
|
|
void Message::addArgument(const int32_t val)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::int32>(val));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param val
|
|
*/
|
|
void Message::addArgument(const float val)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::float32>(val));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param str
|
|
*/
|
|
void Message::addArgument(const std::string str)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::string>(str));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param blob
|
|
* @param size
|
|
*/
|
|
void Message::addArgument(const uint8_t *blob, size_t size)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::blob>(blob, size));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param val
|
|
*/
|
|
void Message::addArgument(const int64_t val)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::int64>(val));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param val
|
|
*/
|
|
void Message::addArgument(const double val)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::float64>(val));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param val
|
|
*/
|
|
void Message::addArgument(const char val)
|
|
{
|
|
arguments.emplace_back(std::make_shared<OSC::character>(val));
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Message::addArgument
|
|
* @param state
|
|
*/
|
|
void Message::addArgument(const bool state)
|
|
{
|
|
if (state)
|
|
arguments.emplace_back(std::make_shared<OSC::True>());
|
|
else
|
|
arguments.emplace_back(std::make_shared<OSC::False>());
|
|
}
|
|
|
|
|
|
size_t Message::streamSize() const
|
|
{
|
|
size_t address_size = address_pattern.size(); // character count
|
|
address_size += 1; // null terminated
|
|
address_size += address_size % 4 ? 4 - (address_size % 4) : 0; // padding bytes
|
|
assert(0 == address_size % 4); // 32 bit aligned
|
|
|
|
size_t type_size = type_tag().size(); // character count
|
|
type_size += 1; // null terminated
|
|
type_size += type_size % 4 ? 4 - (type_size % 4) : 0; // padding
|
|
assert(0 == type_size % 4); // 32 bit aligned
|
|
|
|
size_t argument_size = 0;
|
|
for (const auto & argument: arguments)
|
|
argument_size += argument->streamSize(); // length of all arguments
|
|
assert(0 == argument_size % 4); // 32 bit aligned
|
|
|
|
return address_size + type_size + argument_size;
|
|
}
|
|
|
|
|
|
void Message::iStream(std::shared_ptr<bufferstream> stream)
|
|
{
|
|
Message::readString(stream, address_pattern);
|
|
if (address_pattern.front() != '/')
|
|
return stream->setstate(std::ios::failbit);
|
|
|
|
std::string type_string;
|
|
Message::readString(stream, type_string);
|
|
if (type_string.front() != ',')
|
|
return stream->setstate(std::ios::failbit);
|
|
|
|
arguments = createArguments(type_string);
|
|
for (auto &argument: arguments)
|
|
argument->iStream(stream);
|
|
}
|
|
|
|
|
|
void Message::oStream(std::shared_ptr<bufferstream> stream) const
|
|
{
|
|
Message::writeString(stream, address_pattern);
|
|
Message::writeString(stream, type_tag());
|
|
for (const auto &argument: arguments)
|
|
argument->oStream(stream);
|
|
}
|
|
|
|
} // namespace OSC
|