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.
2928 Commits
11 Branches
1.4GB
Tree: cc26ae1fc1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cc26ae1fc1'
${ noResults }
JUCE/modules/juce_core/containers/juce_Variant.cpp

651 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

  14.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  16.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

  20.    To release a closed-source product which uses JUCE, commercial licenses are

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  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. };

  36. 

  37. //==============================================================================

  38. class var::VariantType

  39. {

  40. public:

  41.     VariantType() noexcept {}

  42.     virtual ~VariantType() noexcept {}

  43. 

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

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

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

  47.     virtual String toString (const ValueUnion&) const                           { return String::empty; }

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

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

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

  51. 

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

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

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

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

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

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

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

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

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

  61. 

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

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

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

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

  66. };

  67. 

  68. //==============================================================================

  69. class var::VariantType_Void  : public var::VariantType

  70. {

  71. public:

  72.     VariantType_Void() noexcept {}

  73.     static const VariantType_Void instance;

  74. 

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

  76.     bool equals (const ValueUnion&, const ValueUnion&, const VariantType& otherType) const noexcept { return otherType.isVoid(); }

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

  78. };

  79. 

  80. //==============================================================================

  81. class var::VariantType_Int  : public var::VariantType

  82. {

  83. public:

  84.     VariantType_Int() noexcept {}

  85.     static const VariantType_Int instance;

  86. 

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

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

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

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

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

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

  93. 

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

  95.     {

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

  97.     }

  98. 

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

  100.     {

  101.         output.writeCompressedInt (5);

  102.         output.writeByte (varMarker_Int);

  103.         output.writeInt (data.intValue);

  104.     }

  105. };

  106. 

  107. //==============================================================================

  108. class var::VariantType_Int64  : public var::VariantType

  109. {

  110. public:

  111.     VariantType_Int64() noexcept {}

  112.     static const VariantType_Int64 instance;

  113. 

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

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

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

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

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

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

  120. 

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

  122.     {

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

  124.     }

  125. 

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

  127.     {

  128.         output.writeCompressedInt (9);

  129.         output.writeByte (varMarker_Int64);

  130.         output.writeInt64 (data.int64Value);

  131.     }

  132. };

  133. 

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

  135. class var::VariantType_Double   : public var::VariantType

  136. {

  137. public:

  138.     VariantType_Double() noexcept {}

  139.     static const VariantType_Double instance;

  140. 

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

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

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

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

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

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

  147. 

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

  149.     {

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

  151.     }

  152. 

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

  154.     {

  155.         output.writeCompressedInt (9);

  156.         output.writeByte (varMarker_Double);

  157.         output.writeDouble (data.doubleValue);

  158.     }

  159. };

  160. 

  161. //==============================================================================

  162. class var::VariantType_Bool   : public var::VariantType

  163. {

  164. public:

  165.     VariantType_Bool() noexcept {}

  166.     static const VariantType_Bool instance;

  167. 

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

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

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

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

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

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

  174. 

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

  176.     {

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

  178.     }

  179. 

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

  181.     {

  182.         output.writeCompressedInt (1);

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

  184.     }

  185. };

  186. 

  187. //==============================================================================

  188. class var::VariantType_String   : public var::VariantType

  189. {

  190. public:

  191.     VariantType_String() noexcept {}

  192.     static const VariantType_String instance;

  193. 

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

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

  196. 

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

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

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

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

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

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

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

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

  205. 

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

  207.     {

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

  209.     }

  210. 

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

  212.     {

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

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

  215.         HeapBlock<char> temp (len);

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

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

  218.         output.writeByte (varMarker_String);

  219.         output.write (temp, len);

  220.     }

  221. 

  222. private:

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

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

  225. };

  226. 

  227. //==============================================================================

  228. class var::VariantType_Object   : public var::VariantType

  229. {

  230. public:

  231.     VariantType_Object() noexcept {}

  232.     static const VariantType_Object instance;

  233. 

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

  235. 

  236.     void createCopy (ValueUnion& dest, const ValueUnion& source) const

  237.     {

  238.         dest.objectValue = source.objectValue;

  239.         if (dest.objectValue != nullptr)

  240.             dest.objectValue->incReferenceCount();

  241.     }

  242. 

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

  244.     bool toBool (const ValueUnion& data) const noexcept                       { return data.objectValue != 0; }

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

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

  247. 

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

  249.     {

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

  251.     }

  252. 

  253.     void writeToStream (const ValueUnion&, OutputStream& output) const

  254.     {

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

  256.         output.writeCompressedInt (0);

  257.     }

  258. };

  259. 

  260. //==============================================================================

  261. class var::VariantType_Array   : public var::VariantType

  262. {

  263. public:

  264.     VariantType_Array() noexcept {}

  265.     static const VariantType_Array instance;

  266. 

  267.     void cleanUp (ValueUnion& data) const noexcept                      { delete data.arrayValue; }

  268.     void createCopy (ValueUnion& dest, const ValueUnion& source) const  { dest.arrayValue = new Array<var> (*(source.arrayValue)); }

  269. 

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

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

  272.     Array<var>* toArray (const ValueUnion& data) const noexcept         { return data.arrayValue; }

  273. 

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

  275.     {

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

  277.         return otherArray != nullptr && *otherArray == *(data.arrayValue);

  278.     }

  279. 

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

  281.     {

  282.         MemoryOutputStream buffer (512);

  283.         const int numItems = data.arrayValue->size();

  284.         buffer.writeCompressedInt (numItems);

  285. 

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

  287.             data.arrayValue->getReference(i).writeToStream (buffer);

  288. 

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

  290.         output.writeByte (varMarker_Array);

  291.         output << buffer;

  292.     }

  293. };

  294. 

  295. //==============================================================================

  296. class var::VariantType_Method   : public var::VariantType

  297. {

  298. public:

  299.     VariantType_Method() noexcept {}

  300.     static const VariantType_Method instance;

  301. 

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

  303.     bool toBool (const ValueUnion& data) const noexcept     { return data.methodValue != 0; }

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

  305. 

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

  307.     {

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

  309.     }

  310. 

  311.     void writeToStream (const ValueUnion&, OutputStream& output) const

  312.     {

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

  314.         output.writeCompressedInt (0);

  315.     }

  316. };

  317. 

  318. //==============================================================================

  319. const var::VariantType_Void    var::VariantType_Void::instance;

  320. const var::VariantType_Int     var::VariantType_Int::instance;

  321. const var::VariantType_Int64   var::VariantType_Int64::instance;

  322. const var::VariantType_Bool    var::VariantType_Bool::instance;

  323. const var::VariantType_Double  var::VariantType_Double::instance;

  324. const var::VariantType_String  var::VariantType_String::instance;

  325. const var::VariantType_Object  var::VariantType_Object::instance;

  326. const var::VariantType_Array   var::VariantType_Array::instance;

  327. const var::VariantType_Method  var::VariantType_Method::instance;

  328. 

  329. 

  330. //==============================================================================

  331. var::var() noexcept : type (&VariantType_Void::instance)

  332. {

  333. }

  334. 

  335. var::~var() noexcept

  336. {

  337.     type->cleanUp (value);

  338. }

  339. 

  340. const var var::null;

  341. 

  342. //==============================================================================

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

  344. {

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

  346. }

  347. 

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

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

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

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

  352. var::var (MethodFunction m) noexcept  : type (&VariantType_Method::instance) { value.methodValue = m; }

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

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

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

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

  357. 

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

  359. {

  360.     value.objectValue = object;

  361. 

  362.     if (object != nullptr)

  363.         object->incReferenceCount();

  364. }

  365. 

  366. //==============================================================================

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

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

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

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

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

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

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

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

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

  376. 

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

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

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

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

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

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

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

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

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

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

  387. 

  388. //==============================================================================

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

  390. {

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

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

  393. }

  394. 

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

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

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

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

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

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

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

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

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

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

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

  406. 

  407. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

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

  409.     : type (other.type),

  410.       value (other.value)

  411. {

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

  413. }

  414. 

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

  416. {

  417.     swapWith (other);

  418.     return *this;

  419. }

  420. 

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

  422. {

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

  424. }

  425. 

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

  427. {

  428.     type->cleanUp (value);

  429.     type = &VariantType_String::instance;

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

  431.     return *this;

  432. }

  433. #endif

  434. 

  435. //==============================================================================

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

  437. {

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

  439. }

  440. 

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

  442. {

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

  444. }

  445. 

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

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

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

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

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

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

  452. 

  453. 

  454. //==============================================================================

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

  456. {

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

  458.         return o->getProperty (propertyName);

  459. 

  460.     return var::null;

  461. }

  462. 

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

  464. {

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

  466. }

  467. 

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

  469. {

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

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

  472. 

  473.     return defaultReturnValue;

  474. }

  475. 

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

  477. {

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

  479.         return o->invokeMethod (method, arguments, numArguments);

  480. 

  481.     return var::null;

  482. }

  483. 

  484. var var::invokeMethod (DynamicObject* const target, const var* const arguments, const int numArguments) const

  485. {

  486.     jassert (target != nullptr);

  487. 

  488.     if (isMethod())

  489.         return (target->*(value.methodValue)) (arguments, numArguments);

  490. 

  491.     return var::null;

  492. }

  493. 

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

  495. {

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

  497. }

  498. 

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

  500. {

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

  502. }

  503. 

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

  505. {

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

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

  508. }

  509. 

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

  511. {

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

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

  514. }

  515. 

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

  517. {

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

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

  520. }

  521. 

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

  523. {

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

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

  526. }

  527. 

  528. //==============================================================================

  529. int var::size() const

  530. {

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

  532.         return array->size();

  533. 

  534.     return 0;

  535. }

  536. 

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

  538. {

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

  540. 

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

  542.     // must be in-range!

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

  544. 

  545.     return array->getReference (arrayIndex);

  546. }

  547. 

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

  549. {

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

  551. 

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

  553.     // must be in-range!

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

  555. 

  556.     return array->getReference (arrayIndex);

  557. }

  558. 

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

  560. {

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

  562. 

  563.     if (array == nullptr)

  564.     {

  565.         const Array<var> tempVar;

  566.         var v (tempVar);

  567.         array = v.value.arrayValue;

  568. 

  569.         if (! isVoid())

  570.             array->add (*this);

  571. 

  572.         swapWith (v);

  573.     }

  574. 

  575.     return array;

  576. }

  577. 

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

  579. {

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

  581. }

  582. 

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

  584. {

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

  586.         array->remove (index);

  587. }

  588. 

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

  590. {

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

  592. }

  593. 

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

  595. {

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

  597. }

  598. 

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

  600. {

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

  602.         return array->indexOf (n);

  603. 

  604.     return -1;

  605. }

  606. 

  607. //==============================================================================

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

  609. {

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

  611. }

  612. 

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

  614. {

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

  616. 

  617.     if (numBytes > 0)

  618.     {

  619.         switch (input.readByte())

  620.         {

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

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

  623.             case varMarker_BoolTrue:    return var (true);

  624.             case varMarker_BoolFalse:   return var (false);

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

  626.             case varMarker_String:

  627.             {

  628.                 MemoryOutputStream mo;

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

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

  631.             }

  632. 

  633.             case varMarker_Array:

  634.             {

  635.                 var v;

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

  637. 

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

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

  640. 

  641.                 return v;

  642.             }

  643. 

  644.             default:

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

  646.         }

  647.     }

  648. 

  649.     return var::null;

  650. }