10821526037

Committed 11 Sep 2024 11:59PM UTC coverage: 95.295%. Remained the same

Build # 10821526037

Build Type

Pull #1566

github

Committed by

baylesj

Commit Message

Merge branch '1.9.7' of github.com:open-source-parsers/jsoncpp into 1.9.7

Pull Request Pull Request #1566: Release 1.9.6 and move versions to 1.9.7

Run Details

5306 of 5568 relevant lines covered (95.29%)

11935.1 hits per line

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

98.48

/src/lib_json/json_valueiterator.inl

// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

// included by json_value.cpp

namespace Json {

// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIteratorBase
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////

ValueIteratorBase::ValueIteratorBase() : current_() {}

ValueIteratorBase::ValueIteratorBase(
    const Value::ObjectValues::iterator& current)
    : current_(current), isNull_(false) {}

Value& ValueIteratorBase::deref() { return current_->second; }
const Value& ValueIteratorBase::deref() const { return current_->second; }

void ValueIteratorBase::increment() { ++current_; }

void ValueIteratorBase::decrement() { --current_; }

ValueIteratorBase::difference_type
ValueIteratorBase::computeDistance(const SelfType& other) const {
  // Iterator for null value are initialized using the default
  // constructor, which initialize current_ to the default
  // std::map::iterator. As begin() and end() are two instance
  // of the default std::map::iterator, they can not be compared.
  // To allow this, we handle this comparison specifically.
  if (isNull_ && other.isNull_) {
    return 0;
  }

  // Usage of std::distance is not portable (does not compile with Sun Studio 12
  // RogueWave STL,
  // which is the one used by default).
  // Using a portable hand-made version for non random iterator instead:
  //   return difference_type( std::distance( current_, other.current_ ) );
  difference_type myDistance = 0;
  for (Value::ObjectValues::iterator it = current_; it != other.current_;
       ++it) {
    ++myDistance;
  }
  return myDistance;
}

bool ValueIteratorBase::isEqual(const SelfType& other) const {
  if (isNull_) {
    return other.isNull_;
  }
  return current_ == other.current_;
}

void ValueIteratorBase::copy(const SelfType& other) {
  current_ = other.current_;
  isNull_ = other.isNull_;
}

Value ValueIteratorBase::key() const {
  const Value::CZString czstring = (*current_).first;
  if (czstring.data()) {
    if (czstring.isStaticString())
      return Value(StaticString(czstring.data()));
    return Value(czstring.data(), czstring.data() + czstring.length());
  }
  return Value(czstring.index());
}

UInt ValueIteratorBase::index() const {
  const Value::CZString czstring = (*current_).first;
  if (!czstring.data())
    return czstring.index();
  return Value::UInt(-1);
}

String ValueIteratorBase::name() const {
  char const* keey;
  char const* end;
  keey = memberName(&end);
  if (!keey)
    return String();
  return String(keey, end);
}

char const* ValueIteratorBase::memberName() const {
  const char* cname = (*current_).first.data();
  return cname ? cname : "";
}

char const* ValueIteratorBase::memberName(char const** end) const {
  const char* cname = (*current_).first.data();
  if (!cname) {
    *end = nullptr;
    return nullptr;
  }
  *end = cname + (*current_).first.length();
  return cname;
}

// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueConstIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////

ValueConstIterator::ValueConstIterator() = default;

ValueConstIterator::ValueConstIterator(
    const Value::ObjectValues::iterator& current)
    : ValueIteratorBase(current) {}

ValueConstIterator::ValueConstIterator(ValueIterator const& other)
    : ValueIteratorBase(other) {}

ValueConstIterator& ValueConstIterator::
operator=(const ValueIteratorBase& other) {
  copy(other);
  return *this;
}

// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// class ValueIterator
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////
// //////////////////////////////////////////////////////////////////

ValueIterator::ValueIterator() = default;

ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)
    : ValueIteratorBase(current) {}

ValueIterator::ValueIterator(const ValueConstIterator& other)
    : ValueIteratorBase(other) {
  throwRuntimeError("ConstIterator to Iterator should never be allowed.");
}

ValueIterator::ValueIterator(const ValueIterator& other) = default;

ValueIterator& ValueIterator::operator=(const SelfType& other) {
  copy(other);
  return *this;
}

} // namespace Json

