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

710 lines
30KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the juce_core module of the JUCE library.

  5.    Copyright (c) 2013 - Raw Material Software Ltd.

  6. 

  7.    Permission to use, copy, modify, and/or distribute this software for any purpose with

  8.    or without fee is hereby granted, provided that the above copyright notice and this

  9.    permission notice appear in all copies.

  10. 

  11.    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD

  12.    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN

  13.    NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL

  14.    DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER

  15.    IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN

  16.    CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  17. 

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

  19. 

  20.    NOTE! This permissive ISC license applies ONLY to files within the juce_core module!

  21.    All other JUCE modules are covered by a dual GPL/commercial license, so if you are

  22.    using any other modules, be sure to check that you also comply with their license.

  23. 

  24.    For more details, visit www.juce.com

  25. 

  26.   ==============================================================================

  27. */

  28. 

  29. enum VariantStreamMarkers

  30. {

  31.     varMarker_Int       = 1,

  32.     varMarker_BoolTrue  = 2,

  33.     varMarker_BoolFalse = 3,

  34.     varMarker_Double    = 4,

  35.     varMarker_String    = 5,

  36.     varMarker_Int64     = 6,

  37.     varMarker_Array     = 7,

  38.     varMarker_Binary    = 8

  39. };

  40. 

  41. //==============================================================================

  42. class var::VariantType

  43. {

  44. public:

  45.     VariantType() noexcept {}

  46.     virtual ~VariantType() noexcept {}

  47. 

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

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

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

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

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

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

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

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

  56. 

  57.     virtual bool isVoid() 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    { return true; }

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

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

  84. };

  85. 

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

  87. class var::VariantType_Int  : public var::VariantType

  88. {

  89. public:

  90.     VariantType_Int() noexcept {}

  91.     static const VariantType_Int instance;

  92. 

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

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

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

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

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

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

  99. 

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

  101.     {

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

  103.     }

  104. 

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

  106.     {

  107.         output.writeCompressedInt (5);

  108.         output.writeByte (varMarker_Int);

  109.         output.writeInt (data.intValue);

  110.     }

  111. };

  112. 

  113. //==============================================================================

  114. class var::VariantType_Int64  : public var::VariantType

  115. {

  116. public:

  117.     VariantType_Int64() noexcept {}

  118.     static const VariantType_Int64 instance;

  119. 

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

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

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

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

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

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

  126. 

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

  128.     {

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

  130.     }

  131. 

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

  133.     {

  134.         output.writeCompressedInt (9);

  135.         output.writeByte (varMarker_Int64);

  136.         output.writeInt64 (data.int64Value);

  137.     }

  138. };

  139. 

  140. //==============================================================================

  141. class var::VariantType_Double   : public var::VariantType

  142. {

  143. public:

  144.     VariantType_Double() noexcept {}

  145.     static const VariantType_Double instance;

  146. 

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

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

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

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

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

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

  153. 

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

  155.     {

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

  157.     }

  158. 

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

  160.     {

  161.         output.writeCompressedInt (9);

  162.         output.writeByte (varMarker_Double);

  163.         output.writeDouble (data.doubleValue);

  164.     }

  165. };

  166. 

  167. //==============================================================================

  168. class var::VariantType_Bool   : public var::VariantType

  169. {

  170. public:

  171.     VariantType_Bool() noexcept {}

  172.     static const VariantType_Bool instance;

  173. 

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

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

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

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

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

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

  180. 

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

  182.     {

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

  184.     }

  185. 

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

  187.     {

  188.         output.writeCompressedInt (1);

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

  190.     }

  191. };

  192. 

  193. //==============================================================================

  194. class var::VariantType_String   : public var::VariantType

  195. {

  196. public:

  197.     VariantType_String() noexcept {}

  198.     static const VariantType_String instance;

  199. 

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

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

  202. 

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

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

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

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

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

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

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

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

  211. 

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

  213.     {

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

  215.     }

  216. 

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

  218.     {

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

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

  221.         HeapBlock<char> temp (len);

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

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

  224.         output.writeByte (varMarker_String);

  225.         output.write (temp, len);

  226.     }

  227. 

  228. private:

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

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

  231. };

  232. 

  233. //==============================================================================

  234. class var::VariantType_Object   : public var::VariantType

  235. {

  236. public:

  237.     VariantType_Object() noexcept {}

  238.     static const VariantType_Object instance;

  239. 

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

  241. 

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

  243.     {

  244.         dest.objectValue = source.objectValue;

  245.         if (dest.objectValue != nullptr)

  246.             dest.objectValue->incReferenceCount();

  247.     }

  248. 

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

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

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

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

  253. 

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

  255.     {

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

  257.     }

  258. 

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

  260.     {

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

  262.         output.writeCompressedInt (0);

  263.     }

  264. };

  265. 

  266. //==============================================================================

  267. class var::VariantType_Array   : public var::VariantType

  268. {

  269. public:

  270.     VariantType_Array() noexcept {}

  271.     static const VariantType_Array instance;

  272. 

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

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

  275. 

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

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

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

  279. 

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

  281.     {

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

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

  284.     }

  285. 

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

  287.     {

  288.         MemoryOutputStream buffer (512);

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

  290.         buffer.writeCompressedInt (numItems);

  291. 

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

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

  294. 

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

  296.         output.writeByte (varMarker_Array);

  297.         output << buffer;

  298.     }

  299. };

  300. 

  301. //==============================================================================

  302. class var::VariantType_Binary   : public var::VariantType

  303. {

  304. public:

  305.     VariantType_Binary() noexcept {}

  306. 

  307.     static const VariantType_Binary instance;

  308. 

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

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

  311. 

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

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

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

  315. 

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

  317.     {

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

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

  320.     }

  321. 

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

  323.     {

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

  325.         output.writeByte (varMarker_Binary);

  326.         output << *data.binaryValue;

  327.     }

  328. };

  329. 

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

  331. class var::VariantType_Method   : public var::VariantType

  332. {

  333. public:

  334.     VariantType_Method() noexcept {}

  335.     static const VariantType_Method instance;

  336. 

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

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

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

  340. 

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

  342.     {

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

  344.     }

  345. 

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

  347.     {

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

  349.         output.writeCompressedInt (0);

  350.     }

  351. };

  352. 

  353. //==============================================================================

  354. const var::VariantType_Void    var::VariantType_Void::instance;

  355. const var::VariantType_Int     var::VariantType_Int::instance;

  356. const var::VariantType_Int64   var::VariantType_Int64::instance;

  357. const var::VariantType_Bool    var::VariantType_Bool::instance;

  358. const var::VariantType_Double  var::VariantType_Double::instance;

  359. const var::VariantType_String  var::VariantType_String::instance;

  360. const var::VariantType_Object  var::VariantType_Object::instance;

  361. const var::VariantType_Array   var::VariantType_Array::instance;

  362. const var::VariantType_Binary  var::VariantType_Binary::instance;

  363. const var::VariantType_Method  var::VariantType_Method::instance;

  364. 

  365. 

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

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

  368. {

  369. }

  370. 

  371. var::~var() noexcept

  372. {

  373.     type->cleanUp (value);

  374. }

  375. 

  376. const var var::null;

  377. 

  378. //==============================================================================

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

  380. {

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

  382. }

  383. 

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

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

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

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

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

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

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

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

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

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

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

  395. 

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

  397. {

  398.     value.objectValue = object;

  399. 

  400.     if (object != nullptr)

  401.         object->incReferenceCount();

  402. }

  403. 

  404. 

  405. //==============================================================================

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

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

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

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

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

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

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

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

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

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

  416. 

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

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

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

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

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

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

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

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

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

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

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

  428. 

  429. //==============================================================================

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

  431. {

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

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

  434. }

  435. 

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

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

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

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

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

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

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

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

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

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

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

  447. 

  448. #if JUCE_COMPILER_SUPPORTS_MOVE_SEMANTICS

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

  450.     : type (other.type),

  451.       value (other.value)

  452. {

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

  454. }

  455. 

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

  457. {

  458.     swapWith (other);

  459.     return *this;

  460. }

  461. 

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

  463. {

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

  465. }

  466. 

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

  468. {

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

  470. }

  471. 

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

  473. {

  474.     type->cleanUp (value);

  475.     type = &VariantType_String::instance;

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

  477.     return *this;

  478. }

  479. #endif

  480. 

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

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

  483. {

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

  485. }

  486. 

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

  488. {

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

  490. }

  491. 

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

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

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

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

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

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

  498. 

  499. 

  500. //==============================================================================

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

  502. {

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

  504.         return o->getProperty (propertyName);

  505. 

  506.     return var::null;

  507. }

  508. 

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

  510. {

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

  512. }

  513. 

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

  515. {

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

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

  518. 

  519.     return defaultReturnValue;

  520. }

  521. 

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

  523. {

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

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

  526. 

  527.     return var::null;

  528. }

  529. 

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

  531. {

  532.     jassert (target != nullptr);

  533. 

  534.     if (isMethod())

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

  536. 

  537.     return var::null;

  538. }

  539. 

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

  541. {

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

  543. }

  544. 

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

  546. {

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

  548. }

  549. 

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

  551. {

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

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

  554. }

  555. 

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

  557. {

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

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

  560. }

  561. 

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

  563. {

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

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

  566. }

  567. 

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

  569. {

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

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

  572. }

  573. 

  574. //==============================================================================

  575. int var::size() const

  576. {

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

  578.         return array->size();

  579. 

  580.     return 0;

  581. }

  582. 

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

  584. {

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

  586. 

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

  588.     // must be in-range!

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

  590. 

  591.     return array->getReference (arrayIndex);

  592. }

  593. 

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

  595. {

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

  597. 

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

  599.     // must be in-range!

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

  601. 

  602.     return array->getReference (arrayIndex);

  603. }

  604. 

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

  606. {

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

  608. 

  609.     if (array == nullptr)

  610.     {

  611.         const Array<var> tempVar;

  612.         var v (tempVar);

  613.         array = v.value.arrayValue;

  614. 

  615.         if (! isVoid())

  616.             array->add (*this);

  617. 

  618.         swapWith (v);

  619.     }

  620. 

  621.     return array;

  622. }

  623. 

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

  625. {

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

  627. }

  628. 

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

  630. {

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

  632.         array->remove (index);

  633. }

  634. 

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

  636. {

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

  638. }

  639. 

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

  641. {

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

  643. }

  644. 

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

  646. {

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

  648.         return array->indexOf (n);

  649. 

  650.     return -1;

  651. }

  652. 

  653. //==============================================================================

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

  655. {

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

  657. }

  658. 

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

  660. {

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

  662. 

  663.     if (numBytes > 0)

  664.     {

  665.         switch (input.readByte())

  666.         {

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

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

  669.             case varMarker_BoolTrue:    return var (true);

  670.             case varMarker_BoolFalse:   return var (false);

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

  672.             case varMarker_String:

  673.             {

  674.                 MemoryOutputStream mo;

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

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

  677.             }

  678. 

  679.             case varMarker_Binary:

  680.             {

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

  682. 

  683.                 if (numBytes > 1)

  684.                 {

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

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

  687.                 }

  688. 

  689.                 return var (mb);

  690.             }

  691. 

  692.             case varMarker_Array:

  693.             {

  694.                 var v;

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

  696. 

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

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

  699. 

  700.                 return v;

  701.             }

  702. 

  703.             default:

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

  705.         }

  706.     }

  707. 

  708.     return var::null;

  709. }