falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3680 Commits
16 Branches
451MB
Tree: b00010b65a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b00010b65a'
${ noResults }
Carla/source/modules/water/containers/juce_Variant.cpp

796 lines
34KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2016 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of the ISC license

  8.    http://www.isc.org/downloads/software-support-policy/isc-license/

  9. 

  10.    Permission to use, copy, modify, and/or distribute this software for any

  11.    purpose with or without fee is hereby granted, provided that the above

  12.    copyright notice and this permission notice appear in all copies.

  13. 

  14.    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD

  15.    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

  16.    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,

  17.    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

  18.    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

  19.    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

  20.    OF THIS SOFTWARE.

  21. 

  22.    -----------------------------------------------------------------------------

  23. 

  24.    To release a closed-source product which uses other parts of JUCE not

  25.    licensed under the ISC terms, commercial licenses are available: visit

  26.    www.juce.com for more information.

  27. 

  28.   ==============================================================================

  29. */

  30. 

  31. enum VariantStreamMarkers

  32. {

  33.     varMarker_Int       = 1,

  34.     varMarker_BoolTrue  = 2,

  35.     varMarker_BoolFalse = 3,

  36.     varMarker_Double    = 4,

  37.     varMarker_String    = 5,

  38.     varMarker_Int64     = 6,

  39.     varMarker_Array     = 7,

  40.     varMarker_Binary    = 8,

  41.     varMarker_Undefined = 9

  42. };

  43. 

  44. //==============================================================================

  45. class var::VariantType

  46. {

  47. public:

  48.     VariantType() noexcept {}

  49.     virtual ~VariantType() noexcept {}

  50. 

  51.     virtual int toInt (const ValueUnion&) const noexcept                        { return 0; }

  52.     virtual int64 toInt64 (const ValueUnion&) const noexcept                    { return 0; }

  53.     virtual double toDouble (const ValueUnion&) const noexcept                  { return 0; }

  54.     virtual String toString (const ValueUnion&) const                           { return String(); }

  55.     virtual bool toBool (const ValueUnion&) const noexcept                      { return false; }

  56.     virtual ReferenceCountedObject* toObject (const ValueUnion&) const noexcept { return nullptr; }

  57.     virtual Array<var>* toArray (const ValueUnion&) const noexcept              { return nullptr; }

  58.     virtual MemoryBlock* toBinary (const ValueUnion&) const noexcept            { return nullptr; }

  59.     virtual var clone (const var& original) const                               { return original; }

  60. 

  61.     virtual bool isVoid() const noexcept      { return false; }

  62.     virtual bool isUndefined() const noexcept { return false; }

  63.     virtual bool isInt() const noexcept       { return false; }

  64.     virtual bool isInt64() const noexcept     { return false; }

  65.     virtual bool isBool() const noexcept      { return false; }

  66.     virtual bool isDouble() const noexcept    { return false; }

  67.     virtual bool isString() const noexcept    { return false; }

  68.     virtual bool isObject() const noexcept    { return false; }

  69.     virtual bool isArray() const noexcept     { return false; }

  70.     virtual bool isBinary() const noexcept    { return false; }

  71.     virtual bool isMethod() const noexcept    { return false; }

  72. 

  73.     virtual void cleanUp (ValueUnion&) const noexcept {}

  74.     virtual void createCopy (ValueUnion& dest, const ValueUnion& source) const      { dest = source; }

  75.     virtual bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept = 0;

  76.     virtual void writeToStream (const ValueUnion& data, OutputStream& output) const = 0;

  77. };

  78. 

  79. //==============================================================================

  80. class var::VariantType_Void  : public var::VariantType

  81. {

  82. public:

  83.     VariantType_Void() noexcept {}

  84.     static const VariantType_Void instance;

  85. 

  86.     bool isVoid() const noexcept override   { return true; }

  87.     bool equals (const ValueUnion&, const ValueUnion&, const VariantType& otherType) const noexcept override { return otherType.isVoid() || otherType.isUndefined(); }

  88.     void writeToStream (const ValueUnion&, OutputStream& output) const override   { output.writeCompressedInt (0); }

  89. };

  90. 

  91. //==============================================================================

  92. class var::VariantType_Undefined  : public var::VariantType

  93. {

  94. public:

  95.     VariantType_Undefined() noexcept {}

  96.     static const VariantType_Undefined instance;

  97. 

  98.     bool isUndefined() const noexcept override           { return true; }

  99.     String toString (const ValueUnion&) const override   { return "undefined"; }

  100.     bool equals (const ValueUnion&, const ValueUnion&, const VariantType& otherType) const noexcept override { return otherType.isVoid() || otherType.isUndefined(); }

  101. 

  102.     void writeToStream (const ValueUnion&, OutputStream& output) const override

  103.     {

  104.         output.writeCompressedInt (1);

  105.         output.writeByte (varMarker_Undefined);

  106.     }

  107. };

  108. 

  109. //==============================================================================

  110. class var::VariantType_Int  : public var::VariantType

  111. {

  112. public:

  113.     VariantType_Int() noexcept {}

  114.     static const VariantType_Int instance;

  115. 

  116.     int toInt (const ValueUnion& data) const noexcept override       { return data.intValue; };

  117.     int64 toInt64 (const ValueUnion& data) const noexcept override   { return (int64) data.intValue; };

  118.     double toDouble (const ValueUnion& data) const noexcept override { return (double) data.intValue; }

  119.     String toString (const ValueUnion& data) const override          { return String (data.intValue); }

  120.     bool toBool (const ValueUnion& data) const noexcept override     { return data.intValue != 0; }

  121.     bool isInt() const noexcept override                             { return true; }

  122. 

  123.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  124.     {

  125.         if (otherType.isDouble() || otherType.isInt64() || otherType.isString())

  126.             return otherType.equals (otherData, data, *this);

  127. 

  128.         return otherType.toInt (otherData) == data.intValue;

  129.     }

  130. 

  131.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  132.     {

  133.         output.writeCompressedInt (5);

  134.         output.writeByte (varMarker_Int);

  135.         output.writeInt (data.intValue);

  136.     }

  137. };

  138. 

  139. //==============================================================================

  140. class var::VariantType_Int64  : public var::VariantType

  141. {

  142. public:

  143.     VariantType_Int64() noexcept {}

  144.     static const VariantType_Int64 instance;

  145. 

  146.     int toInt (const ValueUnion& data) const noexcept override       { return (int) data.int64Value; };

  147.     int64 toInt64 (const ValueUnion& data) const noexcept override   { return data.int64Value; };

  148.     double toDouble (const ValueUnion& data) const noexcept override { return (double) data.int64Value; }

  149.     String toString (const ValueUnion& data) const override          { return String (data.int64Value); }

  150.     bool toBool (const ValueUnion& data) const noexcept override     { return data.int64Value != 0; }

  151.     bool isInt64() const noexcept override                           { return true; }

  152. 

  153.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  154.     {

  155.         if (otherType.isDouble() || otherType.isString())

  156.             return otherType.equals (otherData, data, *this);

  157. 

  158.         return otherType.toInt64 (otherData) == data.int64Value;

  159.     }

  160. 

  161.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  162.     {

  163.         output.writeCompressedInt (9);

  164.         output.writeByte (varMarker_Int64);

  165.         output.writeInt64 (data.int64Value);

  166.     }

  167. };

  168. 

  169. //==============================================================================

  170. class var::VariantType_Double   : public var::VariantType

  171. {

  172. public:

  173.     VariantType_Double() noexcept {}

  174.     static const VariantType_Double instance;

  175. 

  176.     int toInt (const ValueUnion& data) const noexcept override       { return (int) data.doubleValue; };

  177.     int64 toInt64 (const ValueUnion& data) const noexcept override   { return (int64) data.doubleValue; };

  178.     double toDouble (const ValueUnion& data) const noexcept override { return data.doubleValue; }

  179.     String toString (const ValueUnion& data) const override          { return String (data.doubleValue, 20); }

  180.     bool toBool (const ValueUnion& data) const noexcept override     { return data.doubleValue != 0; }

  181.     bool isDouble() const noexcept override                          { return true; }

  182. 

  183.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  184.     {

  185.         return std::abs (otherType.toDouble (otherData) - data.doubleValue) < std::numeric_limits<double>::epsilon();

  186.     }

  187. 

  188.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  189.     {

  190.         output.writeCompressedInt (9);

  191.         output.writeByte (varMarker_Double);

  192.         output.writeDouble (data.doubleValue);

  193.     }

  194. };

  195. 

  196. //==============================================================================

  197. class var::VariantType_Bool   : public var::VariantType

  198. {

  199. public:

  200.     VariantType_Bool() noexcept {}

  201.     static const VariantType_Bool instance;

  202. 

  203.     int toInt (const ValueUnion& data) const noexcept override       { return data.boolValue ? 1 : 0; };

  204.     int64 toInt64 (const ValueUnion& data) const noexcept override   { return data.boolValue ? 1 : 0; };

  205.     double toDouble (const ValueUnion& data) const noexcept override { return data.boolValue ? 1.0 : 0.0; }

  206.     String toString (const ValueUnion& data) const override          { return String::charToString (data.boolValue ? (juce_wchar) '1' : (juce_wchar) '0'); }

  207.     bool toBool (const ValueUnion& data) const noexcept override     { return data.boolValue; }

  208.     bool isBool() const noexcept override                            { return true; }

  209. 

  210.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  211.     {

  212.         return otherType.toBool (otherData) == data.boolValue;

  213.     }

  214. 

  215.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  216.     {

  217.         output.writeCompressedInt (1);

  218.         output.writeByte (data.boolValue ? (char) varMarker_BoolTrue : (char) varMarker_BoolFalse);

  219.     }

  220. };

  221. 

  222. //==============================================================================

  223. class var::VariantType_String   : public var::VariantType

  224. {

  225. public:

  226.     VariantType_String() noexcept {}

  227.     static const VariantType_String instance;

  228. 

  229.     void cleanUp (ValueUnion& data) const noexcept override                       { getString (data)-> ~String(); }

  230.     void createCopy (ValueUnion& dest, const ValueUnion& source) const override   { new (dest.stringValue) String (*getString (source)); }

  231. 

  232.     bool isString() const noexcept override                          { return true; }

  233.     int toInt (const ValueUnion& data) const noexcept override       { return getString (data)->getIntValue(); };

  234.     int64 toInt64 (const ValueUnion& data) const noexcept override   { return getString (data)->getLargeIntValue(); };

  235.     double toDouble (const ValueUnion& data) const noexcept override { return getString (data)->getDoubleValue(); }

  236.     String toString (const ValueUnion& data) const override          { return *getString (data); }

  237.     bool toBool (const ValueUnion& data) const noexcept override     { return getString (data)->getIntValue() != 0

  238.                                                                            || getString (data)->trim().equalsIgnoreCase ("true")

  239.                                                                            || getString (data)->trim().equalsIgnoreCase ("yes"); }

  240. 

  241.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  242.     {

  243.         return otherType.toString (otherData) == *getString (data);

  244.     }

  245. 

  246.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  247.     {

  248.         const String* const s = getString (data);

  249.         const size_t len = s->getNumBytesAsUTF8() + 1;

  250.         HeapBlock<char> temp (len);

  251.         s->copyToUTF8 (temp, len);

  252.         output.writeCompressedInt ((int) (len + 1));

  253.         output.writeByte (varMarker_String);

  254.         output.write (temp, len);

  255.     }

  256. 

  257. private:

  258.     static inline const String* getString (const ValueUnion& data) noexcept { return reinterpret_cast<const String*> (data.stringValue); }

  259.     static inline String* getString (ValueUnion& data) noexcept             { return reinterpret_cast<String*> (data.stringValue); }

  260. };

  261. 

  262. //==============================================================================

  263. class var::VariantType_Object   : public var::VariantType

  264. {

  265. public:

  266.     VariantType_Object() noexcept {}

  267.     static const VariantType_Object instance;

  268. 

  269.     void cleanUp (ValueUnion& data) const noexcept override   { if (data.objectValue != nullptr) data.objectValue->decReferenceCount(); }

  270. 

  271.     void createCopy (ValueUnion& dest, const ValueUnion& source) const override

  272.     {

  273.         dest.objectValue = source.objectValue;

  274.         if (dest.objectValue != nullptr)

  275.             dest.objectValue->incReferenceCount();

  276.     }

  277. 

  278.     String toString (const ValueUnion& data) const override                            { return "Object 0x" + String::toHexString ((int) (pointer_sized_int) data.objectValue); }

  279.     bool toBool (const ValueUnion& data) const noexcept override                       { return data.objectValue != nullptr; }

  280.     ReferenceCountedObject* toObject (const ValueUnion& data) const noexcept override  { return data.objectValue; }

  281.     bool isObject() const noexcept override                                            { return true; }

  282. 

  283.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  284.     {

  285.         return otherType.toObject (otherData) == data.objectValue;

  286.     }

  287. 

  288.     var clone (const var& original) const override

  289.     {

  290.         if (DynamicObject* d = original.getDynamicObject())

  291.             return d->clone().get();

  292. 

  293.         jassertfalse; // can only clone DynamicObjects!

  294.         return var();

  295.     }

  296. 

  297.     void writeToStream (const ValueUnion&, OutputStream& output) const override

  298.     {

  299.         jassertfalse; // Can't write an object to a stream!

  300.         output.writeCompressedInt (0);

  301.     }

  302. };

  303. 

  304. //==============================================================================

  305. class var::VariantType_Array   : public var::VariantType_Object

  306. {

  307. public:

  308.     VariantType_Array() noexcept {}

  309.     static const VariantType_Array instance;

  310. 

  311.     String toString (const ValueUnion&) const override                           { return "[Array]"; }

  312.     ReferenceCountedObject* toObject (const ValueUnion&) const noexcept override { return nullptr; }

  313.     bool isArray() const noexcept override                                       { return true; }

  314. 

  315.     Array<var>* toArray (const ValueUnion& data) const noexcept override

  316.     {

  317.         if (RefCountedArray* a = dynamic_cast<RefCountedArray*> (data.objectValue))

  318.             return &(a->array);

  319. 

  320.         return nullptr;

  321.     }

  322. 

  323.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  324.     {

  325.         const Array<var>* const thisArray = toArray (data);

  326.         const Array<var>* const otherArray = otherType.toArray (otherData);

  327.         return thisArray == otherArray || (thisArray != nullptr && otherArray != nullptr && *otherArray == *thisArray);

  328.     }

  329. 

  330.     var clone (const var& original) const override

  331.     {

  332.         Array<var> arrayCopy;

  333. 

  334.         if (const Array<var>* array = toArray (original.value))

  335.             for (int i = 0; i < array->size(); ++i)

  336.                 arrayCopy.add (array->getReference(i).clone());

  337. 

  338.         return var (arrayCopy);

  339.     }

  340. 

  341.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  342.     {

  343.         if (const Array<var>* array = toArray (data))

  344.         {

  345.             MemoryOutputStream buffer (512);

  346.             const int numItems = array->size();

  347.             buffer.writeCompressedInt (numItems);

  348. 

  349.             for (int i = 0; i < numItems; ++i)

  350.                 array->getReference(i).writeToStream (buffer);

  351. 

  352.             output.writeCompressedInt (1 + (int) buffer.getDataSize());

  353.             output.writeByte (varMarker_Array);

  354.             output << buffer;

  355.         }

  356.     }

  357. 

  358.     struct RefCountedArray  : public ReferenceCountedObject

  359.     {

  360.         RefCountedArray (const Array<var>& a)  : array (a)  { incReferenceCount(); }

  361.        #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

  362.         RefCountedArray (Array<var>&& a)  : array (static_cast<Array<var>&&> (a)) { incReferenceCount(); }

  363.        #endif

  364.         Array<var> array;

  365.     };

  366. };

  367. 

  368. //==============================================================================

  369. class var::VariantType_Binary   : public var::VariantType

  370. {

  371. public:

  372.     VariantType_Binary() noexcept {}

  373. 

  374.     static const VariantType_Binary instance;

  375. 

  376.     void cleanUp (ValueUnion& data) const noexcept override                      { delete data.binaryValue; }

  377.     void createCopy (ValueUnion& dest, const ValueUnion& source) const override  { dest.binaryValue = new MemoryBlock (*source.binaryValue); }

  378. 

  379.     String toString (const ValueUnion& data) const override                      { return data.binaryValue->toBase64Encoding(); }

  380.     bool isBinary() const noexcept override                                      { return true; }

  381.     MemoryBlock* toBinary (const ValueUnion& data) const noexcept override       { return data.binaryValue; }

  382. 

  383.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  384.     {

  385.         const MemoryBlock* const otherBlock = otherType.toBinary (otherData);

  386.         return otherBlock != nullptr && *otherBlock == *data.binaryValue;

  387.     }

  388. 

  389.     void writeToStream (const ValueUnion& data, OutputStream& output) const override

  390.     {

  391.         output.writeCompressedInt (1 + (int) data.binaryValue->getSize());

  392.         output.writeByte (varMarker_Binary);

  393.         output << *data.binaryValue;

  394.     }

  395. };

  396. 

  397. //==============================================================================

  398. class var::VariantType_Method   : public var::VariantType

  399. {

  400. public:

  401.     VariantType_Method() noexcept {}

  402.     static const VariantType_Method instance;

  403. 

  404.     void cleanUp (ValueUnion& data) const noexcept override                      { if (data.methodValue != nullptr ) delete data.methodValue; }

  405.     void createCopy (ValueUnion& dest, const ValueUnion& source) const override  { dest.methodValue = new NativeFunction (*source.methodValue); }

  406. 

  407.     String toString (const ValueUnion&) const override               { return "Method"; }

  408.     bool toBool (const ValueUnion& data) const noexcept override     { return data.methodValue != nullptr; }

  409.     bool isMethod() const noexcept override                          { return true; }

  410. 

  411.     bool equals (const ValueUnion& data, const ValueUnion& otherData, const VariantType& otherType) const noexcept override

  412.     {

  413.         return otherType.isMethod() && otherData.methodValue == data.methodValue;

  414.     }

  415. 

  416.     void writeToStream (const ValueUnion&, OutputStream& output) const override

  417.     {

  418.         jassertfalse; // Can't write a method to a stream!

  419.         output.writeCompressedInt (0);

  420.     }

  421. };

  422. 

  423. //==============================================================================

  424. const var::VariantType_Void         var::VariantType_Void::instance;

  425. const var::VariantType_Undefined    var::VariantType_Undefined::instance;

  426. const var::VariantType_Int          var::VariantType_Int::instance;

  427. const var::VariantType_Int64        var::VariantType_Int64::instance;

  428. const var::VariantType_Bool         var::VariantType_Bool::instance;

  429. const var::VariantType_Double       var::VariantType_Double::instance;

  430. const var::VariantType_String       var::VariantType_String::instance;

  431. const var::VariantType_Object       var::VariantType_Object::instance;

  432. const var::VariantType_Array        var::VariantType_Array::instance;

  433. const var::VariantType_Binary       var::VariantType_Binary::instance;

  434. const var::VariantType_Method       var::VariantType_Method::instance;

  435. 

  436. 

  437. //==============================================================================

  438. var::var() noexcept : type (&VariantType_Void::instance) {}

  439. var::var (const VariantType& t) noexcept  : type (&t) {}

  440. var::~var() noexcept  { type->cleanUp (value); }

  441. 

  442. //==============================================================================

  443. var::var (const var& valueToCopy)  : type (valueToCopy.type)

  444. {

  445.     type->createCopy (value, valueToCopy.value);

  446. }

  447. 

  448. var::var (const int v) noexcept       : type (&VariantType_Int::instance)    { value.intValue = v; }

  449. var::var (const int64 v) noexcept     : type (&VariantType_Int64::instance)  { value.int64Value = v; }

  450. var::var (const bool v) noexcept      : type (&VariantType_Bool::instance)   { value.boolValue = v; }

  451. var::var (const double v) noexcept    : type (&VariantType_Double::instance) { value.doubleValue = v; }

  452. var::var (NativeFunction m) noexcept  : type (&VariantType_Method::instance) { value.methodValue = new NativeFunction (m); }

  453. var::var (const Array<var>& v)        : type (&VariantType_Array::instance)  { value.objectValue = new VariantType_Array::RefCountedArray(v); }

  454. var::var (const String& v)            : type (&VariantType_String::instance) { new (value.stringValue) String (v); }

  455. var::var (const char* const v)        : type (&VariantType_String::instance) { new (value.stringValue) String (v); }

  456. var::var (const wchar_t* const v)     : type (&VariantType_String::instance) { new (value.stringValue) String (v); }

  457. var::var (const void* v, size_t sz)   : type (&VariantType_Binary::instance) { value.binaryValue = new MemoryBlock (v, sz); }

  458. var::var (const MemoryBlock& v)       : type (&VariantType_Binary::instance) { value.binaryValue = new MemoryBlock (v); }

  459. 

  460. var::var (const StringArray& v)       : type (&VariantType_Array::instance)

  461. {

  462.     Array<var> strings;

  463. 

  464.     const int n = v.size();

  465.     for (int i = 0; i < n; ++i)

  466.         strings.add (var (v[i]));

  467. 

  468.     value.objectValue = new VariantType_Array::RefCountedArray(strings);

  469. }

  470. 

  471. var::var (ReferenceCountedObject* const object)  : type (&VariantType_Object::instance)

  472. {

  473.     value.objectValue = object;

  474. 

  475.     if (object != nullptr)

  476.         object->incReferenceCount();

  477. }

  478. 

  479. var var::undefined() noexcept           { return var (VariantType_Undefined::instance); }

  480. 

  481. //==============================================================================

  482. bool var::isVoid() const noexcept       { return type->isVoid(); }

  483. bool var::isUndefined() const noexcept  { return type->isUndefined(); }

  484. bool var::isInt() const noexcept        { return type->isInt(); }

  485. bool var::isInt64() const noexcept      { return type->isInt64(); }

  486. bool var::isBool() const noexcept       { return type->isBool(); }

  487. bool var::isDouble() const noexcept     { return type->isDouble(); }

  488. bool var::isString() const noexcept     { return type->isString(); }

  489. bool var::isObject() const noexcept     { return type->isObject(); }

  490. bool var::isArray() const noexcept      { return type->isArray(); }

  491. bool var::isBinaryData() const noexcept { return type->isBinary(); }

  492. bool var::isMethod() const noexcept     { return type->isMethod(); }

  493. 

  494. var::operator int() const noexcept                      { return type->toInt (value); }

  495. var::operator int64() const noexcept                    { return type->toInt64 (value); }

  496. var::operator bool() const noexcept                     { return type->toBool (value); }

  497. var::operator float() const noexcept                    { return (float) type->toDouble (value); }

  498. var::operator double() const noexcept                   { return type->toDouble (value); }

  499. String var::toString() const                            { return type->toString (value); }

  500. var::operator String() const                            { return type->toString (value); }

  501. ReferenceCountedObject* var::getObject() const noexcept { return type->toObject (value); }

  502. Array<var>* var::getArray() const noexcept              { return type->toArray (value); }

  503. MemoryBlock* var::getBinaryData() const noexcept        { return type->toBinary (value); }

  504. DynamicObject* var::getDynamicObject() const noexcept   { return dynamic_cast<DynamicObject*> (getObject()); }

  505. 

  506. //==============================================================================

  507. void var::swapWith (var& other) noexcept

  508. {

  509.     std::swap (type, other.type);

  510.     std::swap (value, other.value);

  511. }

  512. 

  513. var& var::operator= (const var& v)               { type->cleanUp (value); type = v.type; type->createCopy (value, v.value); return *this; }

  514. var& var::operator= (const int v)                { type->cleanUp (value); type = &VariantType_Int::instance; value.intValue = v; return *this; }

  515. var& var::operator= (const int64 v)              { type->cleanUp (value); type = &VariantType_Int64::instance; value.int64Value = v; return *this; }

  516. var& var::operator= (const bool v)               { type->cleanUp (value); type = &VariantType_Bool::instance; value.boolValue = v; return *this; }

  517. var& var::operator= (const double v)             { type->cleanUp (value); type = &VariantType_Double::instance; value.doubleValue = v; return *this; }

  518. var& var::operator= (const char* const v)        { type->cleanUp (value); type = &VariantType_String::instance; new (value.stringValue) String (v); return *this; }

  519. var& var::operator= (const wchar_t* const v)     { type->cleanUp (value); type = &VariantType_String::instance; new (value.stringValue) String (v); return *this; }

  520. var& var::operator= (const String& v)            { type->cleanUp (value); type = &VariantType_String::instance; new (value.stringValue) String (v); return *this; }

  521. var& var::operator= (const MemoryBlock& v)       { type->cleanUp (value); type = &VariantType_Binary::instance; value.binaryValue = new MemoryBlock (v); return *this; }

  522. var& var::operator= (const Array<var>& v)        { var v2 (v); swapWith (v2); return *this; }

  523. var& var::operator= (ReferenceCountedObject* v)  { var v2 (v); swapWith (v2); return *this; }

  524. var& var::operator= (NativeFunction v)           { var v2 (v); swapWith (v2); return *this; }

  525. 

  526. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

  527. var::var (var&& other) noexcept

  528.     : type (other.type),

  529.       value (other.value)

  530. {

  531.     other.type = &VariantType_Void::instance;

  532. }

  533. 

  534. var& var::operator= (var&& other) noexcept

  535. {

  536.     swapWith (other);

  537.     return *this;

  538. }

  539. 

  540. var::var (String&& v)  : type (&VariantType_String::instance)

  541. {

  542.     new (value.stringValue) String (static_cast<String&&> (v));

  543. }

  544. 

  545. var::var (MemoryBlock&& v)  : type (&VariantType_Binary::instance)

  546. {

  547.     value.binaryValue = new MemoryBlock (static_cast<MemoryBlock&&> (v));

  548. }

  549. 

  550. var::var (Array<var>&& v)  : type (&VariantType_Array::instance)

  551. {

  552.     value.objectValue = new VariantType_Array::RefCountedArray (static_cast<Array<var>&&> (v));

  553. }

  554. 

  555. var& var::operator= (String&& v)

  556. {

  557.     type->cleanUp (value);

  558.     type = &VariantType_String::instance;

  559.     new (value.stringValue) String (static_cast<String&&> (v));

  560.     return *this;

  561. }

  562. #endif

  563. 

  564. //==============================================================================

  565. bool var::equals (const var& other) const noexcept

  566. {

  567.     return type->equals (value, other.value, *other.type);

  568. }

  569. 

  570. bool var::equalsWithSameType (const var& other) const noexcept

  571. {

  572.     return type == other.type && equals (other);

  573. }

  574. 

  575. bool var::hasSameTypeAs (const var& other) const noexcept

  576. {

  577.     return type == other.type;

  578. }

  579. 

  580. bool operator== (const var& v1, const var& v2) noexcept     { return v1.equals (v2); }

  581. bool operator!= (const var& v1, const var& v2) noexcept     { return ! v1.equals (v2); }

  582. bool operator== (const var& v1, const String& v2)           { return v1.toString() == v2; }

  583. bool operator!= (const var& v1, const String& v2)           { return v1.toString() != v2; }

  584. bool operator== (const var& v1, const char* const v2)       { return v1.toString() == v2; }

  585. bool operator!= (const var& v1, const char* const v2)       { return v1.toString() != v2; }

  586. 

  587. //==============================================================================

  588. var var::clone() const noexcept

  589. {

  590.     return type->clone (*this);

  591. }

  592. 

  593. //==============================================================================

  594. const var& var::operator[] (const Identifier& propertyName) const

  595. {

  596.     if (DynamicObject* const o = getDynamicObject())

  597.         return o->getProperty (propertyName);

  598. 

  599.     return getNullVarRef();

  600. }

  601. 

  602. const var& var::operator[] (const char* const propertyName) const

  603. {

  604.     return operator[] (Identifier (propertyName));

  605. }

  606. 

  607. var var::getProperty (const Identifier& propertyName, const var& defaultReturnValue) const

  608. {

  609.     if (DynamicObject* const o = getDynamicObject())

  610.         return o->getProperties().getWithDefault (propertyName, defaultReturnValue);

  611. 

  612.     return defaultReturnValue;

  613. }

  614. 

  615. var::NativeFunction var::getNativeFunction() const

  616. {

  617.     return isMethod() && (value.methodValue != nullptr) ? *value.methodValue : nullptr;

  618. }

  619. 

  620. var var::invoke (const Identifier& method, const var* arguments, int numArguments) const

  621. {

  622.     if (DynamicObject* const o = getDynamicObject())

  623.         return o->invokeMethod (method, var::NativeFunctionArgs (*this, arguments, numArguments));

  624. 

  625.     return var();

  626. }

  627. 

  628. var var::call (const Identifier& method) const

  629. {

  630.     return invoke (method, nullptr, 0);

  631. }

  632. 

  633. var var::call (const Identifier& method, const var& arg1) const

  634. {

  635.     return invoke (method, &arg1, 1);

  636. }

  637. 

  638. var var::call (const Identifier& method, const var& arg1, const var& arg2) const

  639. {

  640.     var args[] = { arg1, arg2 };

  641.     return invoke (method, args, 2);

  642. }

  643. 

  644. var var::call (const Identifier& method, const var& arg1, const var& arg2, const var& arg3)

  645. {

  646.     var args[] = { arg1, arg2, arg3 };

  647.     return invoke (method, args, 3);

  648. }

  649. 

  650. var var::call (const Identifier& method, const var& arg1, const var& arg2, const var& arg3, const var& arg4) const

  651. {

  652.     var args[] = { arg1, arg2, arg3, arg4 };

  653.     return invoke (method, args, 4);

  654. }

  655. 

  656. var var::call (const Identifier& method, const var& arg1, const var& arg2, const var& arg3, const var& arg4, const var& arg5) const

  657. {

  658.     var args[] = { arg1, arg2, arg3, arg4, arg5 };

  659.     return invoke (method, args, 5);

  660. }

  661. 

  662. //==============================================================================

  663. int var::size() const

  664. {

  665.     if (const Array<var>* const array = getArray())

  666.         return array->size();

  667. 

  668.     return 0;

  669. }

  670. 

  671. const var& var::operator[] (int arrayIndex) const

  672. {

  673.     const Array<var>* const array = getArray();

  674. 

  675.     // When using this method, the var must actually be an array, and the index

  676.     // must be in-range!

  677.     jassert (array != nullptr && isPositiveAndBelow (arrayIndex, array->size()));

  678. 

  679.     return array->getReference (arrayIndex);

  680. }

  681. 

  682. var& var::operator[] (int arrayIndex)

  683. {

  684.     const Array<var>* const array = getArray();

  685. 

  686.     // When using this method, the var must actually be an array, and the index

  687.     // must be in-range!

  688.     jassert (array != nullptr && isPositiveAndBelow (arrayIndex, array->size()));

  689. 

  690.     return array->getReference (arrayIndex);

  691. }

  692. 

  693. Array<var>* var::convertToArray()

  694. {

  695.     if (Array<var>* array = getArray())

  696.         return array;

  697. 

  698.     Array<var> tempVar;

  699.     if (! isVoid())

  700.         tempVar.add (*this);

  701. 

  702.     *this = tempVar;

  703.     return getArray();

  704. }

  705. 

  706. void var::append (const var& n)

  707. {

  708.     convertToArray()->add (n);

  709. }

  710. 

  711. void var::remove (const int index)

  712. {

  713.     if (Array<var>* const array = getArray())

  714.         array->remove (index);

  715. }

  716. 

  717. void var::insert (const int index, const var& n)

  718. {

  719.     convertToArray()->insert (index, n);

  720. }

  721. 

  722. void var::resize (const int numArrayElementsWanted)

  723. {

  724.     convertToArray()->resize (numArrayElementsWanted);

  725. }

  726. 

  727. int var::indexOf (const var& n) const

  728. {

  729.     if (const Array<var>* const array = getArray())

  730.         return array->indexOf (n);

  731. 

  732.     return -1;

  733. }

  734. 

  735. //==============================================================================

  736. void var::writeToStream (OutputStream& output) const

  737. {

  738.     type->writeToStream (value, output);

  739. }

  740. 

  741. var var::readFromStream (InputStream& input)

  742. {

  743.     const int numBytes = input.readCompressedInt();

  744. 

  745.     if (numBytes > 0)

  746.     {

  747.         switch (input.readByte())

  748.         {

  749.             case varMarker_Int:         return var (input.readInt());

  750.             case varMarker_Int64:       return var (input.readInt64());

  751.             case varMarker_BoolTrue:    return var (true);

  752.             case varMarker_BoolFalse:   return var (false);

  753.             case varMarker_Double:      return var (input.readDouble());

  754.             case varMarker_String:

  755.             {

  756.                 MemoryOutputStream mo;

  757.                 mo.writeFromInputStream (input, numBytes - 1);

  758.                 return var (mo.toUTF8());

  759.             }

  760. 

  761.             case varMarker_Binary:

  762.             {

  763.                 MemoryBlock mb ((size_t) numBytes - 1);

  764. 

  765.                 if (numBytes > 1)

  766.                 {

  767.                     const int numRead = input.read (mb.getData(), numBytes - 1);

  768.                     mb.setSize ((size_t) numRead);

  769.                 }

  770. 

  771.                 return var (mb);

  772.             }

  773. 

  774.             case varMarker_Array:

  775.             {

  776.                 var v;

  777.                 Array<var>* const destArray = v.convertToArray();

  778. 

  779.                 for (int i = input.readCompressedInt(); --i >= 0;)

  780.                     destArray->add (readFromStream (input));

  781. 

  782.                 return v;

  783.             }

  784. 

  785.             default:

  786.                 input.skipNextBytes (numBytes - 1); break;

  787.         }

  788.     }

  789. 

  790.     return var();

  791. }

  792. 

  793. var::NativeFunctionArgs::NativeFunctionArgs (const var& t, const var* args, int numArgs) noexcept

  794.     : thisObject (t), arguments (args), numArguments (numArgs)

  795. {}