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(); }