3619649488

Build # 3619649488

Build Type

push

github

Committed by Benoit Blanchon

Commit Message

CI: use `ubuntu-20.04` for GCC

Run Details

3373 of 3389 relevant lines covered (99.53%)

5926.06 hits per line

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

97.44

/src/ArduinoJson/Object/ObjectConstRef.hpp

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

#pragma once

#include <ArduinoJson/Object/ObjectIterator.hpp>
#include <ArduinoJson/Variant/VariantOperators.hpp>

namespace ARDUINOJSON_NAMESPACE {

class ObjectConstRef : public VariantOperators<ObjectConstRef> {
  friend class ObjectRef;
  friend class VariantAttorney;

 public:
  typedef ObjectConstIterator iterator;

  ObjectConstRef() : _data(0) {}
  ObjectConstRef(const CollectionData* data) : _data(data) {}

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

  FORCE_INLINE bool isNull() const {
    return _data == 0;
  }

  FORCE_INLINE operator bool() const {
    return _data != 0;
  }

  FORCE_INLINE size_t memoryUsage() const {
    return _data ? _data->memoryUsage() : 0;
  }

  FORCE_INLINE size_t nesting() const {
    return variantNesting(collectionToVariant(_data));
  }

  FORCE_INLINE size_t size() const {
    return _data ? _data->size() : 0;
  }

  FORCE_INLINE iterator begin() const {
    if (!_data)
      return iterator();
    return iterator(_data->head());
  }

  FORCE_INLINE iterator end() const {
    return iterator();
  }

  // containsKey(const std::string&) const
  // containsKey(const String&) const
  template <typename TString>
  FORCE_INLINE bool containsKey(const TString& key) const {
    return getMember(adaptString(key)) != 0;
  }

  // containsKey(char*) const
  // containsKey(const char*) const
  // containsKey(const __FlashStringHelper*) const
  template <typename TChar>
  FORCE_INLINE bool containsKey(TChar* key) const {
    return getMember(adaptString(key)) != 0;
  }

  // operator[](const std::string&) const
  // operator[](const String&) const
  template <typename TString>
  FORCE_INLINE
      typename enable_if<IsString<TString>::value, VariantConstRef>::type
      operator[](const TString& key) const {
    return VariantConstRef(getMember(adaptString(key)));
  }

  // operator[](char*) const
  // operator[](const char*) const
  // operator[](const __FlashStringHelper*) const
  template <typename TChar>
  FORCE_INLINE
      typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
      operator[](TChar* key) const {
    return VariantConstRef(getMember(adaptString(key)));
  }

  FORCE_INLINE bool operator==(ObjectConstRef rhs) const {
    if (_data == rhs._data)
      return true;

    if (!_data || !rhs._data)
      return false;

    size_t count = 0;
    for (iterator it = begin(); it != end(); ++it) {
      if (it->value() != rhs[it->key()])
        return false;
      count++;
    }
    return count == rhs.size();
  }

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

  template <typename TAdaptedString>
  const VariantData* getMember(TAdaptedString key) const {
    if (!_data)
      return 0;
    return _data->getMember(key);
  }

  const CollectionData* _data;
};

template <>
struct Converter<ObjectConstRef> : private VariantAttorney {
  static void toJson(VariantConstRef src, VariantRef dst) {
    variantCopyFrom(getData(dst), getData(src), getPool(dst));
  }

  static ObjectConstRef fromJson(VariantConstRef src) {
    const VariantData* data = getData(src);
    return data != 0 ? data->asObject() : 0;
  }

  static bool checkJson(VariantConstRef src) {
    const VariantData* data = getData(src);
    return data && data->isObject();
  }
};

}  // namespace ARDUINOJSON_NAMESPACE

