Auto merge of #4964 - str4d:univalue-update, r=nuttycom
Update UniValue subtree This brings us up-to-date with upstream Bitcoin's version of the library. Includes a commit cherry-picked from bitcoin/bitcoin#12193.
This commit is contained in:
commit
090e284f57
|
@ -1139,12 +1139,12 @@ static UniValue RPCLockedMemoryInfo()
|
|||
{
|
||||
LockedPool::Stats stats = LockedPoolManager::Instance().stats();
|
||||
UniValue obj(UniValue::VOBJ);
|
||||
obj.push_back(Pair("used", uint64_t(stats.used)));
|
||||
obj.push_back(Pair("free", uint64_t(stats.free)));
|
||||
obj.push_back(Pair("total", uint64_t(stats.total)));
|
||||
obj.push_back(Pair("locked", uint64_t(stats.locked)));
|
||||
obj.push_back(Pair("chunks_used", uint64_t(stats.chunks_used)));
|
||||
obj.push_back(Pair("chunks_free", uint64_t(stats.chunks_free)));
|
||||
obj.pushKV("used", uint64_t(stats.used));
|
||||
obj.pushKV("free", uint64_t(stats.free));
|
||||
obj.pushKV("total", uint64_t(stats.total));
|
||||
obj.pushKV("locked", uint64_t(stats.locked));
|
||||
obj.pushKV("chunks_used", uint64_t(stats.chunks_used));
|
||||
obj.pushKV("chunks_free", uint64_t(stats.chunks_free));
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
@ -1173,7 +1173,7 @@ UniValue getmemoryinfo(const UniValue& params, bool fHelp)
|
|||
+ HelpExampleRpc("getmemoryinfo", "")
|
||||
);
|
||||
UniValue obj(UniValue::VOBJ);
|
||||
obj.push_back(Pair("locked", RPCLockedMemoryInfo()));
|
||||
obj.pushKV("locked", RPCLockedMemoryInfo());
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,7 +25,6 @@ addons:
|
|||
- pkg-config
|
||||
|
||||
before_script:
|
||||
- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew uninstall libtool; brew install libtool; fi
|
||||
- if [ -n "$USE_SHELL" ]; then export CONFIG_SHELL="$USE_SHELL"; fi
|
||||
- test -n "$USE_SHELL" && eval '"$USE_SHELL" -c "./autogen.sh"' || ./autogen.sh
|
||||
|
||||
|
|
|
@ -12,33 +12,10 @@ an arbitrary depth.
|
|||
This class is aligned with the JSON standard, [RFC
|
||||
7159](https://tools.ietf.org/html/rfc7159.html).
|
||||
|
||||
## Motivation
|
||||
## Library usage
|
||||
|
||||
UniValue is a reaction to json_spirit, seeking to minimize template
|
||||
and memory use, providing a straightforward RAII class compatible with
|
||||
link-time optimization and embedded uses.
|
||||
|
||||
## Status
|
||||
|
||||
The current production version is available from the [stable-1.0.x branch](https://github.com/jgarzik/univalue/tree/stable-1.0.x).
|
||||
|
||||
The current development series is 1.1.x, and is pushed to the `master` branch.
|
||||
|
||||
The next stable version will be 1.2.0, to be released immediately
|
||||
following the conclusion of the 1.1.x series, similar to [this
|
||||
variant](https://en.wikipedia.org/wiki/Software_versioning#Odd-numbered_versions_for_development_releases)
|
||||
of semver.
|
||||
|
||||
## Installation
|
||||
|
||||
This project is a standard GNU
|
||||
[autotools](https://www.gnu.org/software/automake/manual/html_node/Autotools-Introduction.html)
|
||||
project. Build and install instructions are available in the `INSTALL`
|
||||
file provided with GNU autotools.
|
||||
|
||||
```
|
||||
$ ./autogen.sh
|
||||
$ ./configure
|
||||
$ make
|
||||
```
|
||||
This is a fork of univalue used by Bitcoin Core. It is not maintained for usage
|
||||
by other projects. Notably, the API may break in non-backward-compatible ways.
|
||||
|
||||
Other projects looking for a maintained library should use the upstream
|
||||
univalue at https://github.com/jgarzik/univalue.
|
||||
|
|
|
@ -1,7 +1,7 @@
|
|||
m4_define([libunivalue_major_version], [1])
|
||||
m4_define([libunivalue_minor_version], [1])
|
||||
m4_define([libunivalue_micro_version], [4])
|
||||
m4_define([libunivalue_interface_age], [4])
|
||||
m4_define([libunivalue_micro_version], [3])
|
||||
m4_define([libunivalue_interface_age], [3])
|
||||
# If you need a modifier for the version number.
|
||||
# Normally empty, but can be used to make "fixup" releases.
|
||||
m4_define([libunivalue_extraversion], [])
|
||||
|
@ -14,7 +14,7 @@ m4_define([libunivalue_age], [m4_eval(libunivalue_binary_age - libunivalue_inter
|
|||
m4_define([libunivalue_version], [libunivalue_major_version().libunivalue_minor_version().libunivalue_micro_version()libunivalue_extraversion()])
|
||||
|
||||
|
||||
AC_INIT([univalue], [1.1.1],
|
||||
AC_INIT([univalue], [1.0.3],
|
||||
[https://github.com/jgarzik/univalue/])
|
||||
|
||||
dnl make the compilation flags quiet unless V=1 is used
|
||||
|
|
|
@ -14,14 +14,17 @@
|
|||
#include <map>
|
||||
#include <cassert>
|
||||
|
||||
#include <utility> // std::pair
|
||||
#include <sstream> // .get_int64()
|
||||
|
||||
class UniValue {
|
||||
public:
|
||||
enum VType { VNULL, VOBJ, VARR, VSTR, VNUM, VBOOL, };
|
||||
|
||||
UniValue() : typ(VNULL) {}
|
||||
UniValue(UniValue::VType type, const std::string& value = std::string()) : typ(type), val(value) {}
|
||||
UniValue() { typ = VNULL; }
|
||||
UniValue(UniValue::VType initialType, const std::string& initialStr = "") {
|
||||
typ = initialType;
|
||||
val = initialStr;
|
||||
}
|
||||
UniValue(uint64_t val_) {
|
||||
setInt(val_);
|
||||
}
|
||||
|
@ -46,15 +49,6 @@ public:
|
|||
}
|
||||
|
||||
void clear();
|
||||
void reserve(size_t n) {
|
||||
if (typ == VOBJ || typ == VARR) {
|
||||
if (typ == VOBJ)
|
||||
keys.reserve(n);
|
||||
values.reserve(n);
|
||||
} else if (typ != VNULL) {
|
||||
val.reserve(n);
|
||||
}
|
||||
}
|
||||
|
||||
bool setNull();
|
||||
bool setBool(bool val);
|
||||
|
@ -90,10 +84,66 @@ public:
|
|||
bool isObject() const { return (typ == VOBJ); }
|
||||
|
||||
bool push_back(const UniValue& val);
|
||||
bool push_back(const std::string& val_) {
|
||||
UniValue tmpVal(VSTR, val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_back(const char *val_) {
|
||||
std::string s(val_);
|
||||
return push_back(s);
|
||||
}
|
||||
bool push_back(uint64_t val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_back(int64_t val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_back(bool val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_back(int val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_back(double val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return push_back(tmpVal);
|
||||
}
|
||||
bool push_backV(const std::vector<UniValue>& vec);
|
||||
|
||||
void _pushKV(const std::string& key, const UniValue& val);
|
||||
bool pushKV(const std::string& key, const UniValue& val);
|
||||
bool pushKV(const std::string& key, const std::string& val_) {
|
||||
UniValue tmpVal(VSTR, val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKV(const std::string& key, const char *val_) {
|
||||
std::string _val(val_);
|
||||
return pushKV(key, _val);
|
||||
}
|
||||
bool pushKV(const std::string& key, int64_t val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKV(const std::string& key, uint64_t val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKV(const std::string& key, bool val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKV(const std::string& key, int val_) {
|
||||
UniValue tmpVal((int64_t)val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKV(const std::string& key, double val_) {
|
||||
UniValue tmpVal(val_);
|
||||
return pushKV(key, tmpVal);
|
||||
}
|
||||
bool pushKVs(const UniValue& obj);
|
||||
|
||||
std::string write(unsigned int prettyIndent = 0,
|
||||
|
@ -129,76 +179,9 @@ public:
|
|||
const UniValue& get_array() const;
|
||||
|
||||
enum VType type() const { return getType(); }
|
||||
bool push_back(std::pair<std::string,UniValue> pear) {
|
||||
return pushKV(pear.first, pear.second);
|
||||
}
|
||||
friend const UniValue& find_value( const UniValue& obj, const std::string& name);
|
||||
};
|
||||
|
||||
//
|
||||
// The following were added for compatibility with json_spirit.
|
||||
// Most duplicate other methods, and should be removed.
|
||||
//
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, const char *cVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(cVal);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, std::string strVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(strVal);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, uint64_t u64Val)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(u64Val);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, int64_t i64Val)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(i64Val);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, bool iVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(iVal);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, int iVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(iVal);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, double dVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
UniValue uVal(dVal);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(const char *cKey, const UniValue& uVal)
|
||||
{
|
||||
std::string key(cKey);
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
static inline std::pair<std::string,UniValue> Pair(std::string key, const UniValue& uVal)
|
||||
{
|
||||
return std::make_pair(key, uVal);
|
||||
}
|
||||
|
||||
enum jtokentype {
|
||||
JTOK_ERR = -1,
|
||||
JTOK_NONE = 0, // eof
|
||||
|
|
|
@ -11,7 +11,6 @@
|
|||
#include <vector>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
|
||||
#include "univalue.h"
|
||||
|
||||
|
@ -36,7 +35,7 @@ bool ParseInt32(const std::string& str, int32_t *out)
|
|||
errno = 0; // strtol will not set errno if valid
|
||||
long int n = strtol(str.c_str(), &endp, 10);
|
||||
if(out) *out = (int32_t)n;
|
||||
// Note that strtol returns a *long int*, so even if strtol doesn't report a over/underflow
|
||||
// Note that strtol returns a *long int*, so even if strtol doesn't report an over/underflow
|
||||
// we still have to check that the returned value is within the range of an *int32_t*. On 64-bit
|
||||
// platforms the size of these types may be different.
|
||||
return endp && *endp == 0 && !errno &&
|
||||
|
|
|
@ -273,7 +273,7 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
|
||||
tok = getJsonToken(tokenVal, consumed, raw, end);
|
||||
if (tok == JTOK_NONE || tok == JTOK_ERR)
|
||||
goto return_fail;
|
||||
return false;
|
||||
raw += consumed;
|
||||
|
||||
bool isValueOpen = jsonTokenIsValue(tok) ||
|
||||
|
@ -281,33 +281,33 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
|
||||
if (expect(VALUE)) {
|
||||
if (!isValueOpen)
|
||||
goto return_fail;
|
||||
return false;
|
||||
clearExpect(VALUE);
|
||||
|
||||
} else if (expect(ARR_VALUE)) {
|
||||
bool isArrValue = isValueOpen || (tok == JTOK_ARR_CLOSE);
|
||||
if (!isArrValue)
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
clearExpect(ARR_VALUE);
|
||||
|
||||
} else if (expect(OBJ_NAME)) {
|
||||
bool isObjName = (tok == JTOK_OBJ_CLOSE || tok == JTOK_STRING);
|
||||
if (!isObjName)
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
} else if (expect(COLON)) {
|
||||
if (tok != JTOK_COLON)
|
||||
goto return_fail;
|
||||
return false;
|
||||
clearExpect(COLON);
|
||||
|
||||
} else if (!expect(COLON) && (tok == JTOK_COLON)) {
|
||||
goto return_fail;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (expect(NOT_VALUE)) {
|
||||
if (isValueOpen)
|
||||
goto return_fail;
|
||||
return false;
|
||||
clearExpect(NOT_VALUE);
|
||||
}
|
||||
|
||||
|
@ -332,7 +332,7 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
}
|
||||
|
||||
if (stack.size() > MAX_JSON_DEPTH)
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
if (utyp == VOBJ)
|
||||
setExpect(OBJ_NAME);
|
||||
|
@ -344,12 +344,12 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
case JTOK_OBJ_CLOSE:
|
||||
case JTOK_ARR_CLOSE: {
|
||||
if (!stack.size() || (last_tok == JTOK_COMMA))
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
VType utyp = (tok == JTOK_OBJ_CLOSE ? VOBJ : VARR);
|
||||
UniValue *top = stack.back();
|
||||
if (utyp != top->getType())
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
stack.pop_back();
|
||||
clearExpect(OBJ_NAME);
|
||||
|
@ -359,11 +359,11 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
|
||||
case JTOK_COLON: {
|
||||
if (!stack.size())
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
UniValue *top = stack.back();
|
||||
if (top->getType() != VOBJ)
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
setExpect(VALUE);
|
||||
break;
|
||||
|
@ -372,7 +372,7 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
case JTOK_COMMA: {
|
||||
if (!stack.size() ||
|
||||
(last_tok == JTOK_COMMA) || (last_tok == JTOK_ARR_OPEN))
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
UniValue *top = stack.back();
|
||||
if (top->getType() == VOBJ)
|
||||
|
@ -446,19 +446,15 @@ bool UniValue::read(const char *raw, size_t size)
|
|||
}
|
||||
|
||||
default:
|
||||
goto return_fail;
|
||||
return false;
|
||||
}
|
||||
} while (!stack.empty ());
|
||||
|
||||
/* Check that nothing follows the initial construct (parsed above). */
|
||||
tok = getJsonToken(tokenVal, consumed, raw, end);
|
||||
if (tok != JTOK_NONE)
|
||||
goto return_fail;
|
||||
return false;
|
||||
|
||||
return true;
|
||||
|
||||
return_fail:
|
||||
clear();
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
@ -3,6 +3,7 @@
|
|||
// file COPYING or https://opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include <iomanip>
|
||||
#include <sstream>
|
||||
#include <stdio.h>
|
||||
#include "univalue.h"
|
||||
#include "univalue_escapes.h"
|
||||
|
|
|
@ -142,8 +142,6 @@ BOOST_AUTO_TEST_CASE(univalue_set)
|
|||
BOOST_CHECK(v.isArray());
|
||||
BOOST_CHECK_EQUAL(v.size(), 0);
|
||||
|
||||
BOOST_CHECK(v.setStr(""));
|
||||
v.reserve(3);
|
||||
BOOST_CHECK(v.setStr("zum"));
|
||||
BOOST_CHECK(v.isStr());
|
||||
BOOST_CHECK_EQUAL(v.getValStr(), "zum");
|
||||
|
@ -189,7 +187,6 @@ BOOST_AUTO_TEST_CASE(univalue_set)
|
|||
BOOST_AUTO_TEST_CASE(univalue_array)
|
||||
{
|
||||
UniValue arr(UniValue::VARR);
|
||||
arr.reserve(9);
|
||||
|
||||
UniValue v((int64_t)1023LL);
|
||||
BOOST_CHECK(arr.push_back(v));
|
||||
|
@ -213,19 +210,31 @@ BOOST_AUTO_TEST_CASE(univalue_array)
|
|||
BOOST_CHECK(arr.push_back((int64_t) -400LL));
|
||||
BOOST_CHECK(arr.push_back((int) -401));
|
||||
BOOST_CHECK(arr.push_back(-40.1));
|
||||
BOOST_CHECK(arr.push_back(true));
|
||||
|
||||
BOOST_CHECK_EQUAL(arr.empty(), false);
|
||||
BOOST_CHECK_EQUAL(arr.size(), 9);
|
||||
BOOST_CHECK_EQUAL(arr.size(), 10);
|
||||
|
||||
BOOST_CHECK_EQUAL(arr[0].getValStr(), "1023");
|
||||
BOOST_CHECK_EQUAL(arr[0].getType(), UniValue::VNUM);
|
||||
BOOST_CHECK_EQUAL(arr[1].getValStr(), "zippy");
|
||||
BOOST_CHECK_EQUAL(arr[1].getType(), UniValue::VSTR);
|
||||
BOOST_CHECK_EQUAL(arr[2].getValStr(), "pippy");
|
||||
BOOST_CHECK_EQUAL(arr[2].getType(), UniValue::VSTR);
|
||||
BOOST_CHECK_EQUAL(arr[3].getValStr(), "boing");
|
||||
BOOST_CHECK_EQUAL(arr[3].getType(), UniValue::VSTR);
|
||||
BOOST_CHECK_EQUAL(arr[4].getValStr(), "going");
|
||||
BOOST_CHECK_EQUAL(arr[4].getType(), UniValue::VSTR);
|
||||
BOOST_CHECK_EQUAL(arr[5].getValStr(), "400");
|
||||
BOOST_CHECK_EQUAL(arr[5].getType(), UniValue::VNUM);
|
||||
BOOST_CHECK_EQUAL(arr[6].getValStr(), "-400");
|
||||
BOOST_CHECK_EQUAL(arr[6].getType(), UniValue::VNUM);
|
||||
BOOST_CHECK_EQUAL(arr[7].getValStr(), "-401");
|
||||
BOOST_CHECK_EQUAL(arr[7].getType(), UniValue::VNUM);
|
||||
BOOST_CHECK_EQUAL(arr[8].getValStr(), "-40.1");
|
||||
BOOST_CHECK_EQUAL(arr[8].getType(), UniValue::VNUM);
|
||||
BOOST_CHECK_EQUAL(arr[9].getValStr(), "1");
|
||||
BOOST_CHECK_EQUAL(arr[9].getType(), UniValue::VBOOL);
|
||||
|
||||
BOOST_CHECK_EQUAL(arr[999].getValStr(), "");
|
||||
|
||||
|
@ -240,8 +249,6 @@ BOOST_AUTO_TEST_CASE(univalue_object)
|
|||
std::string strKey, strVal;
|
||||
UniValue v;
|
||||
|
||||
obj.reserve(11);
|
||||
|
||||
strKey = "age";
|
||||
v.setInt(100);
|
||||
BOOST_CHECK(obj.pushKV(strKey, v));
|
||||
|
|
Loading…
Reference in New Issue