diegoripley/tippecanoe
1
0
Fork 0
mirror of https://github.com/felt/tippecanoe.git synced 2026-10-05 18:05:42 +02:00
Code Issues Packages Projects Releases Wiki Activity

Subclass json_object so primitives shrink from 168 to 24 bytes

Browse Source 
The previous "every member in a struct" layout cost 168 bytes per
json_object, even for JSON_NULL / JSON_TRUE / JSON_FALSE nodes that
have no payload. Splitting json_object into a small base class plus
json_number / json_string / json_array / json_hash subclasses brings
each instance down to just the size of its actual contents:

  json_object (base, TRUE / FALSE / NULL)   24 bytes
  json_number                                48 bytes
  json_string                                48 bytes
  json_array  (empty)                        48 bytes
  json_hash   (empty)                        72 bytes

Other size wins along the way:

* Drop enable_shared_from_this<json_object> (its embedded weak_ptr
  was 16 bytes per node). json_pull now keeps an explicit
  container_stack and the parser no longer needs to resurrect a
  shared_ptr from a raw `parent` walk.
* Remove the unused `refcon` slot from the string variant.
* No virtual destructor: shared_ptr keeps the deleter from the
  original std::make_shared<json_xxx> call, so destroying a
  shared_ptr<json_object> still runs the right subclass dtor.

