SkottieJson.cpp 2.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
  1. /*
  2. * Copyright 2018 Google Inc.
  3. *
  4. * Use of this source code is governed by a BSD-style license that can be
  5. * found in the LICENSE file.
  6. */
  7. #include "modules/skottie/src/SkottieJson.h"
  8. #include "include/core/SkData.h"
  9. #include "include/core/SkPath.h"
  10. #include "include/core/SkPoint.h"
  11. #include "include/core/SkScalar.h"
  12. #include "include/core/SkStream.h"
  13. #include "include/core/SkString.h"
  14. #include "modules/skottie/src/SkottieValue.h"
  15. #include <vector>
  16. namespace skottie {
  17. using namespace skjson;
  18. template <>
  19. bool Parse<SkScalar>(const Value& v, SkScalar* s) {
  20. // Some versions wrap values as single-element arrays.
  21. if (const skjson::ArrayValue* array = v) {
  22. if (array->size() > 0) {
  23. return Parse((*array)[0], s);
  24. }
  25. }
  26. if (const skjson::NumberValue* num = v) {
  27. *s = static_cast<SkScalar>(**num);
  28. return true;
  29. }
  30. return false;
  31. }
  32. template <>
  33. bool Parse<bool>(const Value& v, bool* b) {
  34. switch(v.getType()) {
  35. case Value::Type::kNumber:
  36. *b = SkToBool(*v.as<NumberValue>());
  37. return true;
  38. case Value::Type::kBool:
  39. *b = *v.as<BoolValue>();
  40. return true;
  41. default:
  42. break;
  43. }
  44. return false;
  45. }
  46. template <typename T>
  47. bool ParseIntegral(const Value& v, T* result) {
  48. if (const skjson::NumberValue* num = v) {
  49. const auto dbl = **num;
  50. *result = static_cast<T>(dbl);
  51. return static_cast<double>(*result) == dbl;
  52. }
  53. return false;
  54. }
  55. template <>
  56. bool Parse<int>(const Value& v, int* i) {
  57. return ParseIntegral(v, i);
  58. }
  59. template <>
  60. bool Parse<size_t>(const Value& v, size_t* sz) {
  61. return ParseIntegral(v, sz);
  62. }
  63. template <>
  64. bool Parse<SkString>(const Value& v, SkString* s) {
  65. if (const skjson::StringValue* sv = v) {
  66. s->set(sv->begin(), sv->size());
  67. return true;
  68. }
  69. return false;
  70. }
  71. template <>
  72. bool Parse<SkPoint>(const Value& v, SkPoint* pt) {
  73. if (!v.is<ObjectValue>())
  74. return false;
  75. const auto& ov = v.as<ObjectValue>();
  76. return Parse<SkScalar>(ov["x"], &pt->fX)
  77. && Parse<SkScalar>(ov["y"], &pt->fY);
  78. }
  79. template <>
  80. bool Parse<std::vector<float>>(const Value& v, std::vector<float>* vec) {
  81. if (!v.is<ArrayValue>())
  82. return false;
  83. const auto& av = v.as<ArrayValue>();
  84. vec->resize(av.size());
  85. for (size_t i = 0; i < av.size(); ++i) {
  86. if (!Parse(av[i], vec->data() + i)) {
  87. return false;
  88. }
  89. }
  90. return true;
  91. }
  92. } // namespace skottie