4583260581

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

Test: include deallocated size in allocator's log

Run Details

3289 of 3305 relevant lines covered (99.52%)

6190.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/ArduinoJson/Array/JsonArray.hpp

// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, Benoit BLANCHON
// MIT License

#pragma once

#include <ArduinoJson/Array/ElementProxy.hpp>
#include <ArduinoJson/Array/JsonArrayConst.hpp>

ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE

class JsonObject;

// A reference to an array in a JsonDocument
// https://arduinojson.org/v6/api/jsonarray/
class JsonArray : public detail::VariantOperators<JsonArray> {
  friend class detail::VariantAttorney;

 public:
  typedef JsonArrayIterator iterator;

  // Constructs an unbound reference.
  FORCE_INLINE JsonArray() : _data(0), _pool(0) {}

  // INTERNAL USE ONLY
  FORCE_INLINE JsonArray(detail::MemoryPool* pool, detail::CollectionData* data)
      : _data(data), _pool(pool) {}

  // Returns a JsonVariant pointing to the array.
  // https://arduinojson.org/v6/api/jsonvariant/
  operator JsonVariant() {
    void* data = _data;  // prevent warning cast-align
    return JsonVariant(_pool, reinterpret_cast<detail::VariantData*>(data));
  }

  // Returns a read-only reference to the array.
  // https://arduinojson.org/v6/api/jsonarrayconst/
  operator JsonArrayConst() const {
    return JsonArrayConst(_data);
  }

  // Appends a new (null) element to the array.
  // Returns a reference to the new element.
  // https://arduinojson.org/v6/api/jsonarray/add/
  JsonVariant add() const {
    if (!_data)
      return JsonVariant();
    return JsonVariant(_pool, _data->addElement(_pool));
  }

  // Appends a value to the array.
  // https://arduinojson.org/v6/api/jsonarray/add/
  template <typename T>
  FORCE_INLINE bool add(const T& value) const {
    return add().set(value);
  }

  // Appends a value to the array.
  // https://arduinojson.org/v6/api/jsonarray/add/
  template <typename T>
  FORCE_INLINE bool add(T* value) const {
    return add().set(value);
  }

  // Returns an iterator to the first element of the array.
  // https://arduinojson.org/v6/api/jsonarray/begin/
  FORCE_INLINE iterator begin() const {
    if (!_data)
      return iterator();
    return iterator(_pool, _data->head());
  }

  // Returns an iterator following the last element of the array.
  // https://arduinojson.org/v6/api/jsonarray/end/
  FORCE_INLINE iterator end() const {
    return iterator();
  }

  // Copies an array.
  // https://arduinojson.org/v6/api/jsonarray/set/
  FORCE_INLINE bool set(JsonArrayConst src) const {
    if (!_data || !src._data)
      return false;
    return _data->copyFrom(*src._data, _pool);
  }

  // Compares the content of two arrays.
  FORCE_INLINE bool operator==(JsonArray rhs) const {
    return JsonArrayConst(_data) == JsonArrayConst(rhs._data);
  }

  // Removes the element at the specified iterator.
  // ⚠️ Doesn't release the memory associated with the removed element.
  // https://arduinojson.org/v6/api/jsonarray/remove/
  FORCE_INLINE void remove(iterator it) const {
    if (!_data)
      return;
    _data->removeSlot(it._slot);
  }

  // Removes the element at the specified index.
  // ⚠️ Doesn't release the memory associated with the removed element.
  // https://arduinojson.org/v6/api/jsonarray/remove/
  FORCE_INLINE void remove(size_t index) const {
    if (!_data)
      return;
    _data->removeElement(index);
  }

  // Removes all the elements of the array.
  // ⚠️ Doesn't release the memory associated with the removed elements.
  // https://arduinojson.org/v6/api/jsonarray/clear/
  void clear() const {
    if (!_data)
      return;
    _data->clear();
  }

  // Gets or sets the element at the specified index.
  // https://arduinojson.org/v6/api/jsonarray/subscript/
  FORCE_INLINE detail::ElementProxy<JsonArray> operator[](size_t index) const {
    return {*this, index};
  }

  // Creates an object and appends it to the array.
  // https://arduinojson.org/v6/api/jsonarray/createnestedobject/
  FORCE_INLINE JsonObject createNestedObject() const;

  // Creates an array and appends it to the array.
  // https://arduinojson.org/v6/api/jsonarray/createnestedarray/
  FORCE_INLINE JsonArray createNestedArray() const {
    return add().to<JsonArray>();
  }

  operator JsonVariantConst() const {
    return JsonVariantConst(collectionToVariant(_data));
  }

  // Returns true if the reference is unbound.
  // https://arduinojson.org/v6/api/jsonarray/isnull/
  FORCE_INLINE bool isNull() const {
    return _data == 0;
  }

