DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
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.
7847 Commits
11 Branches
1.3GB
Tree: cbdf17a6fb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cbdf17a6fb'
${ noResults }
JUCE/modules/juce_core/containers/juce_Variant.cpp

793 lines
33KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    The code included in this file is provided under the terms of the ISC license

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

  12.    To use, copy, modify, and/or distribute this software for any purpose with or

  13.    without fee is hereby granted provided that the above copyright notice and

  14.    this permission notice appear in all copies.

  15. 

  16.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  17.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  18.    DISCLAIMED.

  19. 

  20.   ==============================================================================

  21. */

  22. 

  23. namespace juce

  24. {

  25. 

  26. enum VariantStreamMarkers

  27. {

  28.     varMarker_Int       = 1,

  29.     varMarker_BoolTrue  = 2,

  30.     varMarker_BoolFalse = 3,

  31.     varMarker_Double    = 4,

  32.     varMarker_String    = 5,

  33.     varMarker_Int64     = 6,

  34.     varMarker_Array     = 7,

  35.     varMarker_Binary    = 8,

  36.     varMarker_Undefined = 9

  37. };

  38. 

  39. //==============================================================================

  40. class var::VariantType

  41. {

  42. public:

  43.     VariantType() noexcept {}

  44.     virtual ~VariantType() noexcept {}

  45. 

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

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

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

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

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

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

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

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

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

  55. 

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

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

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

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

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

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

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

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

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

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

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

  67. 

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

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

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

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

  72. };

  73. 

  74. //==============================================================================

  75. class var::VariantType_Void  : public var::VariantType

  76. {

  77. public:

  78.     VariantType_Void() noexcept {}

  79.     static const VariantType_Void instance;

  80. 

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

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

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

  84. };

  85. 

  86. //==============================================================================

  87. class var::VariantType_Undefined  : public var::VariantType

  88. {

  89. public:

  90.     VariantType_Undefined() noexcept {}

  91.     static const VariantType_Undefined instance;

  92. 

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

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

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

  96. 

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

  98.     {

  99.         output.writeCompressedInt (1);

  100.         output.writeByte (varMarker_Undefined);

  101.     }

  102. };

  103. 

  104. //==============================================================================

  105. class var::VariantType_Int  : public var::VariantType

  106. {

  107. public:

  108.     VariantType_Int() noexcept {}

  109.     static const VariantType_Int instance;

  110. 

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

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

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

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

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

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

  117. 

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

  119.     {

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

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

  122. 

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

  124.     }

  125. 

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

  127.     {

  128.         output.writeCompressedInt (5);

  129.         output.writeByte (varMarker_Int);

  130.         output.writeInt (data.intValue);

  131.     }

  132. };

  133. 

  134. //==============================================================================

  135. class var::VariantType_Int64  : public var::VariantType

  136. {

  137. public:

  138.     VariantType_Int64() noexcept {}

  139.     static const VariantType_Int64 instance;

  140. 

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

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

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

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

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

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

  147. 

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

  149.     {

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

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

  152. 

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

  154.     }

  155. 

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

  157.     {

  158.         output.writeCompressedInt (9);

  159.         output.writeByte (varMarker_Int64);

  160.         output.writeInt64 (data.int64Value);

  161.     }

  162. };

  163. 

  164. //==============================================================================

  165. class var::VariantType_Double   : public var::VariantType

  166. {

  167. public:

  168.     VariantType_Double() noexcept {}

  169.     static const VariantType_Double instance;

  170. 

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

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

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

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

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

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

  177. 

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

  179.     {

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

  181.     }

  182. 

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

  184.     {

  185.         output.writeCompressedInt (9);

  186.         output.writeByte (varMarker_Double);

  187.         output.writeDouble (data.doubleValue);

  188.     }

  189. };

  190. 

  191. //==============================================================================

  192. class var::VariantType_Bool   : public var::VariantType

  193. {

  194. public:

  195.     VariantType_Bool() noexcept {}

  196.     static const VariantType_Bool instance;

  197. 

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

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

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

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

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

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

  204. 

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

  206.     {

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

  208.     }

  209. 

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

  211.     {

  212.         output.writeCompressedInt (1);

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

  214.     }

  215. };

  216. 

  217. //==============================================================================

  218. class var::VariantType_String   : public var::VariantType

  219. {

  220. public:

  221.     VariantType_String() noexcept {}

  222.     static const VariantType_String instance;

  223. 

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

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

  226. 

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

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

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

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

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

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

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

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

  235. 

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

  237.     {

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

  239.     }

  240. 

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

  242.     {

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

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

  245.         HeapBlock<char> temp (len);

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

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

  248.         output.writeByte (varMarker_String);

  249.         output.write (temp, len);

  250.     }

  251. 

  252. private:

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

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

  255. };

  256. 

  257. //==============================================================================

  258. class var::VariantType_Object   : public var::VariantType

  259. {

  260. public:

  261.     VariantType_Object() noexcept {}

  262.     static const VariantType_Object instance;

  263. 

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

  265. 

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

  267.     {

  268.         dest.objectValue = source.objectValue;

  269.         if (dest.objectValue != nullptr)

  270.             dest.objectValue->incReferenceCount();

  271.     }

  272. 

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

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

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

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

  277. 

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

  279.     {

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

  281.     }

  282. 

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

  284.     {

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

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

  287. 

  288.         jassertfalse; // can only clone DynamicObjects!

  289.         return {};

  290.     }

  291. 

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

  293.     {

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

  295.         output.writeCompressedInt (0);

  296.     }

  297. };

  298. 

  299. //==============================================================================

  300. class var::VariantType_Array   : public var::VariantType_Object

  301. {

  302. public:

  303.     VariantType_Array() noexcept {}

  304.     static const VariantType_Array instance;

  305. 

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

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

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

  309. 

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

  311.     {

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

  313.             return &(a->array);

  314. 

  315.         return nullptr;

  316.     }

  317. 

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

  319.     {

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

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

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

  323.     }

  324. 

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

  326.     {

  327.         Array<var> arrayCopy;

  328. 

  329.         if (auto* array = toArray (original.value))

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

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

  332. 

  333.         return var (arrayCopy);

  334.     }

  335. 

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

  337.     {

  338.         if (auto* array = toArray (data))

  339.         {

  340.             MemoryOutputStream buffer (512);

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

  342.             buffer.writeCompressedInt (numItems);

  343. 

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

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

  346. 

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

  348.             output.writeByte (varMarker_Array);

  349.             output << buffer;

  350.         }

  351.     }

  352. 

  353.     struct RefCountedArray  : public ReferenceCountedObject

  354.     {

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

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

  357.         Array<var> array;

  358.     };

  359. };

  360. 

  361. //==============================================================================

  362. class var::VariantType_Binary   : public var::VariantType

  363. {

  364. public:

  365.     VariantType_Binary() noexcept {}

  366. 

  367.     static const VariantType_Binary instance;

  368. 

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

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

  371. 

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

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

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

  375. 

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

  377.     {

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

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

  380.     }

  381. 

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

  383.     {

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

  385.         output.writeByte (varMarker_Binary);

  386.         output << *data.binaryValue;

  387.     }

  388. };

  389. 

  390. //==============================================================================

  391. class var::VariantType_Method   : public var::VariantType

  392. {

  393. public:

  394.     VariantType_Method() noexcept {}

  395.     static const VariantType_Method instance;

  396. 

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

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

  399. 

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

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

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

  403. 

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

  405.     {

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

  407.     }

  408. 

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

  410.     {

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

  412.         output.writeCompressedInt (0);

  413.     }

  414. };

  415. 

  416. //==============================================================================

  417. const var::VariantType_Void         var::VariantType_Void::instance;

  418. const var::VariantType_Undefined    var::VariantType_Undefined::instance;

  419. const var::VariantType_Int          var::VariantType_Int::instance;

  420. const var::VariantType_Int64        var::VariantType_Int64::instance;

  421. const var::VariantType_Bool         var::VariantType_Bool::instance;

  422. const var::VariantType_Double       var::VariantType_Double::instance;

  423. const var::VariantType_String       var::VariantType_String::instance;

  424. const var::VariantType_Object       var::VariantType_Object::instance;

  425. const var::VariantType_Array        var::VariantType_Array::instance;

  426. const var::VariantType_Binary       var::VariantType_Binary::instance;

  427. const var::VariantType_Method       var::VariantType_Method::instance;

  428. 

  429. 

  430. //==============================================================================

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

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

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

  434. 

  435. #if JUCE_ALLOW_STATIC_NULL_VARIABLES

  436. const var var::null;

  437. #endif

  438. 

  439. //==============================================================================

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

  441. {

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

  443. }

  444. 

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

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

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

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

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

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

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

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

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

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

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

  456. 

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

  458. {

  459.     Array<var> strings;

  460. 

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

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

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

  464. 

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

  466. }

  467. 

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

  469. {

  470.     value.objectValue = object;

  471. 

  472.     if (object != nullptr)

  473.         object->incReferenceCount();

  474. }

  475. 

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

  477. 

  478. //==============================================================================

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

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

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

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

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

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

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

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

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

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

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

  490. 

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

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

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

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

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

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

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

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

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

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

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

  502. 

  503. //==============================================================================

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

  505. {

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

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

  508. }

  509. 

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

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

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

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

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

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

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

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

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

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

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

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

  522. 

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

  524.     : type (other.type),

  525.       value (other.value)

  526. {

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

  528. }

  529. 

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

  531. {

  532.     swapWith (other);

  533.     return *this;

  534. }

  535. 

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

  537. {

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

  539. }

  540. 

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

  542. {

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

  544. }

  545. 

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

  547. {

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

  549. }

  550. 

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

  552. {

  553.     type->cleanUp (value);

  554.     type = &VariantType_String::instance;

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

  556.     return *this;

  557. }

  558. 

  559. //==============================================================================

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

  561. {

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

  563. }

  564. 

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

  566. {

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

  568. }

  569. 

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

  571. {

  572.     return type == other.type;

  573. }

  574. 

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

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

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

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

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

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

  581. 

  582. //==============================================================================

  583. var var::clone() const noexcept

  584. {

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

  586. }

  587. 

  588. //==============================================================================

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

  590. {

  591.     if (auto* o = getDynamicObject())

  592.         return o->getProperty (propertyName);

  593. 

  594.     return getNullVarRef();

  595. }

  596. 

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

  598. {

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

  600. }

  601. 

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

  603. {

  604.     if (auto* o = getDynamicObject())

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

  606. 

  607.     return defaultReturnValue;

  608. }

  609. 

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

  611. {

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

  613. }

  614. 

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

  616. {

  617.     if (auto* o = getDynamicObject())

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

  619. 

  620.     return {};

  621. }

  622. 

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

  624. {

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

  626. }

  627. 

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

  629. {

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

  631. }

  632. 

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

  634. {

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

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

  637. }

  638. 

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

  640. {

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

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

  643. }

  644. 

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

  646. {

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

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

  649. }

  650. 

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

  652. {

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

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

  655. }

  656. 

  657. //==============================================================================

  658. int var::size() const

  659. {

  660.     if (auto* array = getArray())

  661.         return array->size();

  662. 

  663.     return 0;

  664. }

  665. 

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

  667. {

  668.     auto* array = getArray();

  669. 

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

  671.     // must be in-range!

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

  673. 

  674.     return array->getReference (arrayIndex);

  675. }

  676. 

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

  678. {

  679.     auto* array = getArray();

  680. 

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

  682.     // must be in-range!

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

  684. 

  685.     return array->getReference (arrayIndex);

  686. }

  687. 

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

  689. {

  690.     if (auto* array = getArray())

  691.         return array;

  692. 

  693.     Array<var> tempVar;

  694.     if (! isVoid())

  695.         tempVar.add (*this);

  696. 

  697.     *this = tempVar;

  698.     return getArray();

  699. }

  700. 

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

  702. {

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

  704. }

  705. 

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

  707. {

  708.     if (auto* const array = getArray())

  709.         array->remove (index);

  710. }

  711. 

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

  713. {

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

  715. }

  716. 

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

  718. {

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

  720. }

  721. 

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

  723. {

  724.     if (auto* const array = getArray())

  725.         return array->indexOf (n);

  726. 

  727.     return -1;

  728. }

  729. 

  730. //==============================================================================

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

  732. {

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

  734. }

  735. 

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

  737. {

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

  739. 

  740.     if (numBytes > 0)

  741.     {

  742.         switch (input.readByte())

  743.         {

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

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

  746.             case varMarker_BoolTrue:    return var (true);

  747.             case varMarker_BoolFalse:   return var (false);

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

  749.             case varMarker_String:

  750.             {

  751.                 MemoryOutputStream mo;

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

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

  754.             }

  755. 

  756.             case varMarker_Binary:

  757.             {

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

  759. 

  760.                 if (numBytes > 1)

  761.                 {

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

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

  764.                 }

  765. 

  766.                 return var (mb);

  767.             }

  768. 

  769.             case varMarker_Array:

  770.             {

  771.                 var v;

  772.                 auto* destArray = v.convertToArray();

  773. 

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

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

  776. 

  777.                 return v;

  778.             }

  779. 

  780.             default:

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

  782.         }

  783.     }

  784. 

  785.     return {};

  786. }

  787. 

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

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

  790. {}

  791. 

  792. } // namespace juce