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.
3143 Commits
9 Branches
401MB
Tree: c7506df13f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c7506df13f'
${ noResults }
JUCE/modules/juce_core/containers/juce_Variant.cpp

707 lines
29KB
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.     varMarker_Binary    = 8

  36. };

  37. 

  38. //==============================================================================

  39. class var::VariantType

  40. {

  41. public:

  42.     VariantType() noexcept {}

  43.     virtual ~VariantType() noexcept {}

  44. 

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

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

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

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

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

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

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

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

  53. 

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

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

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

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

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

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

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

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

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

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

  64. 

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

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

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

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

  69. };

  70. 

  71. //==============================================================================

  72. class var::VariantType_Void  : public var::VariantType

  73. {

  74. public:

  75.     VariantType_Void() noexcept {}

  76.     static const VariantType_Void instance;

  77. 

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

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

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

  81. };

  82. 

  83. //==============================================================================

  84. class var::VariantType_Int  : public var::VariantType

  85. {

  86. public:

  87.     VariantType_Int() noexcept {}

  88.     static const VariantType_Int instance;

  89. 

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

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

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

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

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

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

  96. 

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

  98.     {

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

  100.     }

  101. 

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

  103.     {

  104.         output.writeCompressedInt (5);

  105.         output.writeByte (varMarker_Int);

  106.         output.writeInt (data.intValue);

  107.     }

  108. };

  109. 

  110. //==============================================================================

  111. class var::VariantType_Int64  : public var::VariantType

  112. {

  113. public:

  114.     VariantType_Int64() noexcept {}

  115.     static const VariantType_Int64 instance;

  116. 

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

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

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

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

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

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

  123. 

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

  125.     {

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

  127.     }

  128. 

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

  130.     {

  131.         output.writeCompressedInt (9);

  132.         output.writeByte (varMarker_Int64);

  133.         output.writeInt64 (data.int64Value);

  134.     }

  135. };

  136. 

  137. //==============================================================================

  138. class var::VariantType_Double   : public var::VariantType

  139. {

  140. public:

  141.     VariantType_Double() noexcept {}

  142.     static const VariantType_Double instance;

  143. 

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

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

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

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

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

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

  150. 

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

  152.     {

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

  154.     }

  155. 

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

  157.     {

  158.         output.writeCompressedInt (9);

  159.         output.writeByte (varMarker_Double);

  160.         output.writeDouble (data.doubleValue);

  161.     }

  162. };

  163. 

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

  165. class var::VariantType_Bool   : public var::VariantType

  166. {

  167. public:

  168.     VariantType_Bool() noexcept {}

  169.     static const VariantType_Bool instance;

  170. 

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

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

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

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

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

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

  177. 

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

  179.     {

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

  181.     }

  182. 

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

  184.     {

  185.         output.writeCompressedInt (1);

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

  187.     }

  188. };

  189. 

  190. //==============================================================================

  191. class var::VariantType_String   : public var::VariantType

  192. {

  193. public:

  194.     VariantType_String() noexcept {}

  195.     static const VariantType_String instance;

  196. 

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

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

  199. 

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

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

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

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

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

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

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

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

  208. 

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

  210.     {

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

  212.     }

  213. 

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

  215.     {

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

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

  218.         HeapBlock<char> temp (len);

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

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

  221.         output.writeByte (varMarker_String);

  222.         output.write (temp, len);

  223.     }

  224. 

  225. private:

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

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

  228. };

  229. 

  230. //==============================================================================

  231. class var::VariantType_Object   : public var::VariantType

  232. {

  233. public:

  234.     VariantType_Object() noexcept {}

  235.     static const VariantType_Object instance;

  236. 

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

  238. 

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

  240.     {

  241.         dest.objectValue = source.objectValue;

  242.         if (dest.objectValue != nullptr)

  243.             dest.objectValue->incReferenceCount();

  244.     }

  245. 

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

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

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

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

  250. 

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

  252.     {

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

  254.     }

  255. 

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

  257.     {

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

  259.         output.writeCompressedInt (0);

  260.     }

  261. };

  262. 

  263. //==============================================================================

  264. class var::VariantType_Array   : public var::VariantType

  265. {

  266. public:

  267.     VariantType_Array() noexcept {}

  268.     static const VariantType_Array instance;

  269. 

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

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

  272. 

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

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

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

  276. 

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

  278.     {

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

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

  281.     }

  282. 

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

  284.     {

  285.         MemoryOutputStream buffer (512);

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

  287.         buffer.writeCompressedInt (numItems);

  288. 

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

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

  291. 

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

  293.         output.writeByte (varMarker_Array);

  294.         output << buffer;

  295.     }

  296. };

  297. 

  298. //==============================================================================

  299. class var::VariantType_Binary   : public var::VariantType

  300. {

  301. public:

  302.     VariantType_Binary() noexcept {}

  303. 

  304.     static const VariantType_Binary instance;

  305. 

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

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

  308. 

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

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

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

  312. 

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

  314.     {

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

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

  317.     }

  318. 

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

  320.     {

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

  322.         output.writeByte (varMarker_Binary);

  323.         output << *data.binaryValue;

  324.     }

  325. };

  326. 

  327. //==============================================================================

  328. class var::VariantType_Method   : public var::VariantType

  329. {

  330. public:

  331.     VariantType_Method() noexcept {}

  332.     static const VariantType_Method instance;

  333. 

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

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

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

  337. 

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

  339.     {

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

  341.     }

  342. 

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

  344.     {

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

  346.         output.writeCompressedInt (0);

  347.     }

  348. };

  349. 

  350. //==============================================================================

  351. const var::VariantType_Void    var::VariantType_Void::instance;

  352. const var::VariantType_Int     var::VariantType_Int::instance;

  353. const var::VariantType_Int64   var::VariantType_Int64::instance;

  354. const var::VariantType_Bool    var::VariantType_Bool::instance;

  355. const var::VariantType_Double  var::VariantType_Double::instance;

  356. const var::VariantType_String  var::VariantType_String::instance;

  357. const var::VariantType_Object  var::VariantType_Object::instance;

  358. const var::VariantType_Array   var::VariantType_Array::instance;

  359. const var::VariantType_Binary  var::VariantType_Binary::instance;

  360. const var::VariantType_Method  var::VariantType_Method::instance;

  361. 

  362. 

  363. //==============================================================================

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

  365. {

  366. }

  367. 

  368. var::~var() noexcept

  369. {

  370.     type->cleanUp (value);

  371. }

  372. 

  373. const var var::null;

  374. 

  375. //==============================================================================

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

  377. {

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

  379. }

  380. 

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

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

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

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

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

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

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

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

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

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

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

  392. 

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

  394. {

  395.     value.objectValue = object;

  396. 

  397.     if (object != nullptr)

  398.         object->incReferenceCount();

  399. }

  400. 

  401. 

  402. //==============================================================================

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

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

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

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

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

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

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

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

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

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

  413. 

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

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

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

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

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

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

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

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

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

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

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

  425. 

  426. //==============================================================================

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

  428. {

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

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

  431. }

  432. 

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

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

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

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

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

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

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

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

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

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

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

  444. 

  445. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

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

  447.     : type (other.type),

  448.       value (other.value)

  449. {

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

  451. }

  452. 

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

  454. {

  455.     swapWith (other);

  456.     return *this;

  457. }

  458. 

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

  460. {

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

  462. }

  463. 

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

  465. {

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

  467. }

  468. 

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

  470. {

  471.     type->cleanUp (value);

  472.     type = &VariantType_String::instance;

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

  474.     return *this;

  475. }

  476. #endif

  477. 

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

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

  480. {

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

  482. }

  483. 

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

  485. {

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

  487. }

  488. 

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

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

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

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

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

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

  495. 

  496. 

  497. //==============================================================================

  498. var var::operator[] (const Identifier propertyName) const

  499. {

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

  501.         return o->getProperty (propertyName);

  502. 

  503.     return var::null;

  504. }

  505. 

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

  507. {

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

  509. }

  510. 

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

  512. {

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

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

  515. 

  516.     return defaultReturnValue;

  517. }

  518. 

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

  520. {

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

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

  523. 

  524.     return var::null;

  525. }

  526. 

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

  528. {

  529.     jassert (target != nullptr);

  530. 

  531.     if (isMethod())

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

  533. 

  534.     return var::null;

  535. }

  536. 

  537. var var::call (const Identifier method) const

  538. {

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

  540. }

  541. 

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

  543. {

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

  545. }

  546. 

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

  548. {

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

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

  551. }

  552. 

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

  554. {

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

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

  557. }

  558. 

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

  560. {

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

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

  563. }

  564. 

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

  566. {

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

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

  569. }

  570. 

  571. //==============================================================================

  572. int var::size() const

  573. {

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

  575.         return array->size();

  576. 

  577.     return 0;

  578. }

  579. 

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

  581. {

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

  583. 

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

  585.     // must be in-range!

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

  587. 

  588.     return array->getReference (arrayIndex);

  589. }

  590. 

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

  592. {

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

  594. 

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

  596.     // must be in-range!

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

  598. 

  599.     return array->getReference (arrayIndex);

  600. }

  601. 

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

  603. {

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

  605. 

  606.     if (array == nullptr)

  607.     {

  608.         const Array<var> tempVar;

  609.         var v (tempVar);

  610.         array = v.value.arrayValue;

  611. 

  612.         if (! isVoid())

  613.             array->add (*this);

  614. 

  615.         swapWith (v);

  616.     }

  617. 

  618.     return array;

  619. }

  620. 

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

  622. {

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

  624. }

  625. 

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

  627. {

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

  629.         array->remove (index);

  630. }

  631. 

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

  633. {

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

  635. }

  636. 

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

  638. {

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

  640. }

  641. 

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

  643. {

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

  645.         return array->indexOf (n);

  646. 

  647.     return -1;

  648. }

  649. 

  650. //==============================================================================

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

  652. {

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

  654. }

  655. 

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

  657. {

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

  659. 

  660.     if (numBytes > 0)

  661.     {

  662.         switch (input.readByte())

  663.         {

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

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

  666.             case varMarker_BoolTrue:    return var (true);

  667.             case varMarker_BoolFalse:   return var (false);

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

  669.             case varMarker_String:

  670.             {

  671.                 MemoryOutputStream mo;

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

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

  674.             }

  675. 

  676.             case varMarker_Binary:

  677.             {

  678.                 MemoryBlock mb (numBytes - 1);

  679. 

  680.                 if (numBytes > 1)

  681.                 {

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

  683.                     mb.setSize (numRead);

  684.                 }

  685. 

  686.                 return var (mb);

  687.             }

  688. 

  689.             case varMarker_Array:

  690.             {

  691.                 var v;

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

  693. 

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

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

  696. 

  697.                 return v;

  698.             }

  699. 

  700.             default:

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

  702.         }

  703.     }

  704. 

  705.     return var::null;

  706. }