The base class exposes type-tagged accessors (o->string(),
o->number(), o->array(), o->keys(), o->values(), o->large_signed(),
o->large_unsigned()) that assert the type matches and downcast to
the appropriate subclass storage. All call sites were swept from
the old `o->value.X.Y` field paths to these accessors. A raw-pointer
overload of json_hash_get() replaces the few external uses of
shared_from_this() that survived in geojson-loop.cpp.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Erica Fischer
2026-05-30 17:49:08 -07:00
co-authored by Cursor
parent 3da03c6075
commit f366b2c4aa
14 changed files with 424 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files
attribute.cpp
+4 -4
View File
@@ -55,9 +55,9 @@ void set_attribute_accum(std::unordered_map<std::string, attribute_op> &attribut
exit(EXIT_JSON); exit(EXIT_JSON);
} }
for (size_t i = 0; i < o->value.object.keys.size(); i++) { for (size_t i = 0; i < o->keys().size(); i++) {
json_object_ptr k = o->value.object.keys[i]; json_object_ptr k = o->keys()[i];
json_object_ptr v = o->value.object.values[i]; json_object_ptr v = o->values()[i];
if (k->type != JSON_STRING) { if (k->type != JSON_STRING) {
fprintf(stderr, "%s: -E%s: key %zu not a string\n", *argv, arg, i); fprintf(stderr, "%s: -E%s: key %zu not a string\n", *argv, arg, i);
@@ -68,7 +68,7 @@ void set_attribute_accum(std::unordered_map<std::string, attribute_op> &attribut
exit(EXIT_JSON); exit(EXIT_JSON);
} }
set_attribute_accum(attribute_accum, k->value.string.string.c_str(), v->value.string.string.c_str()); set_attribute_accum(attribute_accum, k->string().c_str(), v->string().c_str());
} }
return; return;
dirtiles.cpp
+4 -4
View File
@@ -260,14 +260,14 @@ sqlite3 *dirmeta2tmp(const char *fname) {
exit(EXIT_JSON); exit(EXIT_JSON);
} }
for (size_t i = 0; i < o->value.object.keys.size(); i++) { for (size_t i = 0; i < o->keys().size(); i++) {
if (o->value.object.keys[i]->type != JSON_STRING || o->value.object.values[i]->type != JSON_STRING) { if (o->keys()[i]->type != JSON_STRING || o->values()[i]->type != JSON_STRING) {
fprintf(stderr, "%s: non-string in metadata\n", name.c_str()); fprintf(stderr, "%s: non-string in metadata\n", name.c_str());
} }
char *sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES (%Q, %Q);", o->value.object.keys[i]->value.string.string.c_str(), o->value.object.values[i]->value.string.string.c_str()); char *sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES (%Q, %Q);", o->keys()[i]->string().c_str(), o->values()[i]->string().c_str());
if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) { if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set %s in metadata: %s\n", o->value.object.keys[i]->value.string.string.c_str(), err); fprintf(stderr, "set %s in metadata: %s\n", o->keys()[i]->string().c_str(), err);
} }
sqlite3_free(sql); sqlite3_free(sql);
} }
evaluator.cpp
+28 -28
View File
@@ -17,7 +17,7 @@ int compare(mvt_value const &one, json_object_ptr two, bool &fail) {
return false; // string vs non-string return false; // string vs non-string
} }
return strcmp(one.c_str(), two->value.string.string.c_str()); return strcmp(one.c_str(), two->string().c_str());
case mvt_double: case mvt_double:
case mvt_float: case mvt_float:
@@ -52,9 +52,9 @@ int compare(mvt_value const &one, json_object_ptr two, bool &fail) {
exit(EXIT_IMPOSSIBLE); exit(EXIT_IMPOSSIBLE);
} }
if (v < two->value.number.number) { if (v < two->number()) {
return -1; return -1;
} else if (v > two->value.number.number) { } else if (v > two->number()) {
return 1; return 1;
} else { } else {
return 0; return 0;
@@ -102,7 +102,7 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
} }
if (f->type == JSON_NUMBER) { if (f->type == JSON_NUMBER) {
if (f->value.number.number == 0) { if (f->number() == 0) {
return 0; return 0;
} else { } else {
return 1; return 1;
@@ -110,7 +110,7 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
} }
if (f->type == JSON_STRING) { if (f->type == JSON_STRING) {
if (f->value.string.string.empty()) { if (f->string().empty()) {
return 0; return 0;
} else { } else {
return 1; return 1;
@@ -123,39 +123,39 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (f->value.array.array.size() < 1) { if (f->array().size() < 1) {
fprintf(stderr, "Array too small in filter: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Array too small in filter: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (f->value.array.array[0]->type != JSON_STRING) { if (f->array()[0]->type != JSON_STRING) {
fprintf(stderr, "Filter operation is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Filter operation is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
const std::string &op = f->value.array.array[0]->value.string.string; const std::string &op = f->array()[0]->string();
if (op == "has" || if (op == "has" ||
op == "!has") { op == "!has") {
if (f->value.array.array.size() != 2) { if (f->array().size() != 2) {
fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (op == "has") { if (op == "has") {
if (f->value.array.array[1]->type != JSON_STRING) { if (f->array()[1]->type != JSON_STRING) {
fprintf(stderr, "\"has\" key is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "\"has\" key is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
return feature(f->value.array.array[1]->value.string.string).type != mvt_no_such_key; return feature(f->array()[1]->string()).type != mvt_no_such_key;
} }
if (op == "!has") { if (op == "!has") {
if (f->value.array.array[1]->type != JSON_STRING) { if (f->array()[1]->type != JSON_STRING) {
fprintf(stderr, "\"!has\" key is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "\"!has\" key is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
return feature(f->value.array.array[1]->value.string.string).type == mvt_no_such_key; return feature(f->array()[1]->string()).type == mvt_no_such_key;
} }
} }
@@ -165,16 +165,16 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
op == ">=" || op == ">=" ||
op == "<" || op == "<" ||
op == "<=") { op == "<=") {
if (f->value.array.array.size() != 3) { if (f->array().size() != 3) {
fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (f->value.array.array[1]->type != JSON_STRING) { if (f->array()[1]->type != JSON_STRING) {
fprintf(stderr, "comparison key is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "comparison key is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
mvt_value ff = feature(f->value.array.array[1]->value.string.string); mvt_value ff = feature(f->array()[1]->string());
if (ff.type == mvt_no_such_key) { if (ff.type == mvt_no_such_key) {
static bool warned = false; static bool warned = false;
if (!warned) { if (!warned) {
@@ -188,7 +188,7 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
} }
bool fail = false; bool fail = false;
int cmp = compare(ff, f->value.array.array[2], fail); int cmp = compare(ff, f->array()[2], fail);
if (fail) { if (fail) {
static bool warned = false; static bool warned = false;
@@ -236,8 +236,8 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
v = false; v = false;
} }
for (size_t i = 1; i < f->value.array.array.size(); i++) { for (size_t i = 1; i < f->array().size(); i++) {
int out = eval(feature, f->value.array.array[i], exclude_attributes, unidecode_data); int out = eval(feature, f->array()[i], exclude_attributes, unidecode_data);
if (out >= 0) { // nulls are ignored in boolean and/or expressions if (out >= 0) { // nulls are ignored in boolean and/or expressions
if (op == "all") { if (op == "all") {
@@ -263,17 +263,17 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
if (op == "in" || if (op == "in" ||
op == "!in") { op == "!in") {
if (f->value.array.array.size() < 2) { if (f->array().size() < 2) {
fprintf(stderr, "Array too small in filter: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Array too small in filter: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (f->value.array.array[1]->type != JSON_STRING) { if (f->array()[1]->type != JSON_STRING) {
fprintf(stderr, "\"!in\" key is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "\"!in\" key is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
mvt_value ff = feature(f->value.array.array[1]->value.string.string); mvt_value ff = feature(f->array()[1]->string());
if (ff.type == mvt_no_such_key) { if (ff.type == mvt_no_such_key) {
static bool warned = false; static bool warned = false;
if (!warned) { if (!warned) {
@@ -287,9 +287,9 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
} }
bool found = false; bool found = false;
for (size_t i = 2; i < f->value.array.array.size(); i++) { for (size_t i = 2; i < f->array().size(); i++) {
bool fail = false; bool fail = false;
int cmp = compare(ff, f->value.array.array[i], fail); int cmp = compare(ff, f->array()[i], fail);
if (fail) { if (fail) {
static bool warned = false; static bool warned = false;
@@ -314,19 +314,19 @@ static int eval(std::function<mvt_value(std::string const &)> feature, json_obje
} }
if (op == "attribute-filter") { if (op == "attribute-filter") {
if (f->value.array.array.size() != 3) { if (f->array().size() != 3) {
fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str()); fprintf(stderr, "Wrong number of array elements in filter: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
if (f->value.array.array[1]->type != JSON_STRING) { if (f->array()[1]->type != JSON_STRING) {
fprintf(stderr, "\"attribute-filter\" key is not a string: %s\n", json_stringify(f).c_str()); fprintf(stderr, "\"attribute-filter\" key is not a string: %s\n", json_stringify(f).c_str());
exit(EXIT_FILTER); exit(EXIT_FILTER);
} }
bool ok = eval(feature, f->value.array.array[2], exclude_attributes, unidecode_data) > 0; bool ok = eval(feature, f->array()[2], exclude_attributes, unidecode_data) > 0;
if (!ok) { if (!ok) {
exclude_attributes.insert(f->value.array.array[1]->value.string.string); exclude_attributes.insert(f->array()[1]->string());
} }
return true; return true;
geobuf.cpp
+3 -3
View File
@@ -400,17 +400,17 @@ void readFeature(protozero::pbf_reader &pbf, size_t dim, double e, std::vector<s
if (o != nullptr) { if (o != nullptr) {
json_object_ptr min = json_hash_get(o, "minzoom"); json_object_ptr min = json_hash_get(o, "minzoom");
if (min != nullptr && (min->type == JSON_NUMBER)) { if (min != nullptr && (min->type == JSON_NUMBER)) {
sf.tippecanoe_minzoom = integer_zoom(sst->fname, milo::dtoa_milo(min->value.number.number)); sf.tippecanoe_minzoom = integer_zoom(sst->fname, milo::dtoa_milo(min->number()));
} }
json_object_ptr max = json_hash_get(o, "maxzoom"); json_object_ptr max = json_hash_get(o, "maxzoom");
if (max != nullptr && (max->type == JSON_NUMBER)) { if (max != nullptr && (max->type == JSON_NUMBER)) {
sf.tippecanoe_maxzoom = integer_zoom(sst->fname, milo::dtoa_milo(max->value.number.number)); sf.tippecanoe_maxzoom = integer_zoom(sst->fname, milo::dtoa_milo(max->number()));
} }
json_object_ptr tlayer = json_hash_get(o, "layer"); json_object_ptr tlayer = json_hash_get(o, "layer");
if (tlayer != nullptr && (tlayer->type == JSON_STRING)) { if (tlayer != nullptr && (tlayer->type == JSON_STRING)) {
layername = tlayer->value.string.string; layername = tlayer->string();
} }
} }
} }
geojson-loop.cpp
+7 -7
View File
@@ -74,7 +74,7 @@ void parse_json(json_feature_action *jfa, json_pull_ptr jp) {
int i; int i;
int is_geometry = 0; int is_geometry = 0;
for (i = 0; i < GEOM_TYPES; i++) { for (i = 0; i < GEOM_TYPES; i++) {
if (type->value.string.string == geometry_names[i]) { if (type->string() == geometry_names[i]) {
is_geometry = 1; is_geometry = 1;
break; break;
} }
@@ -84,14 +84,14 @@ void parse_json(json_feature_action *jfa, json_pull_ptr jp) {
if (j->parent != nullptr) { if (j->parent != nullptr) {
if (j->parent->type == JSON_ARRAY && j->parent->parent != nullptr) { if (j->parent->type == JSON_ARRAY && j->parent->parent != nullptr) {
if (j->parent->parent->type == JSON_HASH) { if (j->parent->parent->type == JSON_HASH) {
json_object_ptr geometries = json_hash_get(j->parent->parent->shared_from_this(), "geometries"); json_object_ptr geometries = json_hash_get(j->parent->parent, "geometries");
if (geometries != nullptr) { if (geometries != nullptr) {
// Parent of Parent must be a GeometryCollection // Parent of Parent must be a GeometryCollection
is_geometry = 0; is_geometry = 0;
} }
} }
} else if (j->parent->type == JSON_HASH) { } else if (j->parent->type == JSON_HASH) {
json_object_ptr geometry = json_hash_get(j->parent->shared_from_this(), "geometry"); json_object_ptr geometry = json_hash_get(j->parent, "geometry");
if (geometry != nullptr) { if (geometry != nullptr) {
// Parent must be a Feature // Parent must be a Feature
is_geometry = 0; is_geometry = 0;
@@ -104,7 +104,7 @@ void parse_json(json_feature_action *jfa, json_pull_ptr jp) {
json_object *jo = j.get(); json_object *jo = j.get();
while (jo != nullptr) { while (jo != nullptr) {
if (jo->parent != nullptr && jo->parent->type == JSON_HASH) { if (jo->parent != nullptr && jo->parent->type == JSON_HASH) {
if (json_hash_get(jo->parent->shared_from_this(), "properties").get() == jo) { if (json_hash_get(jo->parent, "properties").get() == jo) {
// Ancestor is the value corresponding to a properties key // Ancestor is the value corresponding to a properties key
is_geometry = 0; is_geometry = 0;
break; break;
@@ -126,8 +126,8 @@ void parse_json(json_feature_action *jfa, json_pull_ptr jp) {
} }
} }
if (type->value.string.string != "Feature") { if (type->string() != "Feature") {
if (type->value.string.string == "FeatureCollection") { if (type->string() == "FeatureCollection") {
jfa->check_crs(j); jfa->check_crs(j);
json_free(j); json_free(j);
} }
@@ -161,7 +161,7 @@ void parse_json(json_feature_action *jfa, json_pull_ptr jp) {
json_object *jo = j.get(); json_object *jo = j.get();
while (jo != nullptr) { while (jo != nullptr) {
if (jo->parent != nullptr && jo->parent->type == JSON_HASH) { if (jo->parent != nullptr && jo->parent->type == JSON_HASH) {
if (json_hash_get(jo->parent->shared_from_this(), "properties").get() == jo) { if (json_hash_get(jo->parent, "properties").get() == jo) {
// Ancestor is the value corresponding to a properties key // Ancestor is the value corresponding to a properties key
is_feature = false; is_feature = false;
break; break;
geojson.cpp
+25 -25
View File
@@ -68,12 +68,12 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
int t; int t;
for (t = 0; t < GEOM_TYPES; t++) { for (t = 0; t < GEOM_TYPES; t++) {
if (geometry_type->value.string.string == geometry_names[t]) { if (geometry_type->string() == geometry_names[t]) {
break; break;
} }
} }
if (t >= GEOM_TYPES) { if (t >= GEOM_TYPES) {
fprintf(stderr, "%s:%d: Can't handle geometry type %s: ", sst->fname, sst->line, geometry_type->value.string.string.c_str()); fprintf(stderr, "%s:%d: Can't handle geometry type %s: ", sst->fname, sst->line, geometry_type->string().c_str());
json_context(feature); json_context(feature);
return 0; return 0;
} }
@@ -85,17 +85,17 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
if (tippecanoe != nullptr) { if (tippecanoe != nullptr) {
json_object_ptr min = json_hash_get(tippecanoe, "minzoom"); json_object_ptr min = json_hash_get(tippecanoe, "minzoom");
if (min != nullptr && (min->type == JSON_NUMBER)) { if (min != nullptr && (min->type == JSON_NUMBER)) {
tippecanoe_minzoom = integer_zoom(sst->fname, milo::dtoa_milo(min->value.number.number)); tippecanoe_minzoom = integer_zoom(sst->fname, milo::dtoa_milo(min->number()));
} }
json_object_ptr max = json_hash_get(tippecanoe, "maxzoom"); json_object_ptr max = json_hash_get(tippecanoe, "maxzoom");
if (max != nullptr && (max->type == JSON_NUMBER)) { if (max != nullptr && (max->type == JSON_NUMBER)) {
tippecanoe_maxzoom = integer_zoom(sst->fname, milo::dtoa_milo(max->value.number.number)); tippecanoe_maxzoom = integer_zoom(sst->fname, milo::dtoa_milo(max->number()));
} }
json_object_ptr ln = json_hash_get(tippecanoe, "layer"); json_object_ptr ln = json_hash_get(tippecanoe, "layer");
if (ln != nullptr && (ln->type == JSON_STRING)) { if (ln != nullptr && (ln->type == JSON_STRING)) {
tippecanoe_layername = ln->value.string.string; tippecanoe_layername = ln->string();
} }
} }
@@ -103,27 +103,27 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
unsigned long long id_value = 0; unsigned long long id_value = 0;
if (id != nullptr) { if (id != nullptr) {
if (id->type == JSON_NUMBER) { if (id->type == JSON_NUMBER) {
if (id->value.number.number >= 0) { if (id->number() >= 0) {
char *err = NULL; char *err = NULL;
std::string id_number = milo::dtoa_milo(id->value.number.number); std::string id_number = milo::dtoa_milo(id->number());
id_value = strtoull(id_number.c_str(), &err, 10); id_value = strtoull(id_number.c_str(), &err, 10);
if (id->value.number.large_unsigned != 0) { if (id->large_unsigned() != 0) {
id_value = id->value.number.large_unsigned; id_value = id->large_unsigned();
} }
if (err != NULL && *err != '\0') { if (err != NULL && *err != '\0') {
static bool warned_frac = false; static bool warned_frac = false;
if (!warned_frac) { if (!warned_frac) {
fprintf(stderr, "Warning: Can't represent non-integer feature ID %s\n", milo::dtoa_milo(id->value.number.number).c_str()); fprintf(stderr, "Warning: Can't represent non-integer feature ID %s\n", milo::dtoa_milo(id->number()).c_str());
warned_frac = true; warned_frac = true;
} }
} else if (id->value.number.large_unsigned == 0 && std::to_string(id_value) != milo::dtoa_milo(id->value.number.number)) { } else if (id->large_unsigned() == 0 && std::to_string(id_value) != milo::dtoa_milo(id->number())) {
static bool warned = false; static bool warned = false;
if (!warned) { if (!warned) {
fprintf(stderr, "Warning: Can't represent too-large feature ID %s\n", milo::dtoa_milo(id->value.number.number).c_str()); fprintf(stderr, "Warning: Can't represent too-large feature ID %s\n", milo::dtoa_milo(id->number()).c_str());
warned = true; warned = true;
} }
} else { } else {
@@ -133,7 +133,7 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
static bool warned_neg = false; static bool warned_neg = false;
if (!warned_neg) { if (!warned_neg) {
fprintf(stderr, "Warning: Can't represent negative feature ID %s\n", milo::dtoa_milo(id->value.number.number).c_str()); fprintf(stderr, "Warning: Can't represent negative feature ID %s\n", milo::dtoa_milo(id->number()).c_str());
warned_neg = true; warned_neg = true;
} }
} }
@@ -142,20 +142,20 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
if (additional[A_CONVERT_NUMERIC_IDS] && id->type == JSON_STRING) { if (additional[A_CONVERT_NUMERIC_IDS] && id->type == JSON_STRING) {
char *err = NULL; char *err = NULL;
id_value = strtoull(id->value.string.string.c_str(), &err, 10); id_value = strtoull(id->string().c_str(), &err, 10);
if (err != NULL && *err != '\0') { if (err != NULL && *err != '\0') {
static bool warned_frac = false; static bool warned_frac = false;
if (!warned_frac) { if (!warned_frac) {
fprintf(stderr, "Warning: Can't represent non-integer feature ID %s\n", id->value.string.string.c_str()); fprintf(stderr, "Warning: Can't represent non-integer feature ID %s\n", id->string().c_str());
warned_frac = true; warned_frac = true;
} }
} else if (std::to_string(id_value) != id->value.string.string) { } else if (std::to_string(id_value) != id->string()) {
static bool warned = false; static bool warned = false;
if (!warned) { if (!warned) {
fprintf(stderr, "Warning: Can't represent too-large feature ID %s\n", id->value.string.string.c_str()); fprintf(stderr, "Warning: Can't represent too-large feature ID %s\n", id->string().c_str());
warned = true; warned = true;
} }
} else { } else {
@@ -177,7 +177,7 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
size_t nprop = 0; size_t nprop = 0;
if (properties != nullptr && properties->type == JSON_HASH) { if (properties != nullptr && properties->type == JSON_HASH) {
nprop = properties->value.object.keys.size(); nprop = properties->keys().size();
} }
std::vector<std::shared_ptr<std::string>> full_keys; std::vector<std::shared_ptr<std::string>> full_keys;
@@ -188,10 +188,10 @@ int serialize_geojson_feature(struct serialization_state *sst, json_object_ptr g
key_pool key_pool; key_pool key_pool;
for (size_t i = 0; i < nprop; i++) { for (size_t i = 0; i < nprop; i++) {
if (properties->value.object.keys[i]->type == JSON_STRING) { if (properties->keys()[i]->type == JSON_STRING) {
serial_val sv = stringify_value(properties->value.object.values[i], sst->fname, sst->line, feature); serial_val sv = stringify_value(properties->values()[i], sst->fname, sst->line, feature);
full_keys.emplace_back(key_pool.pool(properties->value.object.keys[i]->value.string.string.c_str())); full_keys.emplace_back(key_pool.pool(properties->keys()[i]->string().c_str()));
values.push_back(std::move(sv)); values.push_back(std::move(sv));
} }
} }
@@ -223,9 +223,9 @@ void check_crs(json_object_ptr j, const char *reading) {
if (properties != nullptr) { if (properties != nullptr) {
json_object_ptr name = json_hash_get(properties, "name"); json_object_ptr name = json_hash_get(properties, "name");
if (name != nullptr && name->type == JSON_STRING) { if (name != nullptr && name->type == JSON_STRING) {
if (name->value.string.string != projection->alias) { if (name->string() != projection->alias) {
if (!quiet) { if (!quiet) {
fprintf(stderr, "%s: Warning: GeoJSON specified projection \"%s\", not the expected \"%s\".\n", reading, name->value.string.string.c_str(), projection->alias); fprintf(stderr, "%s: Warning: GeoJSON specified projection \"%s\", not the expected \"%s\".\n", reading, name->string().c_str(), projection->alias);
fprintf(stderr, "%s: If \"%s\" is not the expected projection, use -s to specify the right one.\n", reading, projection->alias); fprintf(stderr, "%s: If \"%s\" is not the expected projection, use -s to specify the right one.\n", reading, projection->alias);
} }
} }
@@ -243,8 +243,8 @@ struct json_serialize_action : json_feature_action {
sst->line = geometry->parser->line; sst->line = geometry->parser->line;
if (geometrycollection) { if (geometrycollection) {
int ret = 1; int ret = 1;
for (size_t g = 0; g < geometry->value.array.array.size(); g++) { for (size_t g = 0; g < geometry->array().size(); g++) {
ret &= serialize_geojson_feature(sst, geometry->value.array.array[g], properties, id, layer, tippecanoe, feature, layername); ret &= serialize_geojson_feature(sst, geometry->array()[g], properties, id, layer, tippecanoe, feature, layername);
} }
return ret; return ret;
} else { } else {
jsonpull/jsonpull.cpp
+112 -83
View File
@@ -86,22 +86,47 @@ static inline int read_wrap(json_pull *j) {
return c; return c;
} }
static json_object_ptr fabricate_object(json_pull *jp, json_object *parent, json_type type) { // Construct an instance of the right subclass for the given type.
auto o = std::make_shared<json_object>(); // JSON_TRUE / JSON_FALSE / JSON_NULL and the parse-token types are bare
o->type = type; // json_objects; the value-bearing types each get their own subclass.
o->parent = parent; static json_object_ptr make_object(json_type type, json_object *parent, json_pull *jp) {
o->parser = jp; json_object_ptr o;
switch (type) {
case JSON_NUMBER:
o = std::make_shared<json_number>(parent, jp);
break;
case JSON_STRING:
o = std::make_shared<json_string>(parent, jp);
break;
case JSON_ARRAY:
o = std::make_shared<json_array>(parent, jp);
break;
case JSON_HASH:
o = std::make_shared<json_hash>(parent, jp);
break;
default:
o = std::make_shared<json_object>(type, parent, jp);
break;
}
return o; return o;
} }
static json_object_ptr fabricate_object(json_pull *jp, json_object *parent, json_type type) {
return make_object(type, parent, jp);
}
static inline json_object *current_container(json_pull *j) {
return j->container_stack.empty() ? nullptr : j->container_stack.back().get();
}
static json_object_ptr add_object(json_pull *j, json_type type) { static json_object_ptr add_object(json_pull *j, json_type type) {
json_object *c = j->container.get(); json_object *c = current_container(j);
json_object_ptr o = fabricate_object(j, c, type); json_object_ptr o = make_object(type, c, j);
if (c != nullptr) { if (c != nullptr) {
if (c->type == JSON_ARRAY) { if (c->type == JSON_ARRAY) {
if (c->expect == JSON_ITEM) { if (c->expect == JSON_ITEM) {
c->value.array.array.push_back(o); c->array().push_back(o);
c->expect = JSON_COMMA; c->expect = JSON_COMMA;
} else { } else {
j->error = "Expected a comma, not a list item"; j->error = "Expected a comma, not a list item";
@@ -109,7 +134,7 @@ static json_object_ptr add_object(json_pull *j, json_type type) {
} }
} else if (c->type == JSON_HASH) { } else if (c->type == JSON_HASH) {
if (c->expect == JSON_VALUE) { if (c->expect == JSON_VALUE) {
c->value.object.values.back() = o; c->values().back() = o;
c->expect = JSON_COMMA; c->expect = JSON_COMMA;
} else if (c->expect == JSON_KEY) { } else if (c->expect == JSON_KEY) {
if (type != JSON_STRING) { if (type != JSON_STRING) {
@@ -117,8 +142,8 @@ static json_object_ptr add_object(json_pull *j, json_type type) {
return nullptr; return nullptr;
} }
c->value.object.keys.push_back(o); c->keys().push_back(o);
c->value.object.values.push_back(nullptr); c->values().push_back(nullptr);
c->expect = JSON_COLON; c->expect = JSON_COLON;
} else { } else {
j->error = "Expected a comma or colon"; j->error = "Expected a comma or colon";
@@ -134,16 +159,18 @@ static json_object_ptr add_object(json_pull *j, json_type type) {
return o; return o;
} }
json_object_ptr json_hash_get(json_object_ptr o, const char *s) { json_object_ptr json_hash_get(json_object *o, const char *s) {
if (o == nullptr || o->type != JSON_HASH) { if (o == nullptr || o->type != JSON_HASH) {
return nullptr; return nullptr;
} }
for (size_t i = 0; i < o->value.object.keys.size(); i++) { const auto &keys = o->keys();
const auto &key = o->value.object.keys[i]; const auto &vals = o->values();
for (size_t i = 0; i < keys.size(); i++) {
const auto &key = keys[i];
if (key != nullptr && key->type == JSON_STRING) { if (key != nullptr && key->type == JSON_STRING) {
if (key->value.string.string == s) { if (key->string() == s) {
return o->value.object.values[i]; return vals[i];
} }
} }
} }
@@ -151,19 +178,23 @@ json_object_ptr json_hash_get(json_object_ptr o, const char *s) {
return nullptr; return nullptr;
} }
json_object_ptr json_hash_get(json_object_ptr o, const char *s) {
return json_hash_get(o.get(), s);
}
json_object_ptr json_read_separators(json_pull_ptr jp, json_separator_callback cb, void *state) { json_object_ptr json_read_separators(json_pull_ptr jp, json_separator_callback cb, void *state) {
int c; int c;
json_pull *j = jp.get(); json_pull *j = jp.get();
// In case there is an error at the top level // In case there is an error at the top level
if (j->container == nullptr) { if (j->container_stack.empty()) {
j->root.reset(); j->root.reset();
} }
again: again:
c = read_wrap(j); c = read_wrap(j);
if (c == EOF) { if (c == EOF) {
if (j->container != nullptr) { if (!j->container_stack.empty()) {
j->error = "Reached EOF without all containers being closed"; j->error = "Reached EOF without all containers being closed";
} }
@@ -204,8 +235,8 @@ again:
if (o == nullptr) { if (o == nullptr) {
return nullptr; return nullptr;
} }
j->container = o; o->expect = JSON_ITEM;
j->container->expect = JSON_ITEM; j->container_stack.push_back(o);
if (cb != nullptr) { if (cb != nullptr) {
cb(JSON_ARRAY, j, state); cb(JSON_ARRAY, j, state);
@@ -215,32 +246,26 @@ again:
} }
case ']': { case ']': {
if (j->container == nullptr) { json_object *cc = current_container(j);
if (cc == nullptr) {
j->error = "Found ] at top level"; j->error = "Found ] at top level";
return nullptr; return nullptr;
} }
if (j->container->type != JSON_ARRAY) { if (cc->type != JSON_ARRAY) {
j->error = "Found ] not in an array"; j->error = "Found ] not in an array";
return nullptr; return nullptr;
} }
if (j->container->expect != JSON_COMMA) { if (cc->expect != JSON_COMMA) {
if (!(j->container->expect == JSON_ITEM && j->container->value.array.array.size() == 0)) { if (!(cc->expect == JSON_ITEM && cc->array().size() == 0)) {
j->error = "Found ] without final element"; j->error = "Found ] without final element";
return nullptr; return nullptr;
} }
} }
json_object_ptr ret = j->container; json_object_ptr ret = j->container_stack.back();
// Walk up to the parent container. The parent (if any) still owns j->container_stack.pop_back();
// `ret` via its own array vector, so the raw `parent` pointer is
// still valid and we can resurrect a shared_ptr to it.
if (ret->parent != nullptr) {
j->container = ret->parent->shared_from_this();
} else {
j->container.reset();
}
return ret; return ret;
} }
@@ -251,8 +276,8 @@ again:
if (o == nullptr) { if (o == nullptr) {
return nullptr; return nullptr;
} }
j->container = o; o->expect = JSON_KEY;
j->container->expect = JSON_KEY; j->container_stack.push_back(o);
if (cb != nullptr) { if (cb != nullptr) {
cb(JSON_HASH, j, state); cb(JSON_HASH, j, state);
@@ -262,29 +287,26 @@ again:
} }
case '}': { case '}': {
if (j->container == nullptr) { json_object *cc = current_container(j);
if (cc == nullptr) {
j->error = "Found } at top level"; j->error = "Found } at top level";
return nullptr; return nullptr;
} }
if (j->container->type != JSON_HASH) { if (cc->type != JSON_HASH) {
j->error = "Found } not in a hash"; j->error = "Found } not in a hash";
return nullptr; return nullptr;
} }
if (j->container->expect != JSON_COMMA) { if (cc->expect != JSON_COMMA) {
if (!(j->container->expect == JSON_KEY && j->container->value.object.keys.size() == 0)) { if (!(cc->expect == JSON_KEY && cc->keys().size() == 0)) {
j->error = "Found } without final element"; j->error = "Found } without final element";
return nullptr; return nullptr;
} }
} }
json_object_ptr ret = j->container; json_object_ptr ret = j->container_stack.back();
if (ret->parent != nullptr) { j->container_stack.pop_back();
j->container = ret->parent->shared_from_this();
} else {
j->container.reset();
}
return ret; return ret;
} }
@@ -350,16 +372,17 @@ again:
/////////////////////////// Comma /////////////////////////// Comma
case ',': { case ',': {
if (j->container != nullptr) { json_object *cc = current_container(j);
if (j->container->expect != JSON_COMMA) { if (cc != nullptr) {
if (cc->expect != JSON_COMMA) {
j->error = "Found unexpected comma"; j->error = "Found unexpected comma";
return nullptr; return nullptr;
} }
if (j->container->type == JSON_HASH) { if (cc->type == JSON_HASH) {
j->container->expect = JSON_KEY; cc->expect = JSON_KEY;
} else { } else {
j->container->expect = JSON_ITEM; cc->expect = JSON_ITEM;
} }
} }
@@ -373,17 +396,18 @@ again:
/////////////////////////// Colon /////////////////////////// Colon
case ':': { case ':': {
if (j->container == nullptr) { json_object *cc = current_container(j);
if (cc == nullptr) {
j->error = "Found colon at top level"; j->error = "Found colon at top level";
return nullptr; return nullptr;
} }
if (j->container->expect != JSON_COLON) { if (cc->expect != JSON_COLON) {
j->error = "Found unexpected colon"; j->error = "Found unexpected colon";
return nullptr; return nullptr;
} }
j->container->expect = JSON_VALUE; cc->expect = JSON_VALUE;
if (cb != nullptr) { if (cb != nullptr) {
cb(JSON_COLON, j, state); cb(JSON_COLON, j, state);
@@ -463,27 +487,27 @@ again:
json_object_ptr n = add_object(j, JSON_NUMBER); json_object_ptr n = add_object(j, JSON_NUMBER);
if (n != nullptr) { if (n != nullptr) {
n->value.number.number = atof(j->number_buffer.c_str()); n->number() = atof(j->number_buffer.c_str());
n->value.number.large_signed = 0; n->large_signed() = 0;
n->value.number.large_unsigned = 0; n->large_unsigned() = 0;
#define MAX_SAFE_INTEGER 9007199254740991.0 #define MAX_SAFE_INTEGER 9007199254740991.0
#define MIN_SAFE_INTEGER -9007199254740991.0 #define MIN_SAFE_INTEGER -9007199254740991.0
if (!decimal && n->value.number.number > MAX_SAFE_INTEGER) { if (!decimal && n->number() > MAX_SAFE_INTEGER) {
errno = 0; errno = 0;
char *err = nullptr; char *err = nullptr;
unsigned long long ull = strtoull(j->number_buffer.c_str(), &err, 10); unsigned long long ull = strtoull(j->number_buffer.c_str(), &err, 10);
if (errno == 0 && (err == nullptr || *err == '\0')) { if (errno == 0 && (err == nullptr || *err == '\0')) {
n->value.number.large_unsigned = ull; n->large_unsigned() = ull;
} }
} }
if (!decimal && n->value.number.number < MIN_SAFE_INTEGER) { if (!decimal && n->number() < MIN_SAFE_INTEGER) {
errno = 0; errno = 0;
char *err = nullptr; char *err = nullptr;
long long ll = strtoll(j->number_buffer.c_str(), &err, 10); long long ll = strtoll(j->number_buffer.c_str(), &err, 10);
if (errno == 0 && (err == nullptr || *err == '\0')) { if (errno == 0 && (err == nullptr || *err == '\0')) {
n->value.number.large_signed = ll; n->large_signed() = ll;
} }
} }
} }
@@ -614,8 +638,7 @@ again:
json_object_ptr s = add_object(j, JSON_STRING); json_object_ptr s = add_object(j, JSON_STRING);
if (s != nullptr) { if (s != nullptr) {
s->value.string.string = std::move(val); s->string() = std::move(val);
s->value.string.refcon = nullptr;
} }
return s; return s;
} }
@@ -653,13 +676,16 @@ static void clear_back_pointers(json_object *o) {
} }
if (o->type == JSON_HASH) { if (o->type == JSON_HASH) {
for (size_t i = 0; i < o->value.object.keys.size(); i++) { const auto &keys = o->keys();
clear_back_pointers(o->value.object.keys[i].get()); const auto &vals = o->values();
clear_back_pointers(o->value.object.values[i].get()); for (size_t i = 0; i < keys.size(); i++) {
clear_back_pointers(keys[i].get());
clear_back_pointers(vals[i].get());
} }
} else if (o->type == JSON_ARRAY) { } else if (o->type == JSON_ARRAY) {
for (size_t i = 0; i < o->value.array.array.size(); i++) { const auto &arr = o->array();
clear_back_pointers(o->value.array.array[i].get()); for (size_t i = 0; i < arr.size(); i++) {
clear_back_pointers(arr[i].get());
} }
} }
@@ -679,7 +705,7 @@ void json_disconnect(json_object_ptr o) {
json_object *parent = o->parent; json_object *parent = o->parent;
if (parent != nullptr) { if (parent != nullptr) {
if (parent->type == JSON_ARRAY) { if (parent->type == JSON_ARRAY) {
auto &arr = parent->value.array.array; auto &arr = parent->array();
for (size_t i = 0; i < arr.size(); i++) { for (size_t i = 0; i < arr.size(); i++) {
if (arr[i].get() == o.get()) { if (arr[i].get() == o.get()) {
arr.erase(arr.begin() + i); arr.erase(arr.begin() + i);
@@ -687,8 +713,8 @@ void json_disconnect(json_object_ptr o) {
} }
} }
} else if (parent->type == JSON_HASH) { } else if (parent->type == JSON_HASH) {
auto &keys = parent->value.object.keys; auto &keys = parent->keys();
auto &vals = parent->value.object.values; auto &vals = parent->values();
for (size_t i = 0; i < keys.size(); i++) { for (size_t i = 0; i < keys.size(); i++) {
if (keys[i].get() == o.get()) { if (keys[i].get() == o.get()) {
@@ -739,7 +765,7 @@ static void json_print_one(std::string &val, json_object *o) {
} else if (o->type == JSON_STRING) { } else if (o->type == JSON_STRING) {
string_append_c(val, '\"'); string_append_c(val, '\"');
for (const char *cp = o->value.string.string.c_str(); *cp != '\0'; cp++) { for (const char *cp = o->string().c_str(); *cp != '\0'; cp++) {
if (*cp == '\\' || *cp == '"') { if (*cp == '\\' || *cp == '"') {
string_append_c(val, '\\'); string_append_c(val, '\\');
string_append_c(val, *cp); string_append_c(val, *cp);
@@ -756,16 +782,16 @@ static void json_print_one(std::string &val, json_object *o) {
string_append_c(val, '\"'); string_append_c(val, '\"');
} else if (o->type == JSON_NUMBER) { } else if (o->type == JSON_NUMBER) {
if (o->value.number.large_signed != 0) { if (o->large_signed() != 0) {
char s[65]; char s[65];
snprintf(s, sizeof(s), "%lld", o->value.number.large_signed); snprintf(s, sizeof(s), "%lld", o->large_signed());
string_append(val, s); string_append(val, s);
} else if (o->value.number.large_unsigned != 0) { } else if (o->large_unsigned() != 0) {
char s[65]; char s[65];
snprintf(s, sizeof(s), "%llu", o->value.number.large_unsigned); snprintf(s, sizeof(s), "%llu", o->large_unsigned());
string_append(val, s); string_append(val, s);
} else { } else {
char *s = dtoa_milo(o->value.number.number); char *s = dtoa_milo(o->number());
string_append(val, s); string_append(val, s);
free(s); free(s);
} }
@@ -789,20 +815,23 @@ static void json_print(std::string &val, json_object *o) {
} else if (o->type == JSON_HASH) { } else if (o->type == JSON_HASH) {
string_append_c(val, '{'); string_append_c(val, '{');
for (size_t i = 0; i < o->value.object.keys.size(); i++) { const auto &keys = o->keys();
json_print(val, o->value.object.keys[i].get()); const auto &vals = o->values();
for (size_t i = 0; i < keys.size(); i++) {
json_print(val, keys[i].get());
string_append_c(val, ':'); string_append_c(val, ':');
json_print(val, o->value.object.values[i].get()); json_print(val, vals[i].get());
if (i + 1 < o->value.object.keys.size()) { if (i + 1 < keys.size()) {
string_append_c(val, ','); string_append_c(val, ',');
} }
} }
string_append_c(val, '}'); string_append_c(val, '}');
} else if (o->type == JSON_ARRAY) { } else if (o->type == JSON_ARRAY) {
string_append_c(val, '['); string_append_c(val, '[');
for (size_t i = 0; i < o->value.array.array.size(); i++) { const auto &arr = o->array();
json_print(val, o->value.array.array[i].get()); for (size_t i = 0; i < arr.size(); i++) {
if (i + 1 < o->value.array.array.size()) { json_print(val, arr[i].get());
if (i + 1 < arr.size()) {
string_append_c(val, ','); string_append_c(val, ',');
} }
} }
jsonpull/jsonpull.h
+143 -33
View File
@@ -3,6 +3,7 @@
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include <cassert>
#include <memory> #include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
@@ -33,48 +34,152 @@ struct json_pull;
typedef std::shared_ptr<json_object> json_object_ptr; typedef std::shared_ptr<json_object> json_object_ptr;
typedef std::shared_ptr<json_pull> json_pull_ptr; typedef std::shared_ptr<json_pull> json_pull_ptr;
// json_object owns its descendants via std::shared_ptr in std::vector<>s, // json_object is a small base type that just records the JSON type and
// and keeps raw back-pointers to its parent and to the parser. The back-pointers // the back-pointers to its parent and parser. The actual value payload
// remain valid as long as the node is attached to the tree (the parent is kept // lives in a type-specific subclass (json_number, json_string, json_array,
// alive by holding a shared_ptr to this child, and the parser is kept alive by // json_hash), so that JSON_TRUE / JSON_FALSE / JSON_NULL nodes pay only
// the caller's json_pull_ptr). json_disconnect() splices a node out of its // the base-class cost and a JSON_HASH does not also drag along a string
// parent and clears those back-pointers in the detached subtree, so the // or a number field. Type-tagged accessor methods on the base class
// detached subtree can outlive the original parser. // downcast and return references to the underlying subclass storage.
//
// Children are owned by their parent (via std::vector<json_object_ptr>
// inside json_array / json_hash); the raw `parent` and `parser`
// back-pointers stay valid as long as the node is attached to the tree.
// json_disconnect() splices a node out of its parent and walks the
// detached subtree clearing those back-pointers so the subtree can
// outlive the original parser.
//
// json_object intentionally has no virtual functions and no virtual
// destructor: subclasses are constructed via std::make_shared<json_xxx>(),
// and std::shared_ptr remembers the deleter from the original type, so
// destroying a shared_ptr<json_object> that actually points at a
// json_string still runs ~json_string(). Dispatch on `type` is what the
// rest of the code already does. The accessor methods assert at debug
// time that the type matches before downcasting.
struct json_object : public std::enable_shared_from_this<json_object> { struct json_object {
json_object *parent = nullptr; json_object *parent = nullptr;
json_pull *parser = nullptr; json_pull *parser = nullptr;
json_type type = JSON_NULL; json_type type;
int expect = 0; int expect = 0; // used by the parser on JSON_ARRAY / JSON_HASH nodes
// Members named to match the previous C union layout so that existing json_object(json_type t) : type(t) {}
// access paths like `o->value.string.string` and `o->value.array.array[i]` json_object(json_type t, json_object *p, json_pull *pl) : parent(p), parser(pl), type(t) {}
// continue to work. This is no longer a union because std::string and
// std::vector have non-trivial destructors.
struct value_t {
struct {
double number = 0;
unsigned long long large_unsigned = 0;
long long large_signed = 0;
} number;
struct { // Type-tagged accessors. Each one asserts that the receiver is of
std::string string; // the right kind, then downcasts to the storage in the appropriate
void *refcon = nullptr; // reference constant for caller's use // subclass. Inline so the assert and cast disappear at -O.
} string; inline std::string &string();
inline const std::string &string() const;
struct { inline double &number();
std::vector<json_object_ptr> array; inline double number() const;
} array; inline unsigned long long &large_unsigned();
inline unsigned long long large_unsigned() const;
inline long long &large_signed();
inline long long large_signed() const;
struct { inline std::vector<json_object_ptr> &array();
std::vector<json_object_ptr> keys; inline const std::vector<json_object_ptr> &array() const;
std::vector<json_object_ptr> values;
} object; inline std::vector<json_object_ptr> &keys();
} value; inline const std::vector<json_object_ptr> &keys() const;
inline std::vector<json_object_ptr> &values();
inline const std::vector<json_object_ptr> &values() const;
}; };
struct json_number : json_object {
double number_value = 0;
unsigned long long large_unsigned_value = 0;
long long large_signed_value = 0;
json_number() : json_object(JSON_NUMBER) {}
json_number(json_object *p, json_pull *pl) : json_object(JSON_NUMBER, p, pl) {}
};
struct json_string : json_object {
std::string string_value;
json_string() : json_object(JSON_STRING) {}
json_string(json_object *p, json_pull *pl) : json_object(JSON_STRING, p, pl) {}
};
struct json_array : json_object {
std::vector<json_object_ptr> array_value;
json_array() : json_object(JSON_ARRAY) {}
json_array(json_object *p, json_pull *pl) : json_object(JSON_ARRAY, p, pl) {}
};
struct json_hash : json_object {
std::vector<json_object_ptr> keys_value;
std::vector<json_object_ptr> values_value;
json_hash() : json_object(JSON_HASH) {}
json_hash(json_object *p, json_pull *pl) : json_object(JSON_HASH, p, pl) {}
};
inline std::string &json_object::string() {
assert(type == JSON_STRING);
return static_cast<json_string *>(this)->string_value;
}
inline const std::string &json_object::string() const {
assert(type == JSON_STRING);
return static_cast<const json_string *>(this)->string_value;
}
inline double &json_object::number() {
assert(type == JSON_NUMBER);
return static_cast<json_number *>(this)->number_value;
}
inline double json_object::number() const {
assert(type == JSON_NUMBER);
return static_cast<const json_number *>(this)->number_value;
}
inline unsigned long long &json_object::large_unsigned() {
assert(type == JSON_NUMBER);
return static_cast<json_number *>(this)->large_unsigned_value;
}
inline unsigned long long json_object::large_unsigned() const {
assert(type == JSON_NUMBER);
return static_cast<const json_number *>(this)->large_unsigned_value;
}
inline long long &json_object::large_signed() {
assert(type == JSON_NUMBER);
return static_cast<json_number *>(this)->large_signed_value;
}
inline long long json_object::large_signed() const {
assert(type == JSON_NUMBER);
return static_cast<const json_number *>(this)->large_signed_value;
}
inline std::vector<json_object_ptr> &json_object::array() {
assert(type == JSON_ARRAY);
return static_cast<json_array *>(this)->array_value;
}
inline const std::vector<json_object_ptr> &json_object::array() const {
assert(type == JSON_ARRAY);
return static_cast<const json_array *>(this)->array_value;
}
inline std::vector<json_object_ptr> &json_object::keys() {
assert(type == JSON_HASH);
return static_cast<json_hash *>(this)->keys_value;
}
inline const std::vector<json_object_ptr> &json_object::keys() const {
assert(type == JSON_HASH);
return static_cast<const json_hash *>(this)->keys_value;
}
inline std::vector<json_object_ptr> &json_object::values() {
assert(type == JSON_HASH);
return static_cast<json_hash *>(this)->values_value;
}
inline const std::vector<json_object_ptr> &json_object::values() const {
assert(type == JSON_HASH);
return static_cast<const json_hash *>(this)->values_value;
}
struct json_pull { struct json_pull {
const char *error = nullptr; // points at a string literal; no allocation const char *error = nullptr; // points at a string literal; no allocation
int line = 1; int line = 1;
@@ -85,7 +190,11 @@ struct json_pull {
ssize_t buffer_tail = 0; ssize_t buffer_tail = 0;
ssize_t buffer_head = 0; ssize_t buffer_head = 0;
json_object_ptr container; // Stack of currently-open containers; the top is the innermost container
// being parsed. Replaces the previous single `container` pointer / parent
// walk, which previously required enable_shared_from_this<json_object>
// on every json_object instance (16 extra bytes per node).
std::vector<json_object_ptr> container_stack;
json_object_ptr root; json_object_ptr root;
std::string number_buffer; std::string number_buffer;
@@ -118,6 +227,7 @@ void json_free(json_object_ptr &j);
void json_disconnect(json_object_ptr j); void json_disconnect(json_object_ptr j);
json_object_ptr json_hash_get(json_object_ptr o, const char *s); json_object_ptr json_hash_get(json_object_ptr o, const char *s);
json_object_ptr json_hash_get(json_object *o, const char *s);
std::string json_stringify(json_object_ptr o); std::string json_stringify(json_object_ptr o);
jsontool.cpp
+16 -22
View File
@@ -149,7 +149,7 @@ void out(std::string const &s, int type, json_object_ptr properties) {
if (o != nullptr) { if (o != nullptr) {
found = true; found = true;
if (o->type == JSON_STRING || o->type == JSON_NUMBER) { if (o->type == JSON_STRING || o->type == JSON_NUMBER) {
extracted = sort_quote(o->value.string.string.c_str()); extracted = sort_quote(o->string().c_str());
} else { } else {
extracted = sort_quote(json_stringify(o).c_str()); extracted = sort_quote(json_stringify(o).c_str());
} }
@@ -244,9 +244,9 @@ void join_csv(json_object_ptr j) {
std::string joinkey; std::string joinkey;
if (key->type == JSON_STRING) { if (key->type == JSON_STRING) {
joinkey = key->value.string.string; joinkey = key->string();
} else if (key->type == JSON_NUMBER) { } else if (key->type == JSON_NUMBER) {
joinkey = milo::dtoa_milo(key->value.number.number); joinkey = milo::dtoa_milo(key->number());
} else { } else {
joinkey = json_stringify(key); joinkey = json_stringify(key);
} }
@@ -298,8 +298,8 @@ void join_csv(json_object_ptr j) {
} }
if (fields.size() > 0 && joinkey == fields[0]) { if (fields.size() > 0 && joinkey == fields[0]) {
properties->value.object.keys.reserve(properties->value.object.keys.size() + fields.size()); properties->keys().reserve(properties->keys().size() + fields.size());
properties->value.object.values.reserve(properties->value.object.values.size() + fields.size()); properties->values().reserve(properties->values().size() + fields.size());
for (size_t i = 1; i < fields.size(); i++) { for (size_t i = 1; i < fields.size(); i++) {
std::string k = header[i]; std::string k = header[i];
@@ -317,30 +317,24 @@ void join_csv(json_object_ptr j) {
} }
if (attr_type != JSON_NULL) { if (attr_type != JSON_NULL) {
auto ko = std::make_shared<json_object>(); auto ko = std::make_shared<json_string>(properties.get(), properties->parser);
auto vo = std::make_shared<json_object>(); ko->string_value = k;
ko->type = JSON_STRING;
ko->parent = properties.get();
ko->parser = properties->parser;
ko->value.string.string = k;
vo->type = attr_type;
vo->parent = properties.get();
vo->parser = properties->parser;
json_object_ptr vo;
if (attr_type == JSON_STRING) { if (attr_type == JSON_STRING) {
vo->value.string.string = v; auto s = std::make_shared<json_string>(properties.get(), properties->parser);
s->string_value = v;
vo = s;
} else if (attr_type == JSON_NUMBER) { } else if (attr_type == JSON_NUMBER) {
vo->value.number.number = atof(v.c_str()); auto n = std::make_shared<json_number>(properties.get(), properties->parser);
vo->value.number.large_unsigned = 0; n->number_value = atof(v.c_str());
vo->value.number.large_signed = 0; vo = n;
} else { } else {
abort(); abort();
} }
properties->value.object.keys.push_back(ko); properties->keys().push_back(ko);
properties->value.object.values.push_back(vo); properties->values().push_back(vo);
} }
} }
} }
main.cpp
+8 -8
View File
@@ -2885,9 +2885,9 @@ void set_attribute_value(const char *arg) {
exit(EXIT_JSON); exit(EXIT_JSON);
} }
for (size_t i = 0; i < o->value.object.keys.size(); i++) { for (size_t i = 0; i < o->keys().size(); i++) {
json_object_ptr k = o->value.object.keys[i]; json_object_ptr k = o->keys()[i];
json_object_ptr v = o->value.object.values[i]; json_object_ptr v = o->values()[i];
if (k->type != JSON_STRING) { if (k->type != JSON_STRING) {
fprintf(stderr, "%s: --set-attribute %s: key %zu not a string\n", *av, arg, i); fprintf(stderr, "%s: --set-attribute %s: key %zu not a string\n", *av, arg, i);
@@ -2895,7 +2895,7 @@ void set_attribute_value(const char *arg) {
} }
serial_val val = stringify_value(v, "json", 1, o); serial_val val = stringify_value(v, "json", 1, o);
set_attributes.emplace(k->value.string.string, val); set_attributes.emplace(k->string(), val);
} }
return; return;
@@ -2941,21 +2941,21 @@ void parse_json_source(const char *arg, struct source &src) {
exit(EXIT_JSON); exit(EXIT_JSON);
} }
src.file = fname->value.string.string; src.file = fname->string();
json_object_ptr layer = json_hash_get(o, "layer"); json_object_ptr layer = json_hash_get(o, "layer");
if (layer != nullptr && layer->type == JSON_STRING) { if (layer != nullptr && layer->type == JSON_STRING) {
src.layer = layer->value.string.string; src.layer = layer->string();
} }
json_object_ptr description = json_hash_get(o, "description"); json_object_ptr description = json_hash_get(o, "description");
if (description != nullptr && description->type == JSON_STRING) { if (description != nullptr && description->type == JSON_STRING) {
src.description = description->value.string.string; src.description = description->string();
} }
json_object_ptr format = json_hash_get(o, "format"); json_object_ptr format = json_hash_get(o, "format");
if (format != nullptr && format->type == JSON_STRING) { if (format != nullptr && format->type == JSON_STRING) {
src.format = format->value.string.string; src.format = format->string();
} }
} }
plugin.cpp
+14 -14
View File
@@ -168,7 +168,7 @@ serial_feature parse_feature(json_pull_ptr jp, int z, unsigned x, unsigned y, st
if (type == nullptr || type->type != JSON_STRING) { if (type == nullptr || type->type != JSON_STRING) {
continue; continue;
} }
if (type->value.string.string != "Feature") { if (type->string() != "Feature") {
continue; continue;
} }
@@ -208,12 +208,12 @@ serial_feature parse_feature(json_pull_ptr jp, int z, unsigned x, unsigned y, st
int t; int t;
for (t = 0; t < GEOM_TYPES; t++) { for (t = 0; t < GEOM_TYPES; t++) {
if (geometry_type->value.string.string == geometry_names[t]) { if (geometry_type->string() == geometry_names[t]) {
break; break;
} }
} }
if (t >= GEOM_TYPES) { if (t >= GEOM_TYPES) {
fprintf(stderr, "Filter output:%d: Can't handle geometry type %s: ", jp->line, geometry_type->value.string.string.c_str()); fprintf(stderr, "Filter output:%d: Can't handle geometry type %s: ", jp->line, geometry_type->string().c_str());
json_context(j); json_context(j);
exit(EXIT_JSON); exit(EXIT_JSON);
} }
@@ -252,22 +252,22 @@ serial_feature parse_feature(json_pull_ptr jp, int z, unsigned x, unsigned y, st
if (tippecanoe != nullptr) { if (tippecanoe != nullptr) {
json_object_ptr layer = json_hash_get(tippecanoe, "layer"); json_object_ptr layer = json_hash_get(tippecanoe, "layer");
if (layer != nullptr && layer->type == JSON_STRING) { if (layer != nullptr && layer->type == JSON_STRING) {
layername = layer->value.string.string; layername = layer->string();
} }
json_object_ptr index = json_hash_get(tippecanoe, "index"); json_object_ptr index = json_hash_get(tippecanoe, "index");
if (index != nullptr && index->type == JSON_NUMBER) { if (index != nullptr && index->type == JSON_NUMBER) {
sf.index = index->value.number.number; sf.index = index->number();
} }
json_object_ptr sequence = json_hash_get(tippecanoe, "sequence"); json_object_ptr sequence = json_hash_get(tippecanoe, "sequence");
if (sequence != nullptr && sequence->type == JSON_NUMBER) { if (sequence != nullptr && sequence->type == JSON_NUMBER) {
sf.seq = sequence->value.number.number; sf.seq = sequence->number();
} }
json_object_ptr extent = json_hash_get(tippecanoe, "extent"); json_object_ptr extent = json_hash_get(tippecanoe, "extent");
if (extent != nullptr && extent->type == JSON_NUMBER) { if (extent != nullptr && extent->type == JSON_NUMBER) {
sf.extent = extent->value.number.number; sf.extent = extent->number();
} }
json_object_ptr dropped = json_hash_get(tippecanoe, "dropped"); json_object_ptr dropped = json_hash_get(tippecanoe, "dropped");
@@ -297,9 +297,9 @@ serial_feature parse_feature(json_pull_ptr jp, int z, unsigned x, unsigned y, st
json_object_ptr id = json_hash_get(j, "id"); json_object_ptr id = json_hash_get(j, "id");
if (id != nullptr && id->type == JSON_NUMBER) { if (id != nullptr && id->type == JSON_NUMBER) {
sf.id = id->value.number.number; sf.id = id->number();
if (id->value.number.large_unsigned > 0) { if (id->large_unsigned() > 0) {
sf.id = id->value.number.large_unsigned; sf.id = id->large_unsigned();
} }
sf.has_id = true; sf.has_id = true;
} }
@@ -343,18 +343,18 @@ serial_feature parse_feature(json_pull_ptr jp, int z, unsigned x, unsigned y, st
} }
} }
for (size_t i = 0; i < properties->value.object.keys.size(); i++) { for (size_t i = 0; i < properties->keys().size(); i++) {
serial_val v = stringify_value(properties->value.object.values[i], "Filter output", jp->line, j); serial_val v = stringify_value(properties->values()[i], "Filter output", jp->line, j);
// Nulls can be excluded here because the expression evaluation filter // Nulls can be excluded here because the expression evaluation filter
// would have already run before prefiltering // would have already run before prefiltering
if (v.type != mvt_null) { if (v.type != mvt_null) {
sf.full_keys.push_back(key_pool.pool(properties->value.object.keys[i]->value.string.string)); sf.full_keys.push_back(key_pool.pool(properties->keys()[i]->string()));
sf.full_values.push_back(v); sf.full_values.push_back(v);
if (!postfilter) { if (!postfilter) {
add_to_tilestats(ts->second.tilestats, properties->value.object.keys[i]->value.string.string, v); add_to_tilestats(ts->second.tilestats, properties->keys()[i]->string(), v);
} }
} }
} }
pmtiles_file.cpp
+12 -12
View File
@@ -415,37 +415,37 @@ sqlite3 *pmtilesmeta2tmp(const char *fname, const char *pmtiles_map) {
state.nospace = true; state.nospace = true;
state.json_write_hash(); state.json_write_hash();
for (size_t i = 0; i < o->value.object.keys.size(); i++) { for (size_t i = 0; i < o->keys().size(); i++) {
const std::string &key = o->value.object.keys[i]->value.string.string; const std::string &key = o->keys()[i]->string();
if (key == "vector_layers" && o->value.object.values[i]->type == JSON_ARRAY) { if (key == "vector_layers" && o->values()[i]->type == JSON_ARRAY) {
has_json = true; has_json = true;
state.nospace = true; state.nospace = true;
state.json_write_string("vector_layers"); state.json_write_string("vector_layers");
state.nospace = true; state.nospace = true;
state.json_write_json(json_stringify(o->value.object.values[i])); state.json_write_json(json_stringify(o->values()[i]));
} else if (key == "tilestats" && o->value.object.values[i]->type == JSON_HASH) { } else if (key == "tilestats" && o->values()[i]->type == JSON_HASH) {
has_json = true; has_json = true;
state.nospace = true; state.nospace = true;
state.json_write_string("tilestats"); state.json_write_string("tilestats");
state.nospace = true; state.nospace = true;
state.json_write_json(json_stringify(o->value.object.values[i])); state.json_write_json(json_stringify(o->values()[i]));
} else if (key == "strategies" && o->value.object.values[i]->type == JSON_ARRAY) { } else if (key == "strategies" && o->values()[i]->type == JSON_ARRAY) {
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('strategies', %Q);", json_stringify(o->value.object.values[i]).c_str()); sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('strategies', %Q);", json_stringify(o->values()[i]).c_str());
if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) { if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err); fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err);
} }
sqlite3_free(sql); sqlite3_free(sql);
} else if (key == "tippecanoe_decisions" && o->value.object.values[i]->type == JSON_HASH) { } else if (key == "tippecanoe_decisions" && o->values()[i]->type == JSON_HASH) {
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('tippecanoe_decisions', %Q);", json_stringify(o->value.object.values[i]).c_str()); sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES ('tippecanoe_decisions', %Q);", json_stringify(o->values()[i]).c_str());
if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) { if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err); fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err);
} }
sqlite3_free(sql); sqlite3_free(sql);
} else if (o->value.object.keys[i]->type != JSON_STRING || o->value.object.values[i]->type != JSON_STRING) { } else if (o->keys()[i]->type != JSON_STRING || o->values()[i]->type != JSON_STRING) {
fprintf(stderr, "%s\n", key.c_str()); fprintf(stderr, "%s\n", key.c_str());
fprintf(stderr, "%s: non-string in metadata\n", fname); fprintf(stderr, "%s: non-string in metadata\n", fname);
} else { } else {
sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES (%Q, %Q);", key.c_str(), o->value.object.values[i]->value.string.string.c_str()); sql = sqlite3_mprintf("INSERT INTO metadata (name, value) VALUES (%Q, %Q);", key.c_str(), o->values()[i]->string().c_str());
if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) { if (sqlite3_exec(db, sql, NULL, NULL, &err) != SQLITE_OK) {
fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err); fprintf(stderr, "set %s in metadata: %s\n", key.c_str(), err);
} }
read_json.cpp
+22 -22
View File
@@ -63,7 +63,7 @@ void parse_coordinates(int t, json_object_ptr j, drawvec &out, int op, const cha
int within = geometry_within[t]; int within = geometry_within[t];
if (within >= 0) { if (within >= 0) {
size_t i; size_t i;
for (i = 0; i < j->value.array.array.size(); i++) { for (i = 0; i < j->array().size(); i++) {
if (within == GEOM_POINT) { if (within == GEOM_POINT) {
if (i == 0 || mb_geometry[t] == VT_POINT) { if (i == 0 || mb_geometry[t] == VT_POINT) {
op = VT_MOVETO; op = VT_MOVETO;
@@ -72,16 +72,16 @@ void parse_coordinates(int t, json_object_ptr j, drawvec &out, int op, const cha
} }
} }
parse_coordinates(within, j->value.array.array[i], out, op, fname, line, feature); parse_coordinates(within, j->array()[i], out, op, fname, line, feature);
} }
} else { } else {
if (j->value.array.array.size() >= 2 && j->value.array.array[0]->type == JSON_NUMBER && j->value.array.array[1]->type == JSON_NUMBER) { if (j->array().size() >= 2 && j->array()[0]->type == JSON_NUMBER && j->array()[1]->type == JSON_NUMBER) {
long long x, y; long long x, y;
double lon = j->value.array.array[0]->value.number.number; double lon = j->array()[0]->number();
double lat = j->value.array.array[1]->value.number.number; double lat = j->array()[1]->number();
projection->project(lon, lat, 32, &x, &y); projection->project(lon, lat, 32, &x, &y);
if (j->value.array.array.size() > 2) { if (j->array().size() > 2) {
static int warned = 0; static int warned = 0;
if (!warned) { if (!warned) {
@@ -129,7 +129,7 @@ serial_val stringify_value(json_object_ptr value, const char *reading, int line,
if (vt == JSON_STRING) { if (vt == JSON_STRING) {
sv.type = mvt_string; sv.type = mvt_string;
sv.s = value->value.string.string; sv.s = value->string();
std::string err = check_utf8(sv.s); std::string err = check_utf8(sv.s);
if (err.size() > 0) { if (err.size() > 0) {
@@ -140,12 +140,12 @@ serial_val stringify_value(json_object_ptr value, const char *reading, int line,
} else if (vt == JSON_NUMBER) { } else if (vt == JSON_NUMBER) {
sv.type = mvt_double; sv.type = mvt_double;
if (value->value.number.large_unsigned != 0) { if (value->large_unsigned() != 0) {
sv.s = std::to_string(value->value.number.large_unsigned); sv.s = std::to_string(value->large_unsigned());
} else if (value->value.number.large_signed != 0) { } else if (value->large_signed() != 0) {
sv.s = std::to_string(value->value.number.large_signed); sv.s = std::to_string(value->large_signed());
} else { } else {
sv.s = milo::dtoa_milo(value->value.number.number); sv.s = milo::dtoa_milo(value->number());
} }
} else if (vt == JSON_TRUE) { } else if (vt == JSON_TRUE) {
sv.type = mvt_bool; sv.type = mvt_bool;
@@ -200,12 +200,12 @@ std::pair<int, drawvec> parse_geometry(json_object_ptr geometry, json_pull_ptr j
int t; int t;
for (t = 0; t < GEOM_TYPES; t++) { for (t = 0; t < GEOM_TYPES; t++) {
if (geometry_type->value.string.string == geometry_names[t]) { if (geometry_type->string() == geometry_names[t]) {
break; break;
} }
} }
if (t >= GEOM_TYPES) { if (t >= GEOM_TYPES) {
fprintf(stderr, "Filter output:%d: Can't handle geometry type %s: ", jp->line, geometry_type->value.string.string.c_str()); fprintf(stderr, "Filter output:%d: Can't handle geometry type %s: ", jp->line, geometry_type->string().c_str());
json_context(j); json_context(j);
exit(EXIT_JSON); exit(EXIT_JSON);
} }
@@ -325,7 +325,7 @@ std::vector<mvt_layer> parse_layers(FILE *fp, int z, unsigned x, unsigned y, int
if (type == nullptr || type->type != JSON_STRING) { if (type == nullptr || type->type != JSON_STRING) {
continue; continue;
} }
if (type->value.string.string != "Feature") { if (type->string() != "Feature") {
continue; continue;
} }
@@ -342,7 +342,7 @@ std::vector<mvt_layer> parse_layers(FILE *fp, int z, unsigned x, unsigned y, int
if (tippecanoe != nullptr) { if (tippecanoe != nullptr) {
layer = json_hash_get(tippecanoe, "layer"); layer = json_hash_get(tippecanoe, "layer");
if (layer != nullptr && layer->type == JSON_STRING) { if (layer != nullptr && layer->type == JSON_STRING) {
layername = layer->value.string.string; layername = layer->string();
} }
} }
@@ -375,22 +375,22 @@ std::vector<mvt_layer> parse_layers(FILE *fp, int z, unsigned x, unsigned y, int
json_object_ptr id = json_hash_get(j, "id"); json_object_ptr id = json_hash_get(j, "id");
if (id != nullptr && id->type == JSON_NUMBER) { if (id != nullptr && id->type == JSON_NUMBER) {
feature.id = id->value.number.number; feature.id = id->number();
if (id->value.number.large_unsigned > 0) { if (id->large_unsigned() > 0) {
feature.id = id->value.number.large_unsigned; feature.id = id->large_unsigned();
} }
feature.has_id = true; feature.has_id = true;
} }
for (size_t i = 0; i < properties->value.object.keys.size(); i++) { for (size_t i = 0; i < properties->keys().size(); i++) {
serial_val sv = stringify_value(properties->value.object.values[i], "Filter output", jp->line, j); serial_val sv = stringify_value(properties->values()[i], "Filter output", jp->line, j);
// Nulls can be excluded here because this is the postfilter // Nulls can be excluded here because this is the postfilter
// and it is nearly time to create the vector representation // and it is nearly time to create the vector representation
if (sv.type != mvt_null) { if (sv.type != mvt_null) {
mvt_value v = stringified_to_mvt_value(sv.type, sv.s.c_str(), tile_stringpool); mvt_value v = stringified_to_mvt_value(sv.type, sv.s.c_str(), tile_stringpool);
l->second.tag(feature, properties->value.object.keys[i]->value.string.string, v); l->second.tag(feature, properties->keys()[i]->string(), v);
} }
} }
tile-join.cpp
+26 -26
View File
@@ -969,12 +969,12 @@ void handle_strategies(const unsigned char *s, std::vector<strategy> *st) {
json_object_ptr o = json_read_tree(jp); json_object_ptr o = json_read_tree(jp);
if (o != nullptr && o->type == JSON_ARRAY) { if (o != nullptr && o->type == JSON_ARRAY) {
for (size_t i = 0; i < o->value.array.array.size(); i++) { for (size_t i = 0; i < o->array().size(); i++) {
json_object_ptr h = o->value.array.array[i]; json_object_ptr h = o->array()[i];
if (h->type == JSON_HASH) { if (h->type == JSON_HASH) {
for (size_t j = 0; j < h->value.object.keys.size(); j++) { for (size_t j = 0; j < h->keys().size(); j++) {
json_object_ptr k = h->value.object.keys[j]; json_object_ptr k = h->keys()[j];
json_object_ptr v = h->value.object.values[j]; json_object_ptr v = h->values()[j];
if (k->type != JSON_STRING) { if (k->type != JSON_STRING) {
fprintf(stderr, "Key %zu of %zu is not a string: %s\n", j, i, s); fprintf(stderr, "Key %zu of %zu is not a string: %s\n", j, i, s);
@@ -985,25 +985,25 @@ void handle_strategies(const unsigned char *s, std::vector<strategy> *st) {
st->resize(i + 1); st->resize(i + 1);
} }
const std::string &key = k->value.string.string; const std::string &key = k->string();
if (key == "dropped_by_rate") { if (key == "dropped_by_rate") {
(*st)[i].dropped_by_rate += v->value.number.number; (*st)[i].dropped_by_rate += v->number();
} else if (key == "dropped_by_gamma") { } else if (key == "dropped_by_gamma") {
(*st)[i].dropped_by_gamma += v->value.number.number; (*st)[i].dropped_by_gamma += v->number();
} else if (key == "dropped_as_needed") { } else if (key == "dropped_as_needed") {
(*st)[i].dropped_as_needed += v->value.number.number; (*st)[i].dropped_as_needed += v->number();
} else if (key == "coalesced_as_needed") { } else if (key == "coalesced_as_needed") {
(*st)[i].coalesced_as_needed += v->value.number.number; (*st)[i].coalesced_as_needed += v->number();
} else if (key == "truncated_zooms") { } else if (key == "truncated_zooms") {
(*st)[i].truncated_zooms += v->value.number.number; (*st)[i].truncated_zooms += v->number();
} else if (key == "detail_reduced") { } else if (key == "detail_reduced") {
(*st)[i].detail_reduced += v->value.number.number; (*st)[i].detail_reduced += v->number();
} else if (key == "tiny_polygons") { } else if (key == "tiny_polygons") {
(*st)[i].tiny_polygons += v->value.number.number; (*st)[i].tiny_polygons += v->number();
} else if (key == "tile_size_desired") { } else if (key == "tile_size_desired") {
(*st)[i].tile_size += v->value.number.number; (*st)[i].tile_size += v->number();
} else if (key == "feature_count_desired") { } else if (key == "feature_count_desired") {
(*st)[i].feature_count += v->value.number.number; (*st)[i].feature_count += v->number();
} }
} }
} }
@@ -1016,14 +1016,14 @@ void handle_strategies(const unsigned char *s, std::vector<strategy> *st) {
void handle_vector_layers(json_object_ptr vector_layers, std::map<std::string, layermap_entry> &layermap, std::map<std::string, std::string> &attribute_descriptions) { void handle_vector_layers(json_object_ptr vector_layers, std::map<std::string, layermap_entry> &layermap, std::map<std::string, std::string> &attribute_descriptions) {
if (vector_layers != nullptr && vector_layers->type == JSON_ARRAY) { if (vector_layers != nullptr && vector_layers->type == JSON_ARRAY) {
for (size_t i = 0; i < vector_layers->value.array.array.size(); i++) { for (size_t i = 0; i < vector_layers->array().size(); i++) {
if (vector_layers->value.array.array[i]->type == JSON_HASH) { if (vector_layers->array()[i]->type == JSON_HASH) {
json_object_ptr id = json_hash_get(vector_layers->value.array.array[i], "id"); json_object_ptr id = json_hash_get(vector_layers->array()[i], "id");
json_object_ptr desc = json_hash_get(vector_layers->value.array.array[i], "description"); json_object_ptr desc = json_hash_get(vector_layers->array()[i], "description");
if (id != nullptr && desc != nullptr && id->type == JSON_STRING && desc->type == JSON_STRING) { if (id != nullptr && desc != nullptr && id->type == JSON_STRING && desc->type == JSON_STRING) {
const std::string &sid = id->value.string.string; const std::string &sid = id->string();
const std::string &sdesc = desc->value.string.string; const std::string &sdesc = desc->string();
if (sdesc.size() != 0) { if (sdesc.size() != 0) {
auto f = layermap.find(sid); auto f = layermap.find(sid);
@@ -1033,17 +1033,17 @@ void handle_vector_layers(json_object_ptr vector_layers, std::map<std::string, l
} }
} }
json_object_ptr fields = json_hash_get(vector_layers->value.array.array[i], "fields"); json_object_ptr fields = json_hash_get(vector_layers->array()[i], "fields");
if (fields != nullptr && fields->type == JSON_HASH) { if (fields != nullptr && fields->type == JSON_HASH) {
for (size_t j = 0; j < fields->value.object.keys.size(); j++) { for (size_t j = 0; j < fields->keys().size(); j++) {
if (fields->value.object.keys[j]->type == JSON_STRING && fields->value.object.values[j]->type) { if (fields->keys()[j]->type == JSON_STRING && fields->values()[j]->type) {
const std::string &desc2 = fields->value.object.values[j]->value.string.string; const std::string &desc2 = fields->values()[j]->string();
if (desc2 != "Number" && if (desc2 != "Number" &&
desc2 != "String" && desc2 != "String" &&
desc2 != "Boolean" && desc2 != "Boolean" &&
desc2 != "Mixed") { desc2 != "Mixed") {
attribute_descriptions.insert(std::pair<std::string, std::string>(fields->value.object.keys[j]->value.string.string, desc2)); attribute_descriptions.insert(std::pair<std::string, std::string>(fields->keys()[j]->string(), desc2));
} }
} }
} }