GVariant.cpp 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include <AK/JsonValue.h>
  27. #include <LibGUI/GVariant.h>
  28. const char* to_string(GVariant::Type type)
  29. {
  30. switch (type) {
  31. case GVariant::Type::Invalid:
  32. return "Invalid";
  33. case GVariant::Type::Bool:
  34. return "Bool";
  35. case GVariant::Type::Int32:
  36. return "Int32";
  37. case GVariant::Type::Int64:
  38. return "Int64";
  39. case GVariant::Type::UnsignedInt:
  40. return "UnsignedInt";
  41. case GVariant::Type::Float:
  42. return "Float";
  43. case GVariant::Type::String:
  44. return "String";
  45. case GVariant::Type::Bitmap:
  46. return "Bitmap";
  47. case GVariant::Type::Color:
  48. return "Color";
  49. case GVariant::Type::Icon:
  50. return "Icon";
  51. case GVariant::Type::Point:
  52. return "Point";
  53. case GVariant::Type::Size:
  54. return "Size";
  55. case GVariant::Type::Rect:
  56. return "Rect";
  57. case GVariant::Type::Font:
  58. return "Font";
  59. }
  60. ASSERT_NOT_REACHED();
  61. }
  62. GVariant::GVariant()
  63. {
  64. m_value.as_string = nullptr;
  65. }
  66. GVariant::~GVariant()
  67. {
  68. clear();
  69. }
  70. void GVariant::clear()
  71. {
  72. switch (m_type) {
  73. case Type::String:
  74. AK::unref_if_not_null(m_value.as_string);
  75. break;
  76. case Type::Bitmap:
  77. AK::unref_if_not_null(m_value.as_bitmap);
  78. break;
  79. case Type::Icon:
  80. AK::unref_if_not_null(m_value.as_icon);
  81. break;
  82. default:
  83. break;
  84. }
  85. m_type = Type::Invalid;
  86. m_value.as_string = nullptr;
  87. }
  88. GVariant::GVariant(i32 value)
  89. : m_type(Type::Int32)
  90. {
  91. m_value.as_i32 = value;
  92. }
  93. GVariant::GVariant(i64 value)
  94. : m_type(Type::Int64)
  95. {
  96. m_value.as_i64 = value;
  97. }
  98. GVariant::GVariant(unsigned value)
  99. : m_type(Type::UnsignedInt)
  100. {
  101. m_value.as_uint = value;
  102. }
  103. GVariant::GVariant(float value)
  104. : m_type(Type::Float)
  105. {
  106. m_value.as_float = value;
  107. }
  108. GVariant::GVariant(bool value)
  109. : m_type(Type::Bool)
  110. {
  111. m_value.as_bool = value;
  112. }
  113. GVariant::GVariant(const char* cstring)
  114. : GVariant(String(cstring))
  115. {
  116. }
  117. GVariant::GVariant(const String& value)
  118. : m_type(Type::String)
  119. {
  120. m_value.as_string = const_cast<StringImpl*>(value.impl());
  121. AK::ref_if_not_null(m_value.as_string);
  122. }
  123. GVariant::GVariant(const JsonValue& value)
  124. {
  125. if (value.is_null()) {
  126. m_value.as_string = nullptr;
  127. return;
  128. }
  129. if (value.is_i32()) {
  130. m_type = Type::Int32;
  131. m_value.as_i32 = value.as_i32();
  132. return;
  133. }
  134. if (value.is_u32()) {
  135. m_type = Type::UnsignedInt;
  136. m_value.as_uint = value.as_u32();
  137. return;
  138. }
  139. if (value.is_i64()) {
  140. m_type = Type::Int64;
  141. m_value.as_i64 = value.as_i64();
  142. return;
  143. }
  144. if (value.is_u64()) {
  145. // FIXME: GVariant should have a 64-bit internal type.
  146. m_type = Type::UnsignedInt;
  147. m_value.as_uint = value.to_u32();
  148. return;
  149. }
  150. if (value.is_string()) {
  151. m_type = Type::String;
  152. m_value.as_string = value.as_string().impl();
  153. m_value.as_string->ref();
  154. return;
  155. }
  156. if (value.is_bool()) {
  157. m_type = Type::Bool;
  158. m_value.as_bool = value.as_bool();
  159. return;
  160. }
  161. ASSERT_NOT_REACHED();
  162. }
  163. GVariant::GVariant(const GraphicsBitmap& value)
  164. : m_type(Type::Bitmap)
  165. {
  166. m_value.as_bitmap = const_cast<GraphicsBitmap*>(&value);
  167. AK::ref_if_not_null(m_value.as_bitmap);
  168. }
  169. GVariant::GVariant(const GIcon& value)
  170. : m_type(Type::Icon)
  171. {
  172. m_value.as_icon = &const_cast<GIconImpl&>(value.impl());
  173. AK::ref_if_not_null(m_value.as_icon);
  174. }
  175. GVariant::GVariant(const Font& value)
  176. : m_type(Type::Font)
  177. {
  178. m_value.as_font = &const_cast<Font&>(value);
  179. AK::ref_if_not_null(m_value.as_font);
  180. }
  181. GVariant::GVariant(Color color)
  182. : m_type(Type::Color)
  183. {
  184. m_value.as_color = color.value();
  185. }
  186. GVariant::GVariant(const Point& point)
  187. : m_type(Type::Point)
  188. {
  189. m_value.as_point = { point.x(), point.y() };
  190. }
  191. GVariant::GVariant(const Size& size)
  192. : m_type(Type::Size)
  193. {
  194. m_value.as_size = { size.width(), size.height() };
  195. }
  196. GVariant::GVariant(const Rect& rect)
  197. : m_type(Type::Rect)
  198. {
  199. m_value.as_rect = (const RawRect&)rect;
  200. }
  201. GVariant& GVariant::operator=(const GVariant& other)
  202. {
  203. if (&other == this)
  204. return *this;
  205. clear();
  206. copy_from(other);
  207. return *this;
  208. }
  209. GVariant& GVariant::operator=(GVariant&& other)
  210. {
  211. if (&other == this)
  212. return *this;
  213. // FIXME: Move, not copy!
  214. clear();
  215. copy_from(other);
  216. other.clear();
  217. return *this;
  218. }
  219. GVariant::GVariant(const GVariant& other)
  220. {
  221. copy_from(other);
  222. }
  223. void GVariant::copy_from(const GVariant& other)
  224. {
  225. ASSERT(!is_valid());
  226. m_type = other.m_type;
  227. switch (m_type) {
  228. case Type::Bool:
  229. m_value.as_bool = other.m_value.as_bool;
  230. break;
  231. case Type::Int32:
  232. m_value.as_i32 = other.m_value.as_i32;
  233. break;
  234. case Type::Int64:
  235. m_value.as_i64 = other.m_value.as_i64;
  236. break;
  237. case Type::UnsignedInt:
  238. m_value.as_uint = other.m_value.as_uint;
  239. break;
  240. case Type::Float:
  241. m_value.as_float = other.m_value.as_float;
  242. break;
  243. case Type::String:
  244. m_value.as_string = other.m_value.as_string;
  245. AK::ref_if_not_null(m_value.as_bitmap);
  246. break;
  247. case Type::Bitmap:
  248. m_value.as_bitmap = other.m_value.as_bitmap;
  249. AK::ref_if_not_null(m_value.as_bitmap);
  250. break;
  251. case Type::Icon:
  252. m_value.as_icon = other.m_value.as_icon;
  253. AK::ref_if_not_null(m_value.as_icon);
  254. break;
  255. case Type::Font:
  256. m_value.as_font = other.m_value.as_font;
  257. AK::ref_if_not_null(m_value.as_font);
  258. break;
  259. case Type::Color:
  260. m_value.as_color = other.m_value.as_color;
  261. break;
  262. case Type::Point:
  263. m_value.as_point = other.m_value.as_point;
  264. break;
  265. case Type::Size:
  266. m_value.as_size = other.m_value.as_size;
  267. break;
  268. case Type::Rect:
  269. m_value.as_rect = other.m_value.as_rect;
  270. break;
  271. case Type::Invalid:
  272. break;
  273. }
  274. }
  275. bool GVariant::operator==(const GVariant& other) const
  276. {
  277. if (m_type != other.m_type)
  278. return to_string() == other.to_string();
  279. switch (m_type) {
  280. case Type::Bool:
  281. return as_bool() == other.as_bool();
  282. case Type::Int32:
  283. return as_i32() == other.as_i32();
  284. case Type::Int64:
  285. return as_i64() == other.as_i64();
  286. case Type::UnsignedInt:
  287. return as_uint() == other.as_uint();
  288. case Type::Float:
  289. return as_float() == other.as_float();
  290. case Type::String:
  291. return as_string() == other.as_string();
  292. case Type::Bitmap:
  293. return m_value.as_bitmap == other.m_value.as_bitmap;
  294. case Type::Icon:
  295. return m_value.as_icon == other.m_value.as_icon;
  296. case Type::Color:
  297. return m_value.as_color == other.m_value.as_color;
  298. case Type::Point:
  299. return as_point() == other.as_point();
  300. case Type::Size:
  301. return as_size() == other.as_size();
  302. case Type::Rect:
  303. return as_rect() == other.as_rect();
  304. case Type::Font:
  305. return &as_font() == &other.as_font();
  306. case Type::Invalid:
  307. return true;
  308. }
  309. ASSERT_NOT_REACHED();
  310. }
  311. bool GVariant::operator<(const GVariant& other) const
  312. {
  313. if (m_type != other.m_type)
  314. return to_string() < other.to_string();
  315. switch (m_type) {
  316. case Type::Bool:
  317. return as_bool() < other.as_bool();
  318. case Type::Int32:
  319. return as_i32() < other.as_i32();
  320. case Type::Int64:
  321. return as_i64() < other.as_i64();
  322. case Type::UnsignedInt:
  323. return as_uint() < other.as_uint();
  324. case Type::Float:
  325. return as_float() < other.as_float();
  326. case Type::String:
  327. return as_string() < other.as_string();
  328. case Type::Bitmap:
  329. // FIXME: Maybe compare bitmaps somehow differently?
  330. return m_value.as_bitmap < other.m_value.as_bitmap;
  331. case Type::Icon:
  332. // FIXME: Maybe compare icons somehow differently?
  333. return m_value.as_icon < other.m_value.as_icon;
  334. case Type::Color:
  335. return m_value.as_color < other.m_value.as_color;
  336. case Type::Point:
  337. case Type::Size:
  338. case Type::Rect:
  339. case Type::Font:
  340. // FIXME: Figure out how to compare these.
  341. ASSERT_NOT_REACHED();
  342. case Type::Invalid:
  343. break;
  344. }
  345. ASSERT_NOT_REACHED();
  346. }
  347. String GVariant::to_string() const
  348. {
  349. switch (m_type) {
  350. case Type::Bool:
  351. return as_bool() ? "true" : "false";
  352. case Type::Int32:
  353. return String::number(as_i32());
  354. case Type::Int64:
  355. return String::number(as_i64());
  356. case Type::UnsignedInt:
  357. return String::number(as_uint());
  358. case Type::Float:
  359. return String::format("%f", (double)as_float());
  360. case Type::String:
  361. return as_string();
  362. case Type::Bitmap:
  363. return "[GraphicsBitmap]";
  364. case Type::Icon:
  365. return "[GIcon]";
  366. case Type::Color:
  367. return as_color().to_string();
  368. case Type::Point:
  369. return as_point().to_string();
  370. case Type::Size:
  371. return as_size().to_string();
  372. case Type::Rect:
  373. return as_rect().to_string();
  374. case Type::Font:
  375. return String::format("[Font: %s]", as_font().name().characters());
  376. case Type::Invalid:
  377. return "[null]";
  378. break;
  379. }
  380. ASSERT_NOT_REACHED();
  381. }