SkFlattenable.cpp 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145
  1. /*
  2. * Copyright 2011 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 "include/core/SkFlattenable.h"
  8. #include "src/core/SkPtrRecorder.h"
  9. #include "src/core/SkReadBuffer.h"
  10. #include <algorithm>
  11. SkNamedFactorySet::SkNamedFactorySet() : fNextAddedFactory(0) {}
  12. uint32_t SkNamedFactorySet::find(SkFlattenable::Factory factory) {
  13. uint32_t index = fFactorySet.find(factory);
  14. if (index > 0) {
  15. return index;
  16. }
  17. const char* name = SkFlattenable::FactoryToName(factory);
  18. if (nullptr == name) {
  19. return 0;
  20. }
  21. *fNames.append() = name;
  22. return fFactorySet.add(factory);
  23. }
  24. const char* SkNamedFactorySet::getNextAddedFactoryName() {
  25. if (fNextAddedFactory < fNames.count()) {
  26. return fNames[fNextAddedFactory++];
  27. }
  28. return nullptr;
  29. }
  30. ///////////////////////////////////////////////////////////////////////////////
  31. SkRefCntSet::~SkRefCntSet() {
  32. // call this now, while our decPtr() is sill in scope
  33. this->reset();
  34. }
  35. void SkRefCntSet::incPtr(void* ptr) {
  36. ((SkRefCnt*)ptr)->ref();
  37. }
  38. void SkRefCntSet::decPtr(void* ptr) {
  39. ((SkRefCnt*)ptr)->unref();
  40. }
  41. ///////////////////////////////////////////////////////////////////////////////
  42. namespace {
  43. struct Entry {
  44. const char* fName;
  45. SkFlattenable::Factory fFactory;
  46. };
  47. struct EntryComparator {
  48. bool operator()(const Entry& a, const Entry& b) const {
  49. return strcmp(a.fName, b.fName) < 0;
  50. }
  51. bool operator()(const Entry& a, const char* b) const {
  52. return strcmp(a.fName, b) < 0;
  53. }
  54. bool operator()(const char* a, const Entry& b) const {
  55. return strcmp(a, b.fName) < 0;
  56. }
  57. };
  58. int gCount = 0;
  59. Entry gEntries[128];
  60. } // namespace
  61. void SkFlattenable::Finalize() {
  62. std::sort(gEntries, gEntries + gCount, EntryComparator());
  63. }
  64. void SkFlattenable::Register(const char name[], Factory factory) {
  65. SkASSERT(name);
  66. SkASSERT(factory);
  67. SkASSERT(gCount < (int)SK_ARRAY_COUNT(gEntries));
  68. gEntries[gCount].fName = name;
  69. gEntries[gCount].fFactory = factory;
  70. gCount += 1;
  71. }
  72. SkFlattenable::Factory SkFlattenable::NameToFactory(const char name[]) {
  73. RegisterFlattenablesIfNeeded();
  74. SkASSERT(std::is_sorted(gEntries, gEntries + gCount, EntryComparator()));
  75. auto pair = std::equal_range(gEntries, gEntries + gCount, name, EntryComparator());
  76. if (pair.first == pair.second) {
  77. return nullptr;
  78. }
  79. return pair.first->fFactory;
  80. }
  81. const char* SkFlattenable::FactoryToName(Factory fact) {
  82. RegisterFlattenablesIfNeeded();
  83. const Entry* entries = gEntries;
  84. for (int i = gCount - 1; i >= 0; --i) {
  85. if (entries[i].fFactory == fact) {
  86. return entries[i].fName;
  87. }
  88. }
  89. return nullptr;
  90. }
  91. ///////////////////////////////////////////////////////////////////////////////////////////////////
  92. sk_sp<SkData> SkFlattenable::serialize(const SkSerialProcs* procs) const {
  93. SkBinaryWriteBuffer writer;
  94. if (procs) {
  95. writer.setSerialProcs(*procs);
  96. }
  97. writer.writeFlattenable(this);
  98. size_t size = writer.bytesWritten();
  99. auto data = SkData::MakeUninitialized(size);
  100. writer.writeToMemory(data->writable_data());
  101. return data;
  102. }
  103. size_t SkFlattenable::serialize(void* memory, size_t memory_size,
  104. const SkSerialProcs* procs) const {
  105. SkBinaryWriteBuffer writer(memory, memory_size);
  106. if (procs) {
  107. writer.setSerialProcs(*procs);
  108. }
  109. writer.writeFlattenable(this);
  110. return writer.usingInitialStorage() ? writer.bytesWritten() : 0u;
  111. }
  112. sk_sp<SkFlattenable> SkFlattenable::Deserialize(SkFlattenable::Type type, const void* data,
  113. size_t size, const SkDeserialProcs* procs) {
  114. SkReadBuffer buffer(data, size);
  115. if (procs) {
  116. buffer.setDeserialProcs(*procs);
  117. }
  118. return sk_sp<SkFlattenable>(buffer.readFlattenable(type));
  119. }