From d49fee07507f8ca5398ba2fcd6f5ca9ea7f634bc Mon Sep 17 00:00:00 2001 From: Ben Kuper Date: Sat, 22 Jun 2024 19:53:50 +0200 Subject: [PATCH] Add support for types int64, double, T, F, Nil and Impulse This also updates the UnitTest to include those types --- modules/juce_osc/osc/juce_OSCArgument.cpp | 169 ++++++++++++++++++++++ modules/juce_osc/osc/juce_OSCArgument.h | 50 +++++++ modules/juce_osc/osc/juce_OSCMessage.cpp | 79 ++++++++-- modules/juce_osc/osc/juce_OSCMessage.h | 21 +++ modules/juce_osc/osc/juce_OSCReceiver.cpp | 18 +++ modules/juce_osc/osc/juce_OSCSender.cpp | 16 ++ modules/juce_osc/osc/juce_OSCTypes.cpp | 6 + modules/juce_osc/osc/juce_OSCTypes.h | 14 +- 8 files changed, 359 insertions(+), 14 deletions(-) diff --git a/modules/juce_osc/osc/juce_OSCArgument.cpp b/modules/juce_osc/osc/juce_OSCArgument.cpp index 9feee23f5360..79d4c8a5883c 100644 --- a/modules/juce_osc/osc/juce_OSCArgument.cpp +++ b/modules/juce_osc/osc/juce_OSCArgument.cpp @@ -36,10 +36,15 @@ namespace juce { OSCArgument::OSCArgument (int32 v) : type (OSCTypes::int32), intValue (v) {} +OSCArgument::OSCArgument (int64 v) : type (OSCTypes::int64), int64Value (v) {} OSCArgument::OSCArgument (float v) : type (OSCTypes::float32), floatValue (v) {} +OSCArgument::OSCArgument (double v) : type (OSCTypes::double64),doubleValue (v) {} OSCArgument::OSCArgument (const String& s) : type (OSCTypes::string), stringValue (s) {} OSCArgument::OSCArgument (MemoryBlock b) : type (OSCTypes::blob), blob (std::move (b)) {} OSCArgument::OSCArgument (OSCColour c) : type (OSCTypes::colour), intValue ((int32) c.toInt32()) {} +OSCArgument::OSCArgument(bool b) : type (b ? OSCTypes::T : OSCTypes::F) {} +OSCArgument::OSCArgument(OSCType t) : type (t) {} //for nil and impulse + //============================================================================== String OSCArgument::getString() const noexcept @@ -60,6 +65,15 @@ int32 OSCArgument::getInt32() const noexcept return 0; } +int64 OSCArgument::getInt64() const noexcept +{ + if (isInt64()) + return int64Value; + + jassertfalse; // you must check the type of an argument before attempting to get its value! + return 0; +} + float OSCArgument::getFloat32() const noexcept { if (isFloat32()) @@ -69,6 +83,15 @@ float OSCArgument::getFloat32() const noexcept return 0.0f; } +double OSCArgument::getDouble() const noexcept +{ + if (isDouble()) + return doubleValue; + + jassertfalse; // you must check the type of an argument before attempting to get its value! + return 0.0; +} + const MemoryBlock& OSCArgument::getBlob() const noexcept { // you must check the type of an argument before attempting to get its value! @@ -86,6 +109,15 @@ OSCColour OSCArgument::getColour() const noexcept return { 0, 0, 0, 0 }; } +bool OSCArgument::getBool() const noexcept +{ + if (isBool()) + return type == OSCTypes::T; + + jassertfalse; // you must check the type of an argument before attempting to get its value! + return false; +} + //============================================================================== //============================================================================== @@ -126,14 +158,40 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::int32); expect (arg.isInt32()); + expect (! arg.isInt64()); expect (! arg.isFloat32()); + expect (! arg.isDouble()); expect (! arg.isString()); expect (! arg.isBlob()); expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expect (arg.getInt32() == value); } + beginTest("Int64"); + { + int64 value = 1234567890123456789; + + OSCArgument arg(value); + + expect(arg.getType() == OSCTypes::int64); + expect (! arg.isInt32()); + expect (arg.isInt64()); + expect (! arg.isFloat32()); + expect (! arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); + + expect(arg.getInt64() == value); + } + beginTest ("Float32"); { float value = 12345.6789f; @@ -142,14 +200,40 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::float32); expect (! arg.isInt32()); + expect (! arg.isInt64()); expect (arg.isFloat32()); + expect (! arg.isDouble()); expect (! arg.isString()); expect (! arg.isBlob()); expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expectEquals (arg.getFloat32(), value); } + beginTest("Double"); + { + double value = 12345.6789; + + OSCArgument arg(value); + + expect(arg.getType() == OSCTypes::double64); + expect (! arg.isInt32()); + expect (! arg.isInt64()); + expect (! arg.isFloat32()); + expect (arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); + + expectEquals(arg.getDouble(), value); + } + beginTest ("String"); { String value = "Hello, World!"; @@ -157,10 +241,15 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::string); expect (! arg.isInt32()); + expect (! arg.isInt64()); expect (! arg.isFloat32()); + expect (! arg.isDouble()); expect (arg.isString()); expect (! arg.isBlob()); expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expect (arg.getString() == value); } @@ -171,10 +260,15 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::string); expect (! arg.isInt32()); + expect (! arg.isInt64()); expect (! arg.isFloat32()); + expect (! arg.isDouble()); expect (arg.isString()); expect (! arg.isBlob()); expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expect (arg.getString() == "Hello, World!"); } @@ -186,10 +280,15 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::blob); expect (! arg.isInt32()); + expect (! arg.isInt64()); expect (! arg.isFloat32()); + expect (! arg.isDouble()); expect (! arg.isString()); expect (arg.isBlob()); expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expect (arg.getBlob() == blob); } @@ -209,15 +308,85 @@ class OSCArgumentTests final : public UnitTest expect (arg.getType() == OSCTypes::colour); expect (! arg.isInt32()); + expect (! arg.isInt64()); expect (! arg.isFloat32()); + expect (! arg.isDouble()); expect (! arg.isString()); expect (! arg.isBlob()); expect (arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); expect (arg.getColour().toInt32() == col.toInt32()); } } + beginTest ("Nil"); + { + OSCArgument arg (OSCTypes::nil); + + expect (arg.getType() == OSCTypes::nil); + expect (! arg.isInt32()); + expect (! arg.isInt64()); + expect (! arg.isFloat32()); + expect (! arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (arg.isNil()); + expect (! arg.isImpulse()); + expect (! arg.isBool()); + } + + beginTest("Impulse"); + { + OSCArgument arg(OSCTypes::impulse); + + expect(arg.getType() == OSCTypes::impulse); + expect (! arg.isInt32()); + expect (! arg.isInt64()); + expect (! arg.isFloat32()); + expect (! arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (! arg.isNil()); + expect (arg.isImpulse()); + expect (! arg.isBool()); + } + + beginTest("True"); + { + OSCArgument arg(OSCTypes::T); + expect (! arg.isInt32()); + expect (! arg.isInt64()); + expect (! arg.isFloat32()); + expect (! arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (arg.isBool()); + } + + beginTest("False"); + { + OSCArgument arg(OSCTypes::F); + expect (! arg.isInt32()); + expect (! arg.isInt64()); + expect (! arg.isFloat32()); + expect (! arg.isDouble()); + expect (! arg.isString()); + expect (! arg.isBlob()); + expect (! arg.isColour()); + expect (! arg.isNil()); + expect (! arg.isImpulse()); + expect (arg.isBool()); + } + + beginTest ("Copy, move and assignment"); { { diff --git a/modules/juce_osc/osc/juce_OSCArgument.h b/modules/juce_osc/osc/juce_OSCArgument.h index 6b908464a61e..55287e2645ad 100644 --- a/modules/juce_osc/osc/juce_OSCArgument.h +++ b/modules/juce_osc/osc/juce_OSCArgument.h @@ -52,9 +52,15 @@ class JUCE_API OSCArgument /** Constructs an OSCArgument with type int32 and a given value. */ OSCArgument (int32 value); + /** Constructs an OSCArgument with type int64 and a given value. */ + OSCArgument(int64 value); + /** Constructs an OSCArgument with type float32 and a given value. */ OSCArgument (float value); + /** Constructs an OSCArgument with type double and a given value. */ + OSCArgument(double value); + /** Constructs an OSCArgument with type string and a given value */ OSCArgument (const String& value); @@ -69,6 +75,14 @@ class JUCE_API OSCArgument /** Constructs an OSCArgument with type colour and a given colour value */ OSCArgument (OSCColour colour); + /** Constructs an OSCArgument with type T or F depending on the given boolean value */ + OSCArgument(bool value); + + /** Constructs an OSCArgument with the given OSC type tag. + This constructor is intended for creating OSCArgument objects with type nil or impulse. + */ + OSCArgument(OSCType type); + /** Returns the type of the OSCArgument as an OSCType. OSCType is a char type, and its value will be the OSC type tag of the type. */ @@ -77,9 +91,15 @@ class JUCE_API OSCArgument /** Returns whether the type of the OSCArgument is int32. */ bool isInt32() const noexcept { return type == OSCTypes::int32; } + /** Returns whether the type of the OSCArgument is int64. */ + bool isInt64() const noexcept { return type == OSCTypes::int64; } + /** Returns whether the type of the OSCArgument is float. */ bool isFloat32() const noexcept { return type == OSCTypes::float32; } + /** Returns whether the type of the OSCArgument is double. */ + bool isDouble() const noexcept { return type == OSCTypes::double64; } + /** Returns whether the type of the OSCArgument is string. */ bool isString() const noexcept { return type == OSCTypes::string; } @@ -89,16 +109,35 @@ class JUCE_API OSCArgument /** Returns whether the type of the OSCArgument is colour. */ bool isColour() const noexcept { return type == OSCTypes::colour; } + /** Returns whether the type of the OSCArgument is nil. */ + bool isNil() const noexcept { return type == OSCTypes::nil; } + + /** Returns whether the type of the OSCArgument is impulse. */ + bool isImpulse() const noexcept { return type == OSCTypes::impulse; } + + /** Returns whether the type of the OSCArgument is T or F. */ + bool isBool() const noexcept { return type == OSCTypes::T || type == OSCTypes::F; } + /** Returns the value of the OSCArgument as an int32. If the type of the OSCArgument is not int32, the behaviour is undefined. */ int32 getInt32() const noexcept; + /** Returns the value of the OSCArgument as an int64. + If the type of the OSCArgument is not int64, the behaviour is undefined. + */ + int64 getInt64() const noexcept; + /** Returns the value of the OSCArgument as a float32. If the type of the OSCArgument is not float32, the behaviour is undefined. */ float getFloat32() const noexcept; + /** Returns the value of the OSCArgument as a double. + If the type of the OSCArgument is not double, the behaviour is undefined. + */ + double getDouble() const noexcept; + /** Returns the value of the OSCArgument as a string. If the type of the OSCArgument is not string, the behaviour is undefined. */ @@ -116,6 +155,11 @@ class JUCE_API OSCArgument */ OSCColour getColour() const noexcept; + /** Returns the value of the OSCArgument as a boolean. + If the type of the OSCArgument is not T or F, the behaviour is undefined. + */ + bool getBool() const noexcept { return type == OSCTypes::T; } + private: //============================================================================== OSCType type; @@ -126,6 +170,12 @@ class JUCE_API OSCArgument float floatValue; }; + union + { + int64 int64Value; + double doubleValue; + }; + String stringValue; MemoryBlock blob; }; diff --git a/modules/juce_osc/osc/juce_OSCMessage.cpp b/modules/juce_osc/osc/juce_OSCMessage.cpp index 47f0021cabc4..526955f60848 100644 --- a/modules/juce_osc/osc/juce_OSCMessage.cpp +++ b/modules/juce_osc/osc/juce_OSCMessage.cpp @@ -98,10 +98,15 @@ void OSCMessage::clear() //============================================================================== void OSCMessage::addInt32 (int32 value) { arguments.add (OSCArgument (value)); } +void OSCMessage::addInt64 (int64 value) { arguments.add (OSCArgument (value)); } void OSCMessage::addFloat32 (float value) { arguments.add (OSCArgument (value)); } +void OSCMessage::addDouble (double value) { arguments.add (OSCArgument (value)); } void OSCMessage::addString (const String& value) { arguments.add (OSCArgument (value)); } void OSCMessage::addBlob (MemoryBlock blob) { arguments.add (OSCArgument (std::move (blob))); } void OSCMessage::addColour (OSCColour colour) { arguments.add (OSCArgument (colour)); } +void OSCMessage::addNil() { arguments.add (OSCArgument (OSCTypes::nil)); } +void OSCMessage::addImpulse() { arguments.add (OSCArgument (OSCTypes::impulse)); } +void OSCMessage::addBool (bool value) { arguments.add (OSCArgument (value)); } void OSCMessage::addArgument (OSCArgument arg) { arguments.add (arg); } @@ -124,41 +129,72 @@ class OSCMessageTests final : public UnitTest expectEquals (msg.size(), 0); expect (msg.getAddressPattern().toString() == "/test/param0"); - const int numTestArgs = 5; + const int numTestArgs = 11; const int testInt = 42; + const int64 testInt64 = 64; const float testFloat = 3.14159f; + const double testDouble = 6.28; const String testString = "Hello, World!"; const OSCColour testColour = { 10, 20, 150, 200 }; + const bool testTrue = true; + const bool testFalse = false; const uint8 testBlobData[5] = { 0xBB, 0xCC, 0xDD, 0xEE, 0xFF }; const MemoryBlock testBlob (testBlobData, sizeof (testBlobData)); msg.addInt32 (testInt); + msg.addInt64 (testInt64); msg.addFloat32 (testFloat); + msg.addDouble (testDouble); msg.addString (testString); msg.addBlob (testBlob); msg.addColour (testColour); + msg.addNil (); + msg.addImpulse (); + msg.addBool (testTrue); + msg.addBool (testFalse); + expectEquals (msg.size(), numTestArgs); expectEquals (msg[0].getType(), OSCTypes::int32); - expectEquals (msg[1].getType(), OSCTypes::float32); - expectEquals (msg[2].getType(), OSCTypes::string); - expectEquals (msg[3].getType(), OSCTypes::blob); - expectEquals (msg[4].getType(), OSCTypes::colour); + expectEquals (msg[1].getType(), OSCTypes::int64); + expectEquals (msg[2].getType(), OSCTypes::float32); + expectEquals (msg[3].getType(), OSCTypes::double64); + expectEquals (msg[4].getType(), OSCTypes::string); + expectEquals (msg[5].getType(), OSCTypes::blob); + expectEquals (msg[6].getType(), OSCTypes::colour); + expectEquals (msg[7].getType(), OSCTypes::nil); + expectEquals (msg[8].getType(), OSCTypes::impulse); + expectEquals (msg[9].getType(), OSCTypes::T); + expectEquals (msg[10].getType(), OSCTypes::F); + expect (msg[0].isInt32()); - expect (msg[1].isFloat32()); - expect (msg[2].isString()); - expect (msg[3].isBlob()); - expect (msg[4].isColour()); + expect (msg[1].isInt64()); + expect (msg[2].isFloat32()); + expect (msg[3].isDouble()); + expect (msg[4].isString()); + expect (msg[5].isBlob()); + expect (msg[6].isColour()); + expect (msg[7].isNil()); + expect (msg[8].isImpulse()); + expect (msg[9].isBool()); + expect (msg[10].isBool()); + expectEquals (msg[0].getInt32(), testInt); - expectEquals (msg[1].getFloat32(), testFloat); - expectEquals (msg[2].getString(), testString); - expect (msg[3].getBlob() == testBlob); - expect (msg[4].getColour().toInt32() == testColour.toInt32()); + expectEquals (msg[1].getInt64(), testInt64); + expectEquals (msg[2].getFloat32(), testFloat); + expectEquals (msg[3].getDouble(), testDouble); + expectEquals (msg[4].getString(), testString); + expect (msg[5].getBlob() == testBlob); + expect (msg[6].getColour().toInt32() == testColour.toInt32()); + expectEquals (msg[9].getBool(), testTrue); + expectEquals (msg[10].getBool(), testFalse); + + expect (msg.begin() + numTestArgs == msg.end()); @@ -166,9 +202,15 @@ class OSCMessageTests final : public UnitTest expect (arg->isInt32()); expectEquals (arg->getInt32(), testInt); ++arg; + expect (arg->isInt64()); + expectEquals (arg->getInt64(), testInt64); + ++arg; expect (arg->isFloat32()); expectEquals (arg->getFloat32(), testFloat); ++arg; + expect (arg->isDouble()); + expectEquals (arg->getDouble(), testDouble); + ++arg; expect (arg->isString()); expectEquals (arg->getString(), testString); ++arg; @@ -178,6 +220,17 @@ class OSCMessageTests final : public UnitTest expect (arg->isColour()); expect (arg->getColour().toInt32() == testColour.toInt32()); ++arg; + expect (arg->isNil()); + ++arg; + expect(arg->isImpulse()); + ++arg; + expect(arg->isBool()); + expectEquals(arg->getBool(), testTrue); + ++arg; + expect(arg->isBool()); + expectEquals(arg->getBool(), testFalse); + ++arg; + expect (arg == msg.end()); } diff --git a/modules/juce_osc/osc/juce_OSCMessage.h b/modules/juce_osc/osc/juce_OSCMessage.h index f49e931c61a4..15aa78172f76 100644 --- a/modules/juce_osc/osc/juce_OSCMessage.h +++ b/modules/juce_osc/osc/juce_OSCMessage.h @@ -133,11 +133,21 @@ class JUCE_API OSCMessage */ void addInt32 (int32 value); + /** Creates a new OSCArgument of type int64 with the given value, + and adds it to the OSCMessage object. + */ + void addInt64(int64 value); + /** Creates a new OSCArgument of type float32 with the given value, and adds it to the OSCMessage object. */ void addFloat32 (float value); + /** Creates a new OSCArgument of type double with the given value, + and adds it to the OSCMessage object. + */ + void addDouble (double value); + /** Creates a new OSCArgument of type string with the given value, and adds it to the OSCMessage object. */ @@ -155,6 +165,17 @@ class JUCE_API OSCMessage */ void addColour (OSCColour colour); + /** Creates a new OSCArgument of type nil and adds it to the OSCMessage object. */ + void addNil(); + + /** Creates a new OSCArgument of type impulse and adds it to the OSCMessage object. */ + void addImpulse(); + + /** Creates a new OSCArgument of type T or F with the given value, + and adds it to the OSCMessage object. + */ + void addBool (bool value); + /** Adds the OSCArgument argument to the OSCMessage object. Note: This method will result in a copy of the OSCArgument object if it is passed diff --git a/modules/juce_osc/osc/juce_OSCReceiver.cpp b/modules/juce_osc/osc/juce_OSCReceiver.cpp index 545a289299cc..1e0c0323aa99 100644 --- a/modules/juce_osc/osc/juce_OSCReceiver.cpp +++ b/modules/juce_osc/osc/juce_OSCReceiver.cpp @@ -86,6 +86,12 @@ namespace return input.readIntBigEndian(); } + int64 readInt64() + { + checkBytesAvailable(8, "OSC input stream exhausted while reading int64"); + return input.readInt64BigEndian(); + } + uint64 readUint64() { checkBytesAvailable (8, "OSC input stream exhausted while reading uint64"); @@ -98,6 +104,12 @@ namespace return input.readFloatBigEndian(); } + double readDouble64() + { + checkBytesAvailable(8, "OSC input stream exhausted while reading double"); + return input.readDoubleBigEndian(); + } + String readString() { checkBytesAvailable (4, "OSC input stream exhausted while reading string"); @@ -189,10 +201,16 @@ namespace switch (type) { case OSCTypes::int32: return OSCArgument (readInt32()); + case OSCTypes::int64: return OSCArgument (readInt64()); case OSCTypes::float32: return OSCArgument (readFloat32()); + case OSCTypes::double64: return OSCArgument (readDouble64()); case OSCTypes::string: return OSCArgument (readString()); case OSCTypes::blob: return OSCArgument (readBlob()); case OSCTypes::colour: return OSCArgument (readColour()); + case OSCTypes::nil: return OSCArgument (OSCTypes::nil); + case OSCTypes::impulse: return OSCArgument (OSCTypes::impulse); + case OSCTypes::T: return OSCArgument (true); + case OSCTypes::F: return OSCArgument (false); default: // You supplied an invalid OSCType when calling readArgument! This should never happen. diff --git a/modules/juce_osc/osc/juce_OSCSender.cpp b/modules/juce_osc/osc/juce_OSCSender.cpp index 118adf824263..a87bca1957e1 100644 --- a/modules/juce_osc/osc/juce_OSCSender.cpp +++ b/modules/juce_osc/osc/juce_OSCSender.cpp @@ -62,6 +62,11 @@ namespace return output.writeIntBigEndian (value); } + bool writeInt64(int64 value) + { + return output.writeInt64BigEndian(value); + } + bool writeUint64 (uint64 value) { return output.writeInt64BigEndian (int64 (value)); @@ -72,6 +77,11 @@ namespace return output.writeFloatBigEndian (value); } + bool writeDouble(double value) + { + return output.writeDoubleBigEndian(value); + } + bool writeString (const String& value) { if (! output.writeString (value)) @@ -133,10 +143,16 @@ namespace switch (arg.getType()) { case OSCTypes::int32: return writeInt32 (arg.getInt32()); + case OSCTypes::int64: return writeInt64 (arg.getInt64()); case OSCTypes::float32: return writeFloat32 (arg.getFloat32()); + case OSCTypes::double64: return writeDouble (arg.getDouble()); case OSCTypes::string: return writeString (arg.getString()); case OSCTypes::blob: return writeBlob (arg.getBlob()); case OSCTypes::colour: return writeColour (arg.getColour()); + case OSCTypes::nil: return true; + case OSCTypes::impulse: return true; + case OSCTypes::T: return true; + case OSCTypes::F: return true; default: // In this very unlikely case you supplied an invalid OSCType! diff --git a/modules/juce_osc/osc/juce_OSCTypes.cpp b/modules/juce_osc/osc/juce_OSCTypes.cpp index 5a3405b1dc66..c9214fd2a7cc 100644 --- a/modules/juce_osc/osc/juce_OSCTypes.cpp +++ b/modules/juce_osc/osc/juce_OSCTypes.cpp @@ -36,10 +36,16 @@ namespace juce { const OSCType OSCTypes::int32 = 'i'; +const OSCType OSCTypes::int64 = 'h'; const OSCType OSCTypes::float32 = 'f'; +const OSCType OSCTypes::double64= 'd'; const OSCType OSCTypes::string = 's'; const OSCType OSCTypes::blob = 'b'; const OSCType OSCTypes::colour = 'r'; +const OSCType OSCTypes::nil = 'N'; +const OSCType OSCTypes::impulse = 'I'; +const OSCType OSCTypes::T = 'T'; +const OSCType OSCTypes::F = 'F'; uint32 OSCColour::toInt32() const { diff --git a/modules/juce_osc/osc/juce_OSCTypes.h b/modules/juce_osc/osc/juce_OSCTypes.h index 83dbfc791c52..9dab1346ab64 100644 --- a/modules/juce_osc/osc/juce_OSCTypes.h +++ b/modules/juce_osc/osc/juce_OSCTypes.h @@ -56,18 +56,30 @@ class JUCE_API OSCTypes { public: static const OSCType int32; + static const OSCType int64; static const OSCType float32; + static const OSCType double64; static const OSCType string; static const OSCType blob; static const OSCType colour; + static const OSCType nil; + static const OSCType impulse; + static const OSCType T; + static const OSCType F; static bool isSupportedType (OSCType type) noexcept { return type == OSCTypes::int32 + || type == OSCTypes::int64 || type == OSCTypes::float32 + || type == OSCTypes::double64 || type == OSCTypes::string || type == OSCTypes::blob - || type == OSCTypes::colour; + || type == OSCTypes::colour + || type == OSCTypes::nil + || type == OSCTypes::impulse + || type == OSCTypes::T + || type == OSCTypes::F; } };