void Style::setJSON(const std::string& json, const std::string&) {
sources.clear();
layers.clear();
rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
doc.Parse<0>((const char *const)json.c_str());
if (doc.HasParseError()) {
Log::Error(Event::ParseStyle, "Error parsing style JSON at %i: %s", doc.GetErrorOffset(), rapidjson::GetParseError_En(doc.GetParseError()));
return;
}
StyleParser parser;
parser.parse(doc);
for (auto& source : parser.sources) {
addSource(std::move(source));
}
for (auto& layer : parser.layers) {
addLayer(std::move(layer));
}
glyphStore->setURL(parser.glyphURL);
spriteStore->setURL(parser.spriteURL);
loaded = true;
}
void OfflineDownload::activateDownload() {
status = OfflineRegionStatus();
status.downloadState = OfflineRegionDownloadState::Active;
requiredSourceURLs.clear();
ensureResource(Resource::style(definition.styleURL), [&] (Response styleResponse) {
status.requiredResourceCountIsPrecise = true;
StyleParser parser;
parser.parse(*styleResponse.data);
for (const auto& source : parser.sources) {
SourceType type = source->type;
uint16_t tileSize = source->tileSize;
std::string url = source->url;
switch (type) {
case SourceType::Vector:
case SourceType::Raster:
if (source->getInfo()) {
ensureTiles(type, tileSize, *source->getInfo());
} else {
status.requiredResourceCountIsPrecise = false;
requiredSourceURLs.insert(url);
ensureResource(Resource::source(url), [=] (Response sourceResponse) {
ensureTiles(type, tileSize, *StyleParser::parseTileJSON(*sourceResponse.data, url, type, tileSize));
requiredSourceURLs.erase(url);
if (requiredSourceURLs.empty()) {
status.requiredResourceCountIsPrecise = true;
}
});
}
break;
case SourceType::GeoJSON:
if (!source->url.empty()) {
ensureResource(Resource::source(source->url));
}
break;
case SourceType::Video:
case SourceType::Annotations:
break;
}
}
for (const auto& resource : spriteResources(parser)) {
ensureResource(resource);
}
for (const auto& resource : glyphResources(parser)) {
ensureResource(resource);
}
});
}
OfflineRegionStatus OfflineDownload::getStatus() const {
if (status.downloadState == OfflineRegionDownloadState::Active) {
return status;
}
OfflineRegionStatus result = offlineDatabase.getRegionCompletedStatus(id);
result.requiredResourceCount++;
optional<Response> styleResponse = offlineDatabase.get(Resource::style(definition.styleURL));
if (!styleResponse) {
return result;
}
StyleParser parser;
parser.parse(*styleResponse->data);
result.requiredResourceCountIsPrecise = true;
for (const auto& source : parser.sources) {
switch (source->type) {
case SourceType::Vector:
case SourceType::Raster:
if (source->getInfo()) {
result.requiredResourceCount += tileResources(source->type, source->tileSize, *source->getInfo()).size();
} else {
result.requiredResourceCount += 1;
optional<Response> sourceResponse = offlineDatabase.get(Resource::source(source->url));
if (sourceResponse) {
result.requiredResourceCount += tileResources(source->type, source->tileSize,
*StyleParser::parseTileJSON(*sourceResponse->data, source->url, source->type, source->tileSize)).size();
} else {
result.requiredResourceCountIsPrecise = false;
}
}
break;
case SourceType::GeoJSON:
if (!source->url.empty()) {
result.requiredResourceCount += 1;
}
break;
case SourceType::Video:
case SourceType::Annotations:
break;
}
}
result.requiredResourceCount += spriteResources(parser).size();
result.requiredResourceCount += glyphResources(parser).size();
return result;
}
scoped_refptr<StyleSheet> StyleSheet::LoadFromFile(const std::wstring& path)
{
std::string contents;
if (!ReadFileToString(path, &contents))
return NULL;
StyleParser parser;
scoped_refptr<StyleSheet> sheet(new StyleSheet);
parser.SetStyleSheet(sheet.get());
if (!parser.ParseSheet(contents, 0))
return NULL;
return sheet;
}
TEST_P(StyleParserTest, ParseStyle) {
const std::string base = std::string("test/fixtures/style_parser/") + GetParam();
rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> infoDoc;
infoDoc.Parse<0>(util::read_file(base + ".info.json").c_str());
ASSERT_FALSE(infoDoc.HasParseError());
ASSERT_TRUE(infoDoc.IsObject());
rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> styleDoc;
styleDoc.Parse<0>(util::read_file(base + ".style.json").c_str());
ASSERT_FALSE(styleDoc.HasParseError());
ASSERT_TRUE(styleDoc.IsObject());
FixtureLogObserver* observer = new FixtureLogObserver();
Log::setObserver(std::unique_ptr<Log::Observer>(observer));
StyleParser parser;
parser.parse(styleDoc);
for (auto it = infoDoc.MemberBegin(), end = infoDoc.MemberEnd(); it != end; it++) {
const std::string name { it->name.GetString(), it->name.GetStringLength() };
const JSValue &value = it->value;
ASSERT_EQ(true, value.IsObject());
if (value.HasMember("log")) {
const JSValue &js_log = value["log"];
ASSERT_EQ(true, js_log.IsArray());
for (rapidjson::SizeType i = 0; i < js_log.Size(); i++) {
const JSValue &js_entry = js_log[i];
ASSERT_EQ(true, js_entry.IsArray());
const uint32_t count = js_entry[rapidjson::SizeType(0)].GetUint();
const FixtureLogObserver::LogMessage message {
EventSeverityClass(js_entry[rapidjson::SizeType(1)].GetString()),
EventClass(js_entry[rapidjson::SizeType(2)].GetString()),
int64_t(-1),
js_entry[rapidjson::SizeType(3)].GetString()
};
EXPECT_EQ(count, observer->count(message)) << "Message: " << message << std::endl;
}
}
const auto &unchecked = observer->unchecked();
if (unchecked.size()) {
std::cerr << "Unchecked Log Messages (" << base << "/" << name << "): " << std::endl << unchecked;
}
ASSERT_EQ(0ul, unchecked.size());
}
}
void Style::loadJSON(const uint8_t *const data) {
uv::writelock lock(mtx);
rapidjson::Document doc;
doc.Parse<0>((const char *const)data);
if (doc.HasParseError()) {
throw error::style_parse(doc.GetErrorOffset(), doc.GetParseError());
}
StyleParser parser;
parser.parse(const_cast<const rapidjson::Document &>(doc));
layers = parser.getLayers();
sprite_url = parser.getSprite();
glyph_url = parser.getGlyphURL();
updateClasses();
}
void Style::setJSON(const std::string& json, const std::string&) {
sources.clear();
layers.clear();
StyleParser parser;
parser.parse(json);
for (auto& source : parser.sources) {
addSource(std::move(source));
}
for (auto& layer : parser.layers) {
addLayer(std::move(layer));
}
glyphStore->setURL(parser.glyphURL);
spriteStore->load(parser.spriteURL, fileSource);
loaded = true;
}
Style::Style(const std::string& data, const std::string&,
uv_loop_t* loop, Environment& env)
: glyphStore(std::make_unique<GlyphStore>(loop, env)),
glyphAtlas(std::make_unique<GlyphAtlas>(1024, 1024)),
spriteAtlas(std::make_unique<SpriteAtlas>(512, 512)),
lineAtlas(std::make_unique<LineAtlas>(512, 512)),
mtx(std::make_unique<uv::rwlock>()),
workers(4) {
rapidjson::Document doc;
doc.Parse<0>((const char *const)data.c_str());
if (doc.HasParseError()) {
Log::Error(Event::ParseStyle, "Error parsing style JSON at %i: %s", doc.GetErrorOffset(), doc.GetParseError());
return;
}
StyleParser parser;
parser.parse(doc);
sources = parser.getSources();
layers = parser.getLayers();
spriteURL = parser.getSprite();
glyphStore->setURL(parser.getGlyphURL());
for (const auto& source : sources) {
source->setObserver(this);
source->load();
}
glyphStore->setObserver(this);
}
std::vector<Resource> OfflineDownload::glyphResources(const StyleParser& parser) const {
std::vector<Resource> result;
if (!parser.glyphURL.empty()) {
for (const auto& fontStack : parser.fontStacks()) {
for (uint32_t i = 0; i < 256; i++) {
result.push_back(Resource::glyphs(parser.glyphURL, fontStack, getGlyphRange(i * 256)));
}
}
}
return result;
}
void Style::loadJSON(const uint8_t *const data) {
uv::writelock lock(mtx);
rapidjson::Document doc;
doc.Parse<0>((const char *const)data);
if (doc.HasParseError()) {
Log::Error(Event::ParseStyle, "Error parsing style JSON at %i: %s", doc.GetErrorOffset(), doc.GetParseError());
return;
}
StyleParser parser;
parser.parse(doc);
sources = parser.getSources();
layers = parser.getLayers();
sprite_url = parser.getSprite();
glyph_url = parser.getGlyphURL();
}