  // Returns true if the reference is bound.
  // https://arduinojson.org/v6/api/jsonarray/isnull/
  FORCE_INLINE operator bool() const {
    return _data != 0;
  }

  // Returns the number of bytes occupied by the array.
  // https://arduinojson.org/v6/api/jsonarray/memoryusage/
  FORCE_INLINE size_t memoryUsage() const {
    return _data ? _data->memoryUsage() : 0;
  }

  // Returns the depth (nesting level) of the array.
  // https://arduinojson.org/v6/api/jsonarray/nesting/
  FORCE_INLINE size_t nesting() const {
    return variantNesting(collectionToVariant(_data));
  }

  // Returns the number of elements in the array.
  // https://arduinojson.org/v6/api/jsonarray/size/
  FORCE_INLINE size_t size() const {
    return _data ? _data->size() : 0;
  }

 private:
  detail::MemoryPool* getPool() const {
    return _pool;
  }

  detail::VariantData* getData() const {
    return collectionToVariant(_data);
  }

  detail::VariantData* getOrCreateData() const {
    return collectionToVariant(_data);
  }

  detail::CollectionData* _data;
  detail::MemoryPool* _pool;
};

template <>
struct Converter<JsonArray> : private detail::VariantAttorney {
  static void toJson(JsonVariantConst src, JsonVariant dst) {
    variantCopyFrom(getData(dst), getData(src), getPool(dst));
  }

  static JsonArray fromJson(JsonVariant src) {
    auto data = getData(src);
    auto pool = getPool(src);
    return JsonArray(pool, data != 0 ? data->asArray() : 0);
  }

  static detail::InvalidConversion<JsonVariantConst, JsonArray> fromJson(
      JsonVariantConst);

  static bool checkJson(JsonVariantConst) {
    return false;
  }

  static bool checkJson(JsonVariant src) {
    auto data = getData(src);
    return data && data->isArray();
  }
};

ARDUINOJSON_END_PUBLIC_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2023, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Array/ElementProxy.hpp>
8	#include <ArduinoJson/Array/JsonArrayConst.hpp>
9
10	ARDUINOJSON_BEGIN_PUBLIC_NAMESPACE
11
12	class JsonObject;
13
14	// A reference to an array in a JsonDocument
15	// https://arduinojson.org/v6/api/jsonarray/
16	class JsonArray : public detail::VariantOperators<JsonArray> {
17	friend class detail::VariantAttorney;
18
19	public:
20	typedef JsonArrayIterator iterator;
21
22	// Constructs an unbound reference.
23	FORCE_INLINE JsonArray() : _data(0), _pool(0) {}	19✔
24
25	// INTERNAL USE ONLY
26	FORCE_INLINE JsonArray(detail::MemoryPool* pool, detail::CollectionData* data)
27	: _data(data), _pool(pool) {}	300✔
28
29	// Returns a JsonVariant pointing to the array.
30	// https://arduinojson.org/v6/api/jsonvariant/
31	operator JsonVariant() {	8✔
32	void* data = _data; // prevent warning cast-align	8✔
33	return JsonVariant(_pool, reinterpret_cast<detail::VariantData*>(data));	8✔
34	}
35
36	// Returns a read-only reference to the array.
37	// https://arduinojson.org/v6/api/jsonarrayconst/
38	operator JsonArrayConst() const {	35✔
39	return JsonArrayConst(_data);	35✔
40	}
41
42	// Appends a new (null) element to the array.
43	// Returns a reference to the new element.
44	// https://arduinojson.org/v6/api/jsonarray/add/
45	JsonVariant add() const {	65,828✔
46	if (!_data)	65,828✔
47	return JsonVariant();	3✔
48	return JsonVariant(_pool, _data->addElement(_pool));	65,825✔
49	}
50
51	// Appends a value to the array.
52	// https://arduinojson.org/v6/api/jsonarray/add/
53	template <typename T>
54	FORCE_INLINE bool add(const T& value) const {
55	return add().set(value);	311✔
56	}
57
58	// Appends a value to the array.
59	// https://arduinojson.org/v6/api/jsonarray/add/
60	template <typename T>
61	FORCE_INLINE bool add(T* value) const {
62	return add().set(value);	131,212✔
63	}
64
65	// Returns an iterator to the first element of the array.
66	// https://arduinojson.org/v6/api/jsonarray/begin/
67	FORCE_INLINE iterator begin() const {
68	if (!_data)	7✔
69	return iterator();	2✔
70	return iterator(_pool, _data->head());	5✔
71	}
72
73	// Returns an iterator following the last element of the array.
74	// https://arduinojson.org/v6/api/jsonarray/end/
75	FORCE_INLINE iterator end() const {
76	return iterator();	6✔
77	}
78
79	// Copies an array.
80	// https://arduinojson.org/v6/api/jsonarray/set/
81	FORCE_INLINE bool set(JsonArrayConst src) const {
82	if (!_data \|\| !src._data)
83	return false;
84	return _data->copyFrom(*src._data, _pool);
85	}
86
87	// Compares the content of two arrays.
88	FORCE_INLINE bool operator==(JsonArray rhs) const {
89	return JsonArrayConst(_data) == JsonArrayConst(rhs._data);	32✔
90	}
91
92	// Removes the element at the specified iterator.
93	// ⚠️ Doesn't release the memory associated with the removed element.
94	// https://arduinojson.org/v6/api/jsonarray/remove/
95	FORCE_INLINE void remove(iterator it) const {
96	if (!_data)	5✔
97	return;	1✔
98	_data->removeSlot(it._slot);	4✔
99	}
100
101	// Removes the element at the specified index.
102	// ⚠️ Doesn't release the memory associated with the removed element.
103	// https://arduinojson.org/v6/api/jsonarray/remove/
104	FORCE_INLINE void remove(size_t index) const {
105	if (!_data)	4✔
106	return;	1✔
107	_data->removeElement(index);	3✔
108	}
109
110	// Removes all the elements of the array.
111	// ⚠️ Doesn't release the memory associated with the removed elements.
112	// https://arduinojson.org/v6/api/jsonarray/clear/
113	void clear() const {	2✔
114	if (!_data)	2✔
115	return;	1✔
116	_data->clear();	1✔
117	}
118
119	// Gets or sets the element at the specified index.
120	// https://arduinojson.org/v6/api/jsonarray/subscript/
121	FORCE_INLINE detail::ElementProxy<JsonArray> operator[](size_t index) const {
122	return {*this, index};	250✔
123	}
124
125	// Creates an object and appends it to the array.
126	// https://arduinojson.org/v6/api/jsonarray/createnestedobject/
127	FORCE_INLINE JsonObject createNestedObject() const;
128
129	// Creates an array and appends it to the array.
130	// https://arduinojson.org/v6/api/jsonarray/createnestedarray/
131	FORCE_INLINE JsonArray createNestedArray() const {
132	return add().to<JsonArray>();	18✔
133	}
134
135	operator JsonVariantConst() const {	157✔
136	return JsonVariantConst(collectionToVariant(_data));	157✔
137	}
138
139	// Returns true if the reference is unbound.
140	// https://arduinojson.org/v6/api/jsonarray/isnull/
141	FORCE_INLINE bool isNull() const {
142	return _data == 0;	25✔
143	}
144
145	// Returns true if the reference is bound.
146	// https://arduinojson.org/v6/api/jsonarray/isnull/
147	FORCE_INLINE operator bool() const {
148	return _data != 0;	2✔
149	}
150
151	// Returns the number of bytes occupied by the array.
152	// https://arduinojson.org/v6/api/jsonarray/memoryusage/
153	FORCE_INLINE size_t memoryUsage() const {
154	return _data ? _data->memoryUsage() : 0;	8✔
155	}
156
157	// Returns the depth (nesting level) of the array.
158	// https://arduinojson.org/v6/api/jsonarray/nesting/
159	FORCE_INLINE size_t nesting() const {
160	return variantNesting(collectionToVariant(_data));	5✔
161	}
162
163	// Returns the number of elements in the array.
164	// https://arduinojson.org/v6/api/jsonarray/size/
165	FORCE_INLINE size_t size() const {
166	return _data ? _data->size() : 0;	76✔
167	}
168
169	private:
170	detail::MemoryPool* getPool() const {	93✔
171	return _pool;	93✔
172	}
173
174	detail::VariantData* getData() const {	318✔
175	return collectionToVariant(_data);	318✔
176	}
177
178	detail::VariantData* getOrCreateData() const {	23✔
179	return collectionToVariant(_data);	23✔
180	}
181
182	detail::CollectionData* _data;
183	detail::MemoryPool* _pool;
184	};
185
186	template <>
187	struct Converter<JsonArray> : private detail::VariantAttorney {
188	static void toJson(JsonVariantConst src, JsonVariant dst) {	10✔
189	variantCopyFrom(getData(dst), getData(src), getPool(dst));	30✔
190	}	10✔
191
192	static JsonArray fromJson(JsonVariant src) {	78✔
193	auto data = getData(src);	78✔
194	auto pool = getPool(src);	78✔
195	return JsonArray(pool, data != 0 ? data->asArray() : 0);	156✔
196	}
197
198	static detail::InvalidConversion<JsonVariantConst, JsonArray> fromJson(
199	JsonVariantConst);
200
201	static bool checkJson(JsonVariantConst) {	9✔
202	return false;	9✔
203	}
204
205	static bool checkJson(JsonVariant src) {	21✔
206	auto data = getData(src);	21✔
207	return data && data->isArray();	21✔
208	}
209	};
210
211	ARDUINOJSON_END_PUBLIC_NAMESPACE

bblanchon / ArduinoJson / 4583260581

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous