{

public:

typedef json2cppJsonArrayValueIterator const_iterator;

typedef json2cppJsonArrayValueIterator iterator;

/// Construct a json2cppJsonArray referencing an empty array.

json2cppJsonArray() : m_value(emptyArray()) {}

/**

explicit json2cppJsonArray(const json2cpp::json &value) : m_value(value)

{

if (!value.is_array()) { throwRuntimeError("Value is not an array."); }

}

/**

json2cppJsonArrayValueIterator begin() const;

/**

json2cppJsonArrayValueIterator end() const;

/// Return the number of elements in the array

size_t size() const { return m_value.size(); }

private:

/**

static const json2cpp::json &emptyArray()

{

static const json2cpp::json array = json2cpp::json::array();

return array;

}

/// Reference to the contained value

const json2cpp::json &m_value;

{

public:

typedef json2cppJsonObjectMemberIterator const_iterator;

typedef json2cppJsonObjectMemberIterator iterator;

/// Construct a json2cppJsonObject referencing an empty object singleton.

json2cppJsonObject() : m_value(emptyObject()) {}

/**

explicit json2cppJsonObject(const json2cpp::json &value) : m_value(value)

{

if (!value.is_object()) { throwRuntimeError("Value is not an object."); }

}

/**

json2cppJsonObjectMemberIterator begin() const;

/**

json2cppJsonObjectMemberIterator end() const;

/**

json2cppJsonObjectMemberIterator find(const std::string_view propertyName) const;

/// Returns the number of members belonging to this object.

size_t size() const { return m_value.size(); }

private:

/**

static const json2cpp::json &emptyObject()

{

static const json2cpp::json object = json2cpp::json::object();

return object;

}

/// Reference to the contained object

const json2cpp::json &m_value;

{

public:

/**

explicit json2cppJsonFrozenValue(json2cpp::json source) : m_value(std::move(source)) {}

FrozenValue *clone() const override { return new json2cppJsonFrozenValue(m_value); }

bool equalTo(const Adapter &other, bool strict) const override;

private:

/// Stored json2cppJson value

json2cpp::json m_value;

{

public:

/// Construct a wrapper for the empty object singleton

json2cppJsonValue() : m_value(emptyObject()) {}

/// Construct a wrapper for a specific json2cppJson value

explicit json2cppJsonValue(const json2cpp::json &value) : m_value(value) {}

/**

FrozenValue *freeze() const { return new json2cppJsonFrozenValue(m_value); }

/**

opt::optional<json2cppJsonArray> getArrayOptional() const

{

if (m_value.is_array()) { return opt::make_optional(json2cppJsonArray(m_value)); }

return {};

}

/**

bool getArraySize(size_t &result) const

{

if (m_value.is_array()) {

result = m_value.size();

return true;

}

return false;

}

bool getBool(bool &result) const

{

if (m_value.is_boolean()) {

result = m_value.get<bool>();

return true;

}

return false;

}

bool getDouble(double &result) const

{

if (m_value.is_number_float()) {

result = m_value.get<double>();

return true;

}

return false;

}

bool getInteger(int64_t &result) const

{

if (m_value.is_number_integer()) {

result = m_value.get<int64_t>();

return true;

}

return false;

}

/**

opt::optional<json2cppJsonObject> getObjectOptional() const

{

if (m_value.is_object()) { return opt::make_optional(json2cppJsonObject(m_value)); }

opt::optional<json2cppJsonObject> emptyreturn{};

return emptyreturn;

}

/**

bool getObjectSize(size_t &result) const

{

if (m_value.is_object()) {

result = m_value.size();

return true;

}

return false;

}

bool getString(std::string &result) const

{

if (m_value.is_string()) {

result = m_value.get<std::string_view>();

return true;

}

return false;

}

static bool hasStrictTypes() { return true; }

bool isArray() const { return m_value.is_array(); }

bool isBool() const { return m_value.is_boolean(); }

bool isDouble() const { return m_value.is_number_float(); }

bool isInteger() const { return m_value.is_number_integer(); }

bool isNull() const { return m_value.is_null(); }

bool isNumber() const { return m_value.is_number(); }

bool isObject() const { return m_value.is_object(); }

bool isString() const { return m_value.is_string(); }

private:

/// Return a reference to an empty object singleton

static const json2cpp::json &emptyObject()

{

static const json2cpp::json object = json2cpp::json::object();

return object;

}

/// Reference to the contained json2cppJson value.

const json2cpp::json &m_value;

: public BasicAdapter<json2cppJsonAdapter,

json2cppJsonArray,

json2cppJsonObjectMember,

json2cppJsonObject,

json2cppJsonValue>

{

public:

/// Construct a json2cppJsonAdapter that contains an empty object

json2cppJsonAdapter() : BasicAdapter() {}

/// Construct a json2cppJsonAdapter containing a specific json2cpp Json object

explicit json2cppJsonAdapter(const json2cpp::json &value) : BasicAdapter(json2cppJsonValue{ value }) {}

{

public:

using iterator_category = std::bidirectional_iterator_tag;

using value_type = json2cppJsonAdapter;

using difference_type = json2cppJsonAdapter;

using pointer = json2cppJsonAdapter *;

using reference = json2cppJsonAdapter &;

/**

explicit json2cppJsonArrayValueIterator(const json2cpp::json::const_iterator &itr) : m_itr(itr) {}

/// Returns a json2cppJsonAdapter that contains the value of the current

/// element.

json2cppJsonAdapter operator*() const { return json2cppJsonAdapter(*m_itr); }

DerefProxy<json2cppJsonAdapter> operator->() const { return DerefProxy<json2cppJsonAdapter>(**this); }

/**

bool operator==(const json2cppJsonArrayValueIterator &other) const { return m_itr == other.m_itr; }

bool operator!=(const json2cppJsonArrayValueIterator &other) const { return !(m_itr == other.m_itr); }

// cppcheck-suppress functionConst

const json2cppJsonArrayValueIterator &operator++()

{

++m_itr;

return *this;

}

// cppcheck-suppress functionConst

json2cppJsonArrayValueIterator operator++(int)

{

json2cppJsonArrayValueIterator iterator_pre(m_itr);

++(*this);

return iterator_pre;

}

// cppcheck-suppress functionConst

const json2cppJsonArrayValueIterator &operator--()

{

--m_itr;

return *this;

}

// cppcheck-suppress functionStatic

void advance(std::ptrdiff_t n) { m_itr += n; }

private:

json2cpp::json::const_iterator m_itr;

{

public:

using iterator_category = std::bidirectional_iterator_tag;

using value_type = json2cppJsonObjectMember;

using difference_type = json2cppJsonObjectMember;

using pointer = json2cppJsonObjectMember *;

using reference = json2cppJsonObjectMember &;

/**

explicit json2cppJsonObjectMemberIterator(const json2cpp::json::const_iterator &itr) : m_itr(itr) {}

/**

json2cppJsonObjectMember operator*() const { return json2cppJsonObjectMember(m_itr.key(), m_itr.value()); }

DerefProxy<json2cppJsonObjectMember> operator->() const { return DerefProxy<json2cppJsonObjectMember>(**this); }

/**

bool operator==(const json2cppJsonObjectMemberIterator &other) const { return m_itr == other.m_itr; }

bool operator!=(const json2cppJsonObjectMemberIterator &other) const { return !(m_itr == other.m_itr); }

// cppcheck-suppress functionConst

const json2cppJsonObjectMemberIterator &operator++()

{

++m_itr;

return *this;

}

// cppcheck-suppress functionConst

json2cppJsonObjectMemberIterator operator++(int)

{

json2cppJsonObjectMemberIterator iterator_pre(m_itr);

++(*this);

return iterator_pre;

}

// cppcheck-suppress functionConst

const json2cppJsonObjectMemberIterator &operator--()

{

--m_itr;

return *this;

}

private:

/// Iternal copy of the original json2cppJson iterator

json2cpp::json::const_iterator m_itr;