Values_h.template 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266
  1. // This file is generated by Values_h.template.
  2. // Copyright 2016 The Chromium Authors. All rights reserved.
  3. // Use of this source code is governed by a BSD-style license that can be
  4. // found in the LICENSE file.
  5. #ifndef {{"_".join(config.protocol.namespace)}}_Values_h
  6. #define {{"_".join(config.protocol.namespace)}}_Values_h
  7. //#include "Allocator.h"
  8. //#include "Forward.h"
  9. #include <memory>
  10. #include <unordered_map>
  11. #include <utility>
  12. #include <vector>
  13. #include {{format_include(config.protocol.package, "Forward")}}
  14. {% for namespace in config.protocol.namespace %}
  15. namespace {{namespace}} {
  16. {% endfor %}
  17. class ListValue;
  18. class DictionaryValue;
  19. class Value;
  20. #define PROTOCOL_DISALLOW_COPY(ClassName) \
  21. private: \
  22. ClassName(const ClassName&) = delete; \
  23. ClassName& operator=(const ClassName&) = delete
  24. class {{config.lib.export_macro}} Value : public Serializable {
  25. PROTOCOL_DISALLOW_COPY(Value);
  26. public:
  27. virtual ~Value() override { }
  28. static std::unique_ptr<Value> null()
  29. {
  30. return std::unique_ptr<Value>(new Value());
  31. }
  32. static std::unique_ptr<Value> parseBinary(const uint8_t* data, size_t size);
  33. enum ValueType {
  34. TypeNull = 0,
  35. TypeBoolean,
  36. TypeInteger,
  37. TypeDouble,
  38. TypeString,
  39. TypeBinary,
  40. TypeObject,
  41. TypeArray,
  42. TypeImported
  43. };
  44. ValueType type() const { return m_type; }
  45. bool isNull() const { return m_type == TypeNull; }
  46. virtual bool asBoolean(bool* output) const;
  47. virtual bool asDouble(double* output) const;
  48. virtual bool asInteger(int* output) const;
  49. virtual bool asString(String* output) const;
  50. virtual bool asBinary(Binary* output) const;
  51. virtual void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  52. virtual std::unique_ptr<Value> clone() const;
  53. protected:
  54. Value() : m_type(TypeNull) { }
  55. explicit Value(ValueType type) : m_type(type) { }
  56. private:
  57. friend class DictionaryValue;
  58. friend class ListValue;
  59. ValueType m_type;
  60. };
  61. class {{config.lib.export_macro}} FundamentalValue : public Value {
  62. public:
  63. static std::unique_ptr<FundamentalValue> create(bool value)
  64. {
  65. return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
  66. }
  67. static std::unique_ptr<FundamentalValue> create(int value)
  68. {
  69. return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
  70. }
  71. static std::unique_ptr<FundamentalValue> create(double value)
  72. {
  73. return std::unique_ptr<FundamentalValue>(new FundamentalValue(value));
  74. }
  75. bool asBoolean(bool* output) const override;
  76. bool asDouble(double* output) const override;
  77. bool asInteger(int* output) const override;
  78. void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  79. std::unique_ptr<Value> clone() const override;
  80. private:
  81. explicit FundamentalValue(bool value) : Value(TypeBoolean), m_boolValue(value) { }
  82. explicit FundamentalValue(int value) : Value(TypeInteger), m_integerValue(value) { }
  83. explicit FundamentalValue(double value) : Value(TypeDouble), m_doubleValue(value) { }
  84. union {
  85. bool m_boolValue;
  86. double m_doubleValue;
  87. int m_integerValue;
  88. };
  89. };
  90. class {{config.lib.export_macro}} StringValue : public Value {
  91. public:
  92. static std::unique_ptr<StringValue> create(const String& value)
  93. {
  94. return std::unique_ptr<StringValue>(new StringValue(value));
  95. }
  96. static std::unique_ptr<StringValue> create(const char* value)
  97. {
  98. return std::unique_ptr<StringValue>(new StringValue(value));
  99. }
  100. bool asString(String* output) const override;
  101. void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  102. std::unique_ptr<Value> clone() const override;
  103. private:
  104. explicit StringValue(const String& value) : Value(TypeString), m_stringValue(value) { }
  105. explicit StringValue(const char* value) : Value(TypeString), m_stringValue(value) { }
  106. String m_stringValue;
  107. };
  108. class {{config.lib.export_macro}} BinaryValue : public Value {
  109. public:
  110. static std::unique_ptr<BinaryValue> create(const Binary& value)
  111. {
  112. return std::unique_ptr<BinaryValue>(new BinaryValue(value));
  113. }
  114. bool asBinary(Binary* output) const override;
  115. void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  116. std::unique_ptr<Value> clone() const override;
  117. private:
  118. explicit BinaryValue(const Binary& value) : Value(TypeBinary), m_binaryValue(value) { }
  119. Binary m_binaryValue;
  120. };
  121. class {{config.lib.export_macro}} DictionaryValue : public Value {
  122. public:
  123. using Entry = std::pair<String, Value*>;
  124. static std::unique_ptr<DictionaryValue> create()
  125. {
  126. return std::unique_ptr<DictionaryValue>(new DictionaryValue());
  127. }
  128. static DictionaryValue* cast(Value* value)
  129. {
  130. if (!value || value->type() != TypeObject)
  131. return nullptr;
  132. return static_cast<DictionaryValue*>(value);
  133. }
  134. static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
  135. {
  136. DictionaryValue* dictionaryValue = cast(value.get());
  137. if (dictionaryValue) value.release();
  138. return std::unique_ptr<DictionaryValue>(dictionaryValue);
  139. }
  140. void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  141. std::unique_ptr<Value> clone() const override;
  142. size_t size() const { return m_data.size(); }
  143. void setBoolean(const String& name, bool);
  144. void setInteger(const String& name, int);
  145. void setDouble(const String& name, double);
  146. void setString(const String& name, const String&);
  147. void setValue(const String& name, std::unique_ptr<Value>);
  148. void setObject(const String& name, std::unique_ptr<DictionaryValue>);
  149. void setArray(const String& name, std::unique_ptr<ListValue>);
  150. bool getBoolean(const String& name, bool* output) const;
  151. bool getInteger(const String& name, int* output) const;
  152. bool getDouble(const String& name, double* output) const;
  153. bool getString(const String& name, String* output) const;
  154. DictionaryValue* getObject(const String& name) const;
  155. ListValue* getArray(const String& name) const;
  156. Value* get(const String& name) const;
  157. Entry at(size_t index) const;
  158. bool booleanProperty(const String& name, bool defaultValue) const;
  159. int integerProperty(const String& name, int defaultValue) const;
  160. double doubleProperty(const String& name, double defaultValue) const;
  161. void remove(const String& name);
  162. ~DictionaryValue() override;
  163. private:
  164. DictionaryValue();
  165. template<typename T>
  166. void set(const String& key, std::unique_ptr<T>& value)
  167. {
  168. DCHECK(value);
  169. bool isNew = m_data.find(key) == m_data.end();
  170. m_data[key] = std::move(value);
  171. if (isNew)
  172. m_order.push_back(key);
  173. }
  174. using Dictionary = std::unordered_map<String, std::unique_ptr<Value>>;
  175. Dictionary m_data;
  176. std::vector<String> m_order;
  177. };
  178. class {{config.lib.export_macro}} ListValue : public Value {
  179. public:
  180. static std::unique_ptr<ListValue> create()
  181. {
  182. return std::unique_ptr<ListValue>(new ListValue());
  183. }
  184. static ListValue* cast(Value* value)
  185. {
  186. if (!value || value->type() != TypeArray)
  187. return nullptr;
  188. return static_cast<ListValue*>(value);
  189. }
  190. static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
  191. {
  192. ListValue* listValue = cast(value.get());
  193. if (listValue) value.release();
  194. return std::unique_ptr<ListValue>(listValue);
  195. }
  196. ~ListValue() override;
  197. void AppendSerialized(std::vector<uint8_t>* bytes) const override;
  198. std::unique_ptr<Value> clone() const override;
  199. void pushValue(std::unique_ptr<Value>);
  200. Value* at(size_t index);
  201. size_t size() const { return m_data.size(); }
  202. void reserve(size_t capacity) { m_data.reserve(capacity); }
  203. private:
  204. ListValue();
  205. std::vector<std::unique_ptr<Value>> m_data;
  206. };
  207. {% for namespace in config.protocol.namespace %}
  208. } // namespace {{namespace}}
  209. {% endfor %}
  210. #endif // {{"_".join(config.protocol.namespace)}}_Values_h