1	// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
2	// Distributed under MIT license, or public domain if desired and
3	// recognized in your jurisdiction.
4	// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
5
6	// included by json_value.cpp
7
8	namespace Json {
9
10	// //////////////////////////////////////////////////////////////////
11	// //////////////////////////////////////////////////////////////////
12	// //////////////////////////////////////////////////////////////////
13	// class ValueIteratorBase
14	// //////////////////////////////////////////////////////////////////
15	// //////////////////////////////////////////////////////////////////
16	// //////////////////////////////////////////////////////////////////
17
18	ValueIteratorBase::ValueIteratorBase() : current_() {}	54✔
19
20	ValueIteratorBase::ValueIteratorBase(	111✔
21	const Value::ObjectValues::iterator& current)	111✔
22	: current_(current), isNull_(false) {}	111✔
23
24	Value& ValueIteratorBase::deref() { return current_->second; }	×
25	const Value& ValueIteratorBase::deref() const { return current_->second; }	33✔
26
27	void ValueIteratorBase::increment() { ++current_; }	75✔
28
29	void ValueIteratorBase::decrement() { --current_; }	13✔
30
31	ValueIteratorBase::difference_type
32	ValueIteratorBase::computeDistance(const SelfType& other) const {	5✔
33	// Iterator for null value are initialized using the default
34	// constructor, which initialize current_ to the default
35	// std::map::iterator. As begin() and end() are two instance
36	// of the default std::map::iterator, they can not be compared.
37	// To allow this, we handle this comparison specifically.
38	if (isNull_ && other.isNull_) {	5✔
39	return 0;
40	}
41
42	// Usage of std::distance is not portable (does not compile with Sun Studio 12
43	// RogueWave STL,
44	// which is the one used by default).
45	// Using a portable hand-made version for non random iterator instead:
46	// return difference_type( std::distance( current_, other.current_ ) );
47	difference_type myDistance = 0;
48	for (Value::ObjectValues::iterator it = current_; it != other.current_;	6✔
49	++it) {
50	++myDistance;	3✔
51	}
52	return myDistance;
53	}
54
55	bool ValueIteratorBase::isEqual(const SelfType& other) const {	126✔
56	if (isNull_) {	126✔
57	return other.isNull_;	27✔
58	}
59	return current_ == other.current_;	99✔
60	}
61
62	void ValueIteratorBase::copy(const SelfType& other) {	2✔
63	current_ = other.current_;	2✔
64	isNull_ = other.isNull_;	2✔
65	}	2✔
66
67	Value ValueIteratorBase::key() const {	5✔
68	const Value::CZString czstring = (*current_).first;	5✔
69	if (czstring.data()) {	5✔
70	if (czstring.isStaticString())	3✔
71	return Value(StaticString(czstring.data()));	1✔
72	return Value(czstring.data(), czstring.data() + czstring.length());	2✔
73	}
74	return Value(czstring.index());	2✔
75	}	5✔
76
77	UInt ValueIteratorBase::index() const {	4✔
78	const Value::CZString czstring = (*current_).first;	4✔
79	if (!czstring.data())	4✔
80	return czstring.index();	2✔
81	return Value::UInt(-1);
82	}	4✔
83
84	String ValueIteratorBase::name() const {	46✔
85	char const* keey;
86	char const* end;
87	keey = memberName(&end);	46✔
88	if (!keey)	46✔
89	return String();
90	return String(keey, end);	44✔
91	}
92
93	char const* ValueIteratorBase::memberName() const {	2✔
94	const char* cname = (*current_).first.data();	2✔
95	return cname ? cname : "";	2✔
96	}
97
98	char const* ValueIteratorBase::memberName(char const** end) const {	46✔
99	const char* cname = (*current_).first.data();	46✔
100	if (!cname) {	46✔
101	*end = nullptr;	2✔
102	return nullptr;	2✔
103	}
104	end = cname + (current_).first.length();	44✔
105	return cname;	44✔
106	}
107
108	// //////////////////////////////////////////////////////////////////
109	// //////////////////////////////////////////////////////////////////
110	// //////////////////////////////////////////////////////////////////
111	// class ValueConstIterator
112	// //////////////////////////////////////////////////////////////////
113	// //////////////////////////////////////////////////////////////////
114	// //////////////////////////////////////////////////////////////////
115
116	ValueConstIterator::ValueConstIterator() = default;	26✔
117
118	ValueConstIterator::ValueConstIterator(	60✔
119	const Value::ObjectValues::iterator& current)	60✔
120	: ValueIteratorBase(current) {}	60✔
121
122	ValueConstIterator::ValueConstIterator(ValueIterator const& other)	1✔
123	: ValueIteratorBase(other) {}	1✔
124
125	ValueConstIterator& ValueConstIterator::	1✔
126	operator=(const ValueIteratorBase& other) {
127	copy(other);	1✔
128	return *this;	1✔
129	}
130
131	// //////////////////////////////////////////////////////////////////
132	// //////////////////////////////////////////////////////////////////
133	// //////////////////////////////////////////////////////////////////
134	// class ValueIterator
135	// //////////////////////////////////////////////////////////////////
136	// //////////////////////////////////////////////////////////////////
137	// //////////////////////////////////////////////////////////////////
138
139	ValueIterator::ValueIterator() = default;	28✔
140
141	ValueIterator::ValueIterator(const Value::ObjectValues::iterator& current)	51✔
142	: ValueIteratorBase(current) {}	51✔
143
144	ValueIterator::ValueIterator(const ValueConstIterator& other)	1✔
145	: ValueIteratorBase(other) {	1✔
146	throwRuntimeError("ConstIterator to Iterator should never be allowed.");	1✔
147	}
148
149	ValueIterator::ValueIterator(const ValueIterator& other) = default;	15✔
150
151	ValueIterator& ValueIterator::operator=(const SelfType& other) {	1✔
152	copy(other);	1✔
153	return *this;	1✔
154	}
155
156	} // namespace Json

open-source-parsers / jsoncpp / 10821526037

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