1	// ArduinoJson - https://arduinojson.org
2	// Copyright © 2014-2022, Benoit BLANCHON
3	// MIT License
4
5	#pragma once
6
7	#include <ArduinoJson/Object/ObjectIterator.hpp>
8	#include <ArduinoJson/Variant/VariantOperators.hpp>
9
10	namespace ARDUINOJSON_NAMESPACE {
11
12	class ObjectConstRef : public VariantOperators<ObjectConstRef> {
13	friend class ObjectRef;
14	friend class VariantAttorney;
15
16	public:
17	typedef ObjectConstIterator iterator;
18
19	ObjectConstRef() : _data(0) {}	5✔
20	ObjectConstRef(const CollectionData* data) : _data(data) {}	574✔
21
22	operator VariantConstRef() const {	69✔
23	return VariantConstRef(collectionToVariant(_data));	69✔
24	}
25
26	FORCE_INLINE bool isNull() const {
27	return _data == 0;	3✔
28	}
29
30	FORCE_INLINE operator bool() const {
31	return _data != 0;	2✔
32	}
33
34	FORCE_INLINE size_t memoryUsage() const {
35	return _data ? _data->memoryUsage() : 0;	1✔
36	}
37
38	FORCE_INLINE size_t nesting() const {
39	return variantNesting(collectionToVariant(_data));
40	}
41
42	FORCE_INLINE size_t size() const {
43	return _data ? _data->size() : 0;	142✔
44	}
45
46	FORCE_INLINE iterator begin() const {
47	if (!_data)	210✔
48	return iterator();	1✔
49	return iterator(_data->head());	209✔
50	}
51
52	FORCE_INLINE iterator end() const {
53	return iterator();	464✔
54	}
55
56	// containsKey(const std::string&) const
57	// containsKey(const String&) const
58	template <typename TString>
59	FORCE_INLINE bool containsKey(const TString& key) const {
60	return getMember(adaptString(key)) != 0;
61	}
62
63	// containsKey(char*) const
64	// containsKey(const char*) const
65	// containsKey(const __FlashStringHelper*) const
66	template <typename TChar>
67	FORCE_INLINE bool containsKey(TChar* key) const {
68	return getMember(adaptString(key)) != 0;	2✔
69	}
70
71	// operator[](const std::string&) const
72	// operator[](const String&) const
73	template <typename TString>
74	FORCE_INLINE
75	typename enable_if<IsString<TString>::value, VariantConstRef>::type
76	operator[](const TString& key) const {
77	return VariantConstRef(getMember(adaptString(key)));	316✔
78	}
79
80	// operator[](char*) const
81	// operator[](const char*) const
82	// operator[](const __FlashStringHelper*) const
83	template <typename TChar>
84	FORCE_INLINE
85	typename enable_if<IsString<TChar*>::value, VariantConstRef>::type
86	operator[](TChar* key) const {
87	return VariantConstRef(getMember(adaptString(key)));
88	}
89
90	FORCE_INLINE bool operator==(ObjectConstRef rhs) const {
91	if (_data == rhs._data)	275✔
92	return true;	61✔
93
94	if (!_data \|\| !rhs._data)	214✔
95	return false;	6✔
96
97	size_t count = 0;	208✔
98	for (iterator it = begin(); it != end(); ++it) {	666✔
99	if (it->value() != rhs[it->key()])	632✔
100	return false;	66✔
101	count++;	250✔
102	}
103	return count == rhs.size();	142✔
104	}
105
106	private:
107	const VariantData* getData() const {	68✔
108	return collectionToVariant(_data);	68✔
109	}
110
111	template <typename TAdaptedString>
112	const VariantData* getMember(TAdaptedString key) const {	318✔
113	if (!_data)	318✔
114	return 0;	×
115	return _data->getMember(key);	318✔
116	}
117
118	const CollectionData* _data;
119	};
120
121	template <>
122	struct Converter<ObjectConstRef> : private VariantAttorney {
123	static void toJson(VariantConstRef src, VariantRef dst) {	1✔
124	variantCopyFrom(getData(dst), getData(src), getPool(dst));	3✔
125	}	1✔
126
127	static ObjectConstRef fromJson(VariantConstRef src) {	2✔
128	const VariantData* data = getData(src);	2✔
129	return data != 0 ? data->asObject() : 0;	2✔
130	}
131
132	static bool checkJson(VariantConstRef src) {	304✔
133	const VariantData* data = getData(src);	304✔
134	return data && data->isObject();	304✔
135	}
136	};
137
138	} // namespace ARDUINOJSON_NAMESPACE

bblanchon / ArduinoJson / 3619649488

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