bool JSONReader::parseAll(const std::string& text, IdType& nextId, std::string& filepath, std::string& checksum,
std::vector<std::shared_ptr<MetadataStream::VideoSegment>>& segments,
std::vector<std::shared_ptr<MetadataSchema>>& schemas,
std::vector<std::shared_ptr<MetadataInternal>>& metadata)
{
if(text.empty())
{
VMF_LOG_ERROR("Empty input JSON string");
return false;
}
schemas.clear();
metadata.clear();
JSONNode root;
try
{
root = libjson::parse(text);
}
catch(...)
{
VMF_LOG_ERROR("Can't get JSON root");
return false;
}
if(root.size() != 1)
{
VMF_LOG_ERROR("More than one JSON root");
return false;
}
JSONNode localRootNode = root[0];
if( localRootNode.name() == TAG_VMF )
{
auto nextIdIter = localRootNode.find(ATTR_VMF_NEXTID);
if(nextIdIter != localRootNode.end() )
nextId = nextIdIter->as_int();
auto filepathIter = localRootNode.find(ATTR_VMF_FILEPATH);
if(filepathIter != localRootNode.end() )
filepath = filepathIter->as_string();
auto checksumIter = localRootNode.find(ATTR_VMF_CHECKSUM);
if(checksumIter != localRootNode.end() )
checksum = checksumIter->as_string();
if(!parseVideoSegments(text, segments))
return false;
if(!parseSchemas(text, schemas))
return false;
if(!parseMetadata(text, schemas, metadata))
return false;
}
else
{
VMF_LOG_ERROR("Root JSON element isn't 'vmf'");
return false;
}
return true;
}
std::vector<std::string> MDAL::LoaderGdal::parseDatasetNames( const std::string &fileName )
{
std::string gdal_name = GDALFileName( fileName );
std::vector<std::string> ret;
GDALDatasetH hDataset = GDALOpen( gdal_name.data(), GA_ReadOnly );
if ( hDataset == nullptr ) throw MDAL_Status::Err_UnknownFormat;
metadata_hash metadata = parseMetadata( hDataset, "SUBDATASETS" );
for ( auto iter = metadata.begin(); iter != metadata.end(); ++iter )
{
const std::string &key = iter->first;
if ( MDAL::endsWith( key, "_name" ) )
{
// skip subdataset desc keys, just register names
ret.push_back( iter->second );
}
}
// there are no GDAL subdatasets
if ( ret.empty() )
{
ret.push_back( gdal_name );
}
GDALClose( hDataset );
return ret;
}
shared_ptr<FDSObjectMetadata> GalaxyFDSClient::getObjectMetadata(const string&
bucketName, const string& objectName) {
vector<string> subResources;
subResources.push_back(SubResource::METADATA);
string uri = formatUri(_pConfig->getBaseUri(), bucketName + "/" + objectName,
subResources);
URI pocoUri(uri);
shared_ptr<HTTPClientSession> pSession(_pSessionFacotry->createClientSession(
pocoUri));
pSession->setHost(pocoUri.getHost());
pSession->setPort(pocoUri.getPort());
HTTPRequest request(HTTPRequest::HTTP_GET, uri, HTTPMessage::HTTP_1_1);
prepareRequestHeaders(uri, HTTPRequest::HTTP_GET, "", _emptyStream,
*_pEmptyMetadata, request);
HTTPResponse response;
pSession->sendRequest(request);
istream& rs = pSession->receiveResponse(response);
if (response.getStatus() != HTTPResponse::HTTP_OK) {
stringstream msg;
msg << "Get object metadata failed, status=" << response.getStatus()
<< ", reason=";
StreamCopier::copyStream(rs, msg);
throw GalaxyFDSClientException(response.getStatus(), msg.str());
}
return parseMetadata(response);
}
void SM_QDropbox::parseBlockingMetadata(QString response)
{
clearError();
parseMetadata(response);
stopEventLoop();
return;
}
void StatTool::parseGroup(xercesc::DOMElement * parentNode,
crispr::xml::base& xmlParser)
{
StatManager * sm = new StatManager();
ST_StatsVec.push_back(sm);
char * c_cons = tc(parentNode->getAttribute(xmlParser.attr_Drseq()));
std::string concensusRepeat =c_cons;
sm->setConcensus(concensusRepeat);
xr(&c_cons);
char * c_gid = tc(parentNode->getAttribute(xmlParser.attr_Gid()));
std::string gid = c_gid;
xr(&c_gid);
sm->setGid(gid);
for (xercesc::DOMElement * currentElement = parentNode->getFirstElementChild();
currentElement != NULL;
currentElement = currentElement->getNextElementSibling()) {
if (xercesc::XMLString::equals(currentElement->getTagName(), xmlParser.tag_Data())) {
parseData(currentElement, xmlParser, sm);
} else if (xercesc::XMLString::equals(currentElement->getTagName(), xmlParser.tag_Metadata())) {
parseMetadata(currentElement, xmlParser, sm);
}
}
}
Word parseWord(QString word) {
Word ret;
if(word.startsWith("<")) { // lines with words start with this.
QStringList split = word.split("#");
for(int i = 0; i < split.length(); i++) {
QString part = split[i];
switch(i) {
case 0: // first part, contains some magic and the word
parseMetadata(part, &ret); // parses the meta data between <>
part = part.remove(0, part.indexOf('>') + 1); // take of the stuff between <>
// TODO: find out what it is
if(part.contains('.')) {
// end of sentence, put the linkedWords right here.
}
ret.setWord(part.trimmed());
break;
case 1: // second part, contains the meaning
ret.setMeaning(part.trimmed());
break;
case 2: // third part, contains the grammar
ret.setGrammar(part.trimmed());
break;
case 3: // fourth part, contains the word to look up in the dictionary
ret.setDictionary(part.trimmed());
break;
}
}
}
return ret;
}
bool OsmAnd::MapStyle_P::parseMetadata()
{
if(owner->isEmbedded)
{
QXmlStreamReader data(EmbeddedResources::decompressResource(owner->resourcePath));
return parseMetadata(data);
}
else
{
QFile styleFile(owner->resourcePath);
if(!styleFile.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
QXmlStreamReader data(&styleFile);
bool ok = parseMetadata(data);
styleFile.close();
return ok;
}
return false;
}
void parseSource(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
{
ezxml_t cur_node;
char *name = NULL, *type = NULL;
mapcache_source *source;
name = (char*)ezxml_attr(node,"name");
type = (char*)ezxml_attr(node,"type");
if(!name || !strlen(name)) {
ctx->set_error(ctx, 400, "mandatory attribute \"name\" not found in <source>");
return;
} else {
name = apr_pstrdup(ctx->pool, name);
/* check we don't already have a source defined with this name */
if(mapcache_configuration_get_source(config, name)) {
ctx->set_error(ctx, 400, "duplicate source with name \"%s\"",name);
return;
}
}
if(!type || !strlen(type)) {
ctx->set_error(ctx, 400, "mandatory attribute \"type\" not found in <source>");
return;
}
source = NULL;
if(!strcmp(type,"wms")) {
source = mapcache_source_wms_create(ctx);
} else if(!strcmp(type,"mapserver")) {
source = mapcache_source_mapserver_create(ctx);
} else if(!strcmp(type,"gdal")) {
source = mapcache_source_gdal_create(ctx);
} else if(!strcmp(type,"dummy")) {
source = mapcache_source_dummy_create(ctx);
} else {
ctx->set_error(ctx, 400, "unknown source type %s for source \"%s\"", type, name);
return;
}
if(source == NULL) {
ctx->set_error(ctx, 400, "failed to parse source \"%s\"", name);
return;
}
source->name = name;
if ((cur_node = ezxml_child(node,"metadata")) != NULL) {
parseMetadata(ctx, cur_node, source->metadata);
GC_CHECK_ERROR(ctx);
}
source->configuration_parse_xml(ctx,node,source);
GC_CHECK_ERROR(ctx);
source->configuration_check(ctx,config,source);
GC_CHECK_ERROR(ctx);
mapcache_configuration_add_source(config,source,name);
}
void Regola::insertCompleteMetadata(QTreeWidget *tree)
{
insertMetadata(tree);
MetadataInfo info;
parseMetadata(&info);
//---
appendAMetadatum(tree, &info.project, MetadataInfo::ProjectMetaType);
appendAMetadatum(tree, &info.copyright, MetadataInfo::CopyrightMetaType);
appendAMetadatum(tree, &info.version, MetadataInfo::VersionMetaType);
appendAMetadatum(tree, &info.domain, MetadataInfo::DomainMetaType);
appendAMetadatum(tree, &info.name, MetadataInfo::NameMetaType);
//---
}
void Playlist::onRefreshFinished() {
auto reply = qobject_cast<QNetworkReply*>(sender());
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
qWarning() << Q_FUNC_INFO << "Failed to refresh metadata";
return;
}
QFile output(_cachePath.filePath("metadata"));
output.open(QIODevice::WriteOnly);
output.write(reply->readAll());
output.close();
parseMetadata();
}
void AvatarAsset::readBlocks()
{
DWORD prevAddress = header.blockStartAddress, prevDataLen = 0;
io->setPosition(0, ios_base::end);
DWORD fileSize = io->getPosition();
for (;;)
{
// seek to the position of the next block
DWORD curBlockAddress = prevAddress + roundUpToBlockAlignment(prevDataLen);
io->setPosition(curBlockAddress);
// if the io is at the end of the file, then break out
if ((curBlockAddress + header.blockHeaderSize) > fileSize)
break;
// create a new block
STRBBlock block;
block.data = NULL;
// read the block header
block.id = (STRRBBlockId)io->readMultiByte(header.blockIDSize);
block.dataLength = prevDataLen = (int)io->readMultiByte(header.blockSpanSize);
block.fieldSize = (int)io->readMultiByte(header.blockSpanSize);
if (block.id == STRBAssetMetadata)
parseMetadataLegacyV1(curBlockAddress + header.blockHeaderSize);
else if (block.id == STRBAssetMetadataVersioned)
parseMetadata(curBlockAddress + header.blockHeaderSize);
else if (block.id == STRBCustomColorTable)
parseColorTable(curBlockAddress + header.blockHeaderSize);
else if (block.id == STRBAnimation)
readAnimationInfo(curBlockAddress + header.blockHeaderSize);
// check the values read in
if (block.dataLength < 0 || block.fieldSize == 0 || (block.dataLength % block.fieldSize) != 0)
throw string("STRB: Invalid block header value(s).\n");
prevAddress = curBlockAddress + header.blockHeaderSize;
block.dataAddress = prevAddress;
blocks.push_back(block);
}
}
void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
{
char *name = NULL;
mapcache_tileset *tileset = NULL;
ezxml_t cur_node;
char* value;
int havewgs84bbox=0;
if(config->mode == MAPCACHE_MODE_NORMAL) {
name = (char*)ezxml_attr(node,"name");
} else {
name = "mirror";
}
if(!name || !strlen(name)) {
ctx->set_error(ctx, 400, "mandatory attribute \"name\" not found in <tileset>");
return;
} else {
name = apr_pstrdup(ctx->pool, name);
/* check we don't already have a cache defined with this name */
if(mapcache_configuration_get_tileset(config, name)) {
ctx->set_error(ctx, 400, "duplicate tileset with name \"%s\"",name);
return;
}
}
tileset = mapcache_tileset_create(ctx);
tileset->name = name;
if ((cur_node = ezxml_child(node,"read-only")) != NULL) {
if(cur_node->txt && !strcmp(cur_node->txt,"true"))
tileset->read_only = 1;
}
if ((cur_node = ezxml_child(node,"metadata")) != NULL) {
parseMetadata(ctx, cur_node, tileset->metadata);
GC_CHECK_ERROR(ctx);
}
if ((value = (char*)apr_table_get(tileset->metadata,"wgs84boundingbox")) != NULL) {
double *values;
int nvalues;
value = apr_pstrdup(ctx->pool,value);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, value, NULL, &values, &nvalues) ||
nvalues != 4) {
ctx->set_error(ctx, 400, "failed to parse extent array %s."
"(expecting 4 space separated numbers, got %d (%f %f %f %f)"
"eg <wgs84bbox>-180 -90 180 90</wgs84bbox>",
value,nvalues,values[0],values[1],values[2],values[3]);
return;
}
tileset->wgs84bbox.minx = values[0];
tileset->wgs84bbox.miny = values[1];
tileset->wgs84bbox.maxx = values[2];
tileset->wgs84bbox.maxy = values[3];
havewgs84bbox = 1;
}
for(cur_node = ezxml_child(node,"grid"); cur_node; cur_node = cur_node->next) {
mapcache_grid *grid;
mapcache_grid_link *gridlink;
char *restrictedExtent = NULL, *sTolerance = NULL;
mapcache_extent *extent;
int tolerance;
if (tileset->grid_links == NULL) {
tileset->grid_links = apr_array_make(ctx->pool,1,sizeof(mapcache_grid_link*));
}
grid = mapcache_configuration_get_grid(config, cur_node->txt);
if(!grid) {
ctx->set_error(ctx, 400, "tileset \"%s\" references grid \"%s\","
" but it is not configured", name, cur_node->txt);
return;
}
gridlink = apr_pcalloc(ctx->pool,sizeof(mapcache_grid_link));
gridlink->grid = grid;
gridlink->minz = 0;
gridlink->maxz = grid->nlevels;
gridlink->grid_limits = (mapcache_extent_i*)apr_pcalloc(ctx->pool,grid->nlevels*sizeof(mapcache_extent_i));
gridlink->outofzoom_strategy = MAPCACHE_OUTOFZOOM_NOTCONFIGURED;
gridlink->intermediate_grids = apr_array_make(ctx->pool,1,sizeof(mapcache_grid_link*));
restrictedExtent = (char*)ezxml_attr(cur_node,"restricted_extent");
if(restrictedExtent) {
int nvalues;
double *values;
restrictedExtent = apr_pstrdup(ctx->pool,restrictedExtent);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, restrictedExtent, NULL, &values, &nvalues) ||
nvalues != 4) {
ctx->set_error(ctx, 400, "failed to parse extent array %s."
"(expecting 4 space separated numbers, "
"eg <grid restricted_extent=\"-180 -90 180 90\">foo</grid>",
restrictedExtent);
return;
}
gridlink->restricted_extent = (mapcache_extent*) apr_pcalloc(ctx->pool, sizeof(mapcache_extent));
gridlink->restricted_extent->minx = values[0];
gridlink->restricted_extent->miny = values[1];
gridlink->restricted_extent->maxx = values[2];
gridlink->restricted_extent->maxy = values[3];
extent = gridlink->restricted_extent;
} else {
extent = &grid->extent;
}
tolerance = 5;
sTolerance = (char*)ezxml_attr(cur_node,"tolerance");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid tolerance %s (expecting a positive integer)",
sTolerance);
return;
}
}
sTolerance = (char*)ezxml_attr(cur_node,"use_wms_intermediate_resolutions");
if(sTolerance && !strcmp(sTolerance,"true")) {
mapcache_grid_link *intermediate_gridlink = apr_pcalloc(ctx->pool,sizeof(mapcache_grid_link));
APR_ARRAY_PUSH(gridlink->intermediate_grids,mapcache_grid_link*) = intermediate_gridlink;
}
mapcache_grid_compute_limits(grid,extent,gridlink->grid_limits,tolerance);
sTolerance = (char*)ezxml_attr(cur_node,"minzoom");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid minzoom %s (expecting a positive integer)",
sTolerance);
return;
}
gridlink->minz = tolerance;
}
sTolerance = (char*)ezxml_attr(cur_node,"maxzoom");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid maxzoom %s (expecting a positive integer)",
sTolerance);
return;
}
gridlink->maxz = tolerance + 1;
}
if(gridlink->minz<0 || gridlink->maxz>grid->nlevels || gridlink->minz>=gridlink->maxz) {
ctx->set_error(ctx, 400, "invalid grid maxzoom/minzoom %d/%d", gridlink->minz,gridlink->maxz);
return;
}
sTolerance = (char*)ezxml_attr(cur_node,"max-cached-zoom");
/* RFC97 implementation: check for a maximum zoomlevel to cache */
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid max-cached-zoom %s (expecting a positive integer)",
sTolerance);
return;
}
if(tolerance > gridlink->maxz) {
ctx->set_error(ctx, 400, "failed to parse grid max-cached-zoom %s (max cached zoom is greater than grid's max zoom)",
sTolerance);
return;
}
gridlink->max_cached_zoom = tolerance;
/* default to reassembling */
gridlink->outofzoom_strategy = MAPCACHE_OUTOFZOOM_REASSEMBLE;
sTolerance = (char*)ezxml_attr(cur_node,"out-of-zoom-strategy");
if(sTolerance) {
if(!strcasecmp(sTolerance,"reassemble")) {
gridlink->outofzoom_strategy = MAPCACHE_OUTOFZOOM_REASSEMBLE;
}
else if(!strcasecmp(sTolerance,"proxy")) {
gridlink->outofzoom_strategy = MAPCACHE_OUTOFZOOM_PROXY;
} else {
ctx->set_error(ctx, 400, "failed to parse grid out-of-zoom-strategy %s (expecting \"reassemble\" or \"proxy\")",
sTolerance);
return;
}
}
}
/* compute wgs84 bbox if it wasn't supplied already */
if(!havewgs84bbox && !strcasecmp(grid->srs,"EPSG:4326")) {
tileset->wgs84bbox = *extent;
}
if(gridlink->intermediate_grids->nelts > 0) {
double factor = 0.5, unitheight,unitwidth;
int i;
mapcache_grid_link *igl = APR_ARRAY_IDX(gridlink->intermediate_grids, 0, mapcache_grid_link*);
igl->restricted_extent = gridlink->restricted_extent;
igl->minz = gridlink->minz;
igl->max_cached_zoom = gridlink->max_cached_zoom - 1;
igl->maxz = gridlink->maxz - 1;
igl->outofzoom_strategy = gridlink->outofzoom_strategy;
igl->grid = mapcache_grid_create(ctx->pool);
igl->grid->extent = gridlink->grid->extent;
igl->grid->name = apr_psprintf(ctx->pool,"%s_intermediate_%g",gridlink->grid->name,factor);
igl->grid->nlevels = gridlink->grid->nlevels - 1;
igl->grid->origin = gridlink->grid->origin;
igl->grid->srs = gridlink->grid->srs;
igl->grid->srs_aliases = gridlink->grid->srs_aliases;
igl->grid->unit = gridlink->grid->unit;
igl->grid->tile_sx = gridlink->grid->tile_sx + gridlink->grid->tile_sx * factor;
igl->grid->tile_sy = gridlink->grid->tile_sy + gridlink->grid->tile_sy * factor;
igl->grid->levels = (mapcache_grid_level**)apr_pcalloc(ctx->pool, igl->grid->nlevels*sizeof(mapcache_grid_level*));
for(i=0; i<igl->grid->nlevels; i++) {
mapcache_grid_level *level = (mapcache_grid_level*)apr_pcalloc(ctx->pool,sizeof(mapcache_grid_level));
level->resolution = gridlink->grid->levels[i]->resolution + (gridlink->grid->levels[i+1]->resolution - gridlink->grid->levels[i]->resolution) * factor;
unitheight = igl->grid->tile_sy * level->resolution;
unitwidth = igl->grid->tile_sx * level->resolution;
level->maxy = ceil((igl->grid->extent.maxy-igl->grid->extent.miny - 0.01* unitheight)/unitheight);
level->maxx = ceil((igl->grid->extent.maxx-igl->grid->extent.minx - 0.01* unitwidth)/unitwidth);
igl->grid->levels[i] = level;
}
igl->grid_limits = (mapcache_extent_i*)apr_pcalloc(ctx->pool,igl->grid->nlevels*sizeof(mapcache_extent_i));
mapcache_grid_compute_limits(igl->grid,extent,igl->grid_limits,tolerance);
}
void parseGrid(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config)
{
char *name;
mapcache_extent extent = {0,0,0,0};
mapcache_grid *grid;
ezxml_t cur_node;
char *value;
name = (char*)ezxml_attr(node,"name");
if(!name || !strlen(name)) {
ctx->set_error(ctx, 400, "mandatory attribute \"name\" not found in <grid>");
return;
} else {
name = apr_pstrdup(ctx->pool, name);
/* check we don't already have a grid defined with this name */
if(mapcache_configuration_get_grid(config, name)) {
ctx->set_error(ctx, 400, "duplicate grid with name \"%s\"",name);
return;
}
}
grid = mapcache_grid_create(ctx->pool);
grid->name = name;
if ((cur_node = ezxml_child(node,"extent")) != NULL) {
double *values;
int nvalues;
value = apr_pstrdup(ctx->pool,cur_node->txt);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, value, NULL, &values, &nvalues) ||
nvalues != 4) {
ctx->set_error(ctx, 400, "failed to parse extent array %s."
"(expecting 4 space separated numbers, got %d (%f %f %f %f)"
"eg <extent>-180 -90 180 90</extent>",
value,nvalues,values[0],values[1],values[2],values[3]);
return;
}
extent.minx = values[0];
extent.miny = values[1];
extent.maxx = values[2];
extent.maxy = values[3];
}
if ((cur_node = ezxml_child(node,"metadata")) != NULL) {
parseMetadata(ctx, cur_node, grid->metadata);
GC_CHECK_ERROR(ctx);
}
if ((cur_node = ezxml_child(node,"units")) != NULL) {
if(!strcasecmp(cur_node->txt,"dd")) {
grid->unit = MAPCACHE_UNIT_DEGREES;
} else if(!strcasecmp(cur_node->txt,"m")) {
grid->unit = MAPCACHE_UNIT_METERS;
} else if(!strcasecmp(cur_node->txt,"ft")) {
grid->unit = MAPCACHE_UNIT_FEET;
} else {
ctx->set_error(ctx, 400, "unknown unit %s for grid %s (valid values are \"dd\", \"m\", and \"ft\"",
cur_node->txt, grid->name);
return;
}
}
if ((cur_node = ezxml_child(node,"srs")) != NULL) {
grid->srs = apr_pstrdup(ctx->pool,cur_node->txt);
}
for(cur_node = ezxml_child(node,"srsalias"); cur_node; cur_node = cur_node->next) {
value = apr_pstrdup(ctx->pool,cur_node->txt);
APR_ARRAY_PUSH(grid->srs_aliases,char*) = value;
}
if ((cur_node = ezxml_child(node,"origin")) != NULL) {
if(!strcasecmp(cur_node->txt,"top-left")) {
grid->origin = MAPCACHE_GRID_ORIGIN_TOP_LEFT;
} else if(!strcasecmp(cur_node->txt,"bottom-left")) {
grid->origin = MAPCACHE_GRID_ORIGIN_BOTTOM_LEFT;
} else if(!strcasecmp(cur_node->txt,"top-right")) {
grid->origin = MAPCACHE_GRID_ORIGIN_TOP_RIGHT;
} else if(!strcasecmp(cur_node->txt,"bottom-right")) {
grid->origin = MAPCACHE_GRID_ORIGIN_BOTTOM_RIGHT;
} else {
ctx->set_error(ctx, 400,
"unknown origin %s for grid %s (valid values are \"top-left\", \"bottom-left\", \"top-right\" and \"bottom-right\"",
cur_node->txt, grid->name);
return;
}
if(grid->origin == MAPCACHE_GRID_ORIGIN_BOTTOM_RIGHT || grid->origin == MAPCACHE_GRID_ORIGIN_TOP_RIGHT) {
ctx->set_error(ctx,500,"grid origin %s not implemented",cur_node->txt);
return;
}
}
if ((cur_node = ezxml_child(node,"size")) != NULL) {
int *sizes, nsizes;
value = apr_pstrdup(ctx->pool,cur_node->txt);
if(MAPCACHE_SUCCESS != mapcache_util_extract_int_list(ctx, value, NULL, &sizes, &nsizes) ||
nsizes != 2) {
ctx->set_error(ctx, 400, "failed to parse size array %s in grid %s"
"(expecting two space separated integers, eg <size>256 256</size>",
value, grid->name);
return;
}
grid->tile_sx = sizes[0];
grid->tile_sy = sizes[1];
}
if ((cur_node = ezxml_child(node,"resolutions")) != NULL) {
int nvalues;
double *values;
value = apr_pstrdup(ctx->pool,cur_node->txt);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, value, NULL, &values, &nvalues) ||
!nvalues) {
ctx->set_error(ctx, 400, "failed to parse resolutions array %s."
"(expecting space separated numbers, "
"eg <resolutions>1 2 4 8 16 32</resolutions>",
value);
return;
}
grid->nlevels = nvalues;
grid->levels = (mapcache_grid_level**)apr_pcalloc(ctx->pool,
grid->nlevels*sizeof(mapcache_grid_level));
while(nvalues--) {
double unitheight;
double unitwidth;
mapcache_grid_level *level = (mapcache_grid_level*)apr_pcalloc(ctx->pool,sizeof(mapcache_grid_level));
level->resolution = values[nvalues];
unitheight = grid->tile_sy * level->resolution;
unitwidth = grid->tile_sx * level->resolution;
level->maxy = ceil((extent.maxy-extent.miny - 0.01* unitheight)/unitheight);
level->maxx = ceil((extent.maxx-extent.minx - 0.01* unitwidth)/unitwidth);
grid->levels[nvalues] = level;
}
}
if(grid->srs == NULL) {
ctx->set_error(ctx, 400, "grid \"%s\" has no srs configured."
" You must add a <srs> tag.", grid->name);
return;
}
if(extent.minx >= extent.maxx || extent.miny >= extent.maxy) {
ctx->set_error(ctx, 400, "grid \"%s\" has no (or invalid) extent configured"
" You must add/correct a <extent> tag.", grid->name);
return;
} else {
grid->extent = extent;
}
if(grid->tile_sx <= 0 || grid->tile_sy <= 0) {
ctx->set_error(ctx, 400, "grid \"%s\" has no (or invalid) tile size configured"
" You must add/correct a <size> tag.", grid->name);
return;
}
if(!grid->nlevels) {
ctx->set_error(ctx, 400, "grid \"%s\" has no resolutions configured."
" You must add a <resolutions> tag.", grid->name);
return;
}
mapcache_configuration_add_grid(config,grid,name);
}
void SM_QDropbox::requestFinished(int nr, QNetworkReply *rply)
{
rply->deleteLater();
#ifdef SM_QTDROPBOX_DEBUG
int resp_bytes = rply->bytesAvailable();
#endif
QByteArray buff = rply->readAll();
QString response = QString(buff);
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "request " << nr << "finished." << endl;
qDebug() << "request was: " << rply->url().toString() << endl;
#endif
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "response: " << resp_bytes << "bytes" << endl;
qDebug() << "status code: " << rply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toString() << endl;
qDebug() << "== begin response ==" << endl << response << endl << "== end response ==" << endl;
qDebug() << "req#" << nr << " is of type " << requestMap[nr].type << endl;
#endif
// drop box error handling based on return codes
switch(rply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt())
{
case SM_DROPBOX_ERROR_BAD_INPUT:
errorState = SM_QDropbox::BadInput;
errorText = "";
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_EXPIRED_TOKEN:
errorState = SM_QDropbox::TokenExpired;
errorText = "";
emit tokenExpired();
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_BAD_OAUTH_REQUEST:
errorState = SM_QDropbox::BadOAuthRequest;
errorText = "";
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_FILE_NOT_FOUND:
emit fileNotFound();
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_WRONG_METHOD:
errorState = SM_QDropbox::WrongHttpMethod;
errorText = "";
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_REQUEST_CAP:
errorState = SM_QDropbox::MaxRequestsExceeded;
errorText = "";
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
break;
case SM_DROPBOX_ERROR_USER_OVER_QUOTA:
errorState = SM_QDropbox::UserOverQuota;
errorText = "";
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
break;
default:
break;
}
if(rply->error() != QNetworkReply::NoError)
{
errorState = SM_QDropbox::CommunicationError;
errorText = QString("%1 - %2").arg(rply->error()).arg(rply->errorString());
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "error " << errorState << "(" << errorText << ") in request" << endl;
#endif
emit errorOccured(errorState);
checkReleaseEventLoop(nr);
return;
}
// ignore connection requests
if(requestMap[nr].type == SM_DROPBOX_REQ_CONNECT)
{
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "- answer to connection request ignored" << endl;
#endif
removeRequestFromMap(nr);
return;
}
bool delayed_finish = false;
int delayed_nr;
if(rply->attribute(QNetworkRequest::HttpStatusCodeAttribute) == 302)
{
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "redirection received" << endl;
#endif
// redirection handling
QUrl newlocation(rply->header(QNetworkRequest::LocationHeader).toString(), QUrl::StrictMode);
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "new url: " << newlocation.toString() << endl;
#endif
int oldnr = nr;
nr = sendRequest(newlocation, requestMap[nr].method, 0, requestMap[nr].host);
requestMap[nr].type = SM_DROPBOX_REQ_REDIREC;
requestMap[nr].linked = oldnr;
return;
}
else
{
if(requestMap[nr].type == SM_DROPBOX_REQ_REDIREC)
{
// change values if this is the answert to a redirect
SM_DROPBOX_request redir = requestMap[nr];
SM_DROPBOX_request orig = requestMap[redir.linked];
requestMap[nr] = orig;
removeRequestFromMap(nr);
nr = redir.linked;
}
// standard handling depending on message type
switch(requestMap[nr].type)
{
case SM_DROPBOX_REQ_CONNECT:
// was only a connect request - so drop it
break;
case SM_DROPBOX_REQ_RQTOKEN:
// requested a tiken
responseTokenRequest(response);
break;
case SM_DROPBOX_REQ_RQBTOKN:
responseBlockedTokenRequest(response);
break;
case SM_DROPBOX_REQ_AULOGIN:
delayed_nr = responseDropboxLogin(response, nr);
delayed_finish = true;
break;
case SM_DROPBOX_REQ_ACCTOKN:
responseAccessToken(response);
break;
case SM_DROPBOX_REQ_METADAT:
parseMetadata(response);
break;
case SM_DROPBOX_REQ_BMETADA:
parseBlockingMetadata(response);
break;
case SM_DROPBOX_REQ_BACCTOK:
responseBlockingAccessToken(response);
break;
case SM_DROPBOX_REQ_ACCINFO:
parseAccountInfo(response);
break;
case SM_DROPBOX_REQ_BACCINF:
parseBlockingAccountInfo(response);
break;
case SM_DROPBOX_REQ_SHRDLNK:
parseSharedLink(response);
break;
case SM_DROPBOX_REQ_BSHRDLN:
parseBlockingSharedLink(response);
break;
case SM_DROPBOX_REQ_REVISIO:
parseRevisions(response);
break;
case SM_DROPBOX_REQ_BREVISI:
parseBlockingRevisions(response);
break;
case SM_DROPBOX_REQ_DELTA:
parseDelta(response);
break;
case SM_DROPBOX_REQ_BDELTA:
parseBlockingDelta(response);
break;
default:
errorState = SM_QDropbox::ResponseToUnknownRequest;
errorText = "Received a response to an unknown request";
emit errorOccured(errorState);
break;
}
}
if(delayed_finish)
delayMap[delayed_nr] = nr;
else
{
if(delayMap[nr])
{
int drq = delayMap[nr];
while(drq!=0)
{
emit operationFinished(delayMap[drq]);
delayMap.remove(drq);
drq = delayMap[drq];
}
}
removeRequestFromMap(nr);
emit operationFinished(nr);
}
return;
}
void parseTileset(mapcache_context *ctx, ezxml_t node, mapcache_cfg *config) {
char *name = NULL;
mapcache_tileset *tileset = NULL;
ezxml_t cur_node;
char* value;
int havewgs84bbox=0;
if(config->mode == MAPCACHE_MODE_NORMAL) {
name = (char*)ezxml_attr(node,"name");
} else {
name = "mirror";
}
if(!name || !strlen(name)) {
ctx->set_error(ctx, 400, "mandatory attribute \"name\" not found in <tileset>");
return;
}
else {
name = apr_pstrdup(ctx->pool, name);
/* check we don't already have a cache defined with this name */
if(mapcache_configuration_get_tileset(config, name)) {
ctx->set_error(ctx, 400, "duplicate tileset with name \"%s\"",name);
return;
}
}
tileset = mapcache_tileset_create(ctx);
tileset->name = name;
if ((cur_node = ezxml_child(node,"metadata")) != NULL) {
parseMetadata(ctx, cur_node, tileset->metadata);
GC_CHECK_ERROR(ctx);
}
if ((value = (char*)apr_table_get(tileset->metadata,"wgs84boundingbox")) != NULL) {
double *values;
int nvalues;
value = apr_pstrdup(ctx->pool,value);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, value, NULL, &values, &nvalues) ||
nvalues != 4) {
ctx->set_error(ctx, 400, "failed to parse extent array %s."
"(expecting 4 space separated numbers, got %d (%f %f %f %f)"
"eg <wgs84bbox>-180 -90 180 90</wgs84bbox>",
value,nvalues,values[0],values[1],values[2],values[3]);
return;
}
tileset->wgs84bbox[0] = values[0];
tileset->wgs84bbox[1] = values[1];
tileset->wgs84bbox[2] = values[2];
tileset->wgs84bbox[3] = values[3];
havewgs84bbox = 1;
}
for(cur_node = ezxml_child(node,"grid"); cur_node; cur_node = cur_node->next) {
int i;
mapcache_grid *grid;
mapcache_grid_link *gridlink;
char *restrictedExtent = NULL, *sTolerance = NULL;
double *extent;
int tolerance;
if (tileset->grid_links == NULL) {
tileset->grid_links = apr_array_make(ctx->pool,1,sizeof(mapcache_grid_link*));
}
grid = mapcache_configuration_get_grid(config, cur_node->txt);
if(!grid) {
ctx->set_error(ctx, 400, "tileset \"%s\" references grid \"%s\","
" but it is not configured", name, cur_node->txt);
return;
}
gridlink = apr_pcalloc(ctx->pool,sizeof(mapcache_grid_link));
gridlink->grid = grid;
gridlink->minz = 0;
gridlink->maxz = grid->nlevels;
gridlink->grid_limits = apr_pcalloc(ctx->pool,grid->nlevels*sizeof(int*));
for(i=0;i<grid->nlevels;i++) {
gridlink->grid_limits[i] = apr_pcalloc(ctx->pool,4*sizeof(int));
}
restrictedExtent = (char*)ezxml_attr(cur_node,"restricted_extent");
if(restrictedExtent) {
int nvalues;
restrictedExtent = apr_pstrdup(ctx->pool,restrictedExtent);
if(MAPCACHE_SUCCESS != mapcache_util_extract_double_list(ctx, restrictedExtent, NULL, &gridlink->restricted_extent, &nvalues) ||
nvalues != 4) {
ctx->set_error(ctx, 400, "failed to parse extent array %s."
"(expecting 4 space separated numbers, "
"eg <grid restricted_extent=\"-180 -90 180 90\">foo</grid>",
restrictedExtent);
return;
}
extent = gridlink->restricted_extent;
} else {
extent = grid->extent;
}
tolerance = 5;
sTolerance = (char*)ezxml_attr(cur_node,"tolerance");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid tolerance %s (expecting a positive integer)",
sTolerance);
return;
}
}
mapcache_grid_compute_limits(grid,extent,gridlink->grid_limits,tolerance);
sTolerance = (char*)ezxml_attr(cur_node,"minzoom");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid minzoom %s (expecting a positive integer)",
sTolerance);
return;
}
gridlink->minz = tolerance;
}
sTolerance = (char*)ezxml_attr(cur_node,"maxzoom");
if(sTolerance) {
char *endptr;
tolerance = (int)strtol(sTolerance,&endptr,10);
if(*endptr != 0 || tolerance < 0) {
ctx->set_error(ctx, 400, "failed to parse grid maxzoom %s (expecting a positive integer)",
sTolerance);
return;
}
gridlink->maxz = tolerance + 1;
}
if(gridlink->minz<0 || gridlink->maxz>grid->nlevels || gridlink->minz>=gridlink->maxz) {
ctx->set_error(ctx, 400, "invalid grid maxzoom/minzoom %d/%d", gridlink->minz,gridlink->maxz);
return;
}
/* compute wgs84 bbox if it wasn't supplied already */
if(!havewgs84bbox && !strcasecmp(grid->srs,"EPSG:4326")) {
tileset->wgs84bbox[0] = extent[0];
tileset->wgs84bbox[1] = extent[1];
tileset->wgs84bbox[2] = extent[2];
tileset->wgs84bbox[3] = extent[3];
}
APR_ARRAY_PUSH(tileset->grid_links,mapcache_grid_link*) = gridlink;
}
if ((cur_node = ezxml_child(node,"dimensions")) != NULL) {
parseDimensions(ctx, cur_node, tileset);
GC_CHECK_ERROR(ctx);
}
if ((cur_node = ezxml_child(node,"cache")) != NULL) {
mapcache_cache *cache = mapcache_configuration_get_cache(config, cur_node->txt);
if(!cache) {
ctx->set_error(ctx, 400, "tileset \"%s\" references cache \"%s\","
" but it is not configured", name, cur_node->txt);
return;
}
tileset->cache = cache;
}
if ((cur_node = ezxml_child(node,"source")) != NULL) {
mapcache_source *source = mapcache_configuration_get_source(config, cur_node->txt);
if(!source) {
ctx->set_error(ctx, 400, "tileset \"%s\" references source \"%s\","
" but it is not configured", name, cur_node->txt);
return;
}
tileset->source = source;
}
if ((cur_node = ezxml_child(node,"metatile")) != NULL) {
int *values, nvalues;
value = apr_pstrdup(ctx->pool,cur_node->txt);
if(MAPCACHE_SUCCESS != mapcache_util_extract_int_list(ctx, cur_node->txt, NULL,
&values, &nvalues) ||
nvalues != 2) {
ctx->set_error(ctx, 400, "failed to parse metatile dimension %s."
"(expecting 2 space separated integers, "
"eg <metatile>5 5</metatile>",
cur_node->txt);
return;
}
tileset->metasize_x = values[0];
tileset->metasize_y = values[1];
}
if ((cur_node = ezxml_child(node,"watermark")) != NULL) {
if(!*cur_node->txt) {
ctx->set_error(ctx,400, "watermark config entry empty");
return;
}
mapcache_tileset_add_watermark(ctx,tileset,cur_node->txt);
GC_CHECK_ERROR(ctx);
}
if ((cur_node = ezxml_child(node,"expires")) != NULL) {
char *endptr;
tileset->expires = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx, 400, "failed to parse expires %s."
"(expecting an integer, "
"eg <expires>3600</expires>",
cur_node->txt);
return;
}
}
if ((cur_node = ezxml_child(node,"auto_expire")) != NULL) {
char *endptr;
tileset->auto_expire = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx, 400, "failed to parse auto_expire %s."
"(expecting an integer, "
"eg <auto_expire>3600</auto_expire>",
cur_node->txt);
return;
}
}
if ((cur_node = ezxml_child(node,"metabuffer")) != NULL) {
char *endptr;
tileset->metabuffer = (int)strtol(cur_node->txt,&endptr,10);
if(*endptr != 0) {
ctx->set_error(ctx, 400, "failed to parse metabuffer %s."
"(expecting an integer, "
"eg <metabuffer>1</metabuffer>",
cur_node->txt);
return;
}
}
if ((cur_node = ezxml_child(node,"format")) != NULL) {
mapcache_image_format *format = mapcache_configuration_get_image_format(config,cur_node->txt);
if(!format) {
ctx->set_error(ctx, 400, "tileset \"%s\" references format \"%s\","
" but it is not configured",name,cur_node->txt);
return;
}
tileset->format = format;
}
mapcache_tileset_configuration_check(ctx,tileset);
GC_CHECK_ERROR(ctx);
mapcache_configuration_add_tileset(config,tileset,name);
return;
}
void MDAL::LoaderGdal::parseRasterBands( const MDAL::GdalDataset *cfGDALDataset )
{
for ( unsigned int i = 1; i <= cfGDALDataset->mNBands; ++i ) // starts with 1 .... ehm....
{
// Get Band
GDALRasterBandH gdalBand = GDALGetRasterBand( cfGDALDataset->mHDataset, static_cast<int>( i ) );
if ( !gdalBand )
{
throw MDAL_Status::Err_InvalidData;
}
// Reference time
metadata_hash global_metadata = parseMetadata( cfGDALDataset->mHDataset );
parseGlobals( global_metadata );
// Get metadata
metadata_hash metadata = parseMetadata( gdalBand );
std::string band_name;
double time = std::numeric_limits<double>::min();
bool is_vector;
bool is_x;
if ( parseBandInfo( cfGDALDataset, metadata, band_name, &time, &is_vector, &is_x ) )
{
continue;
}
// Add to data structures
std::vector<GDALRasterBandH>::size_type data_count = is_vector ? 2 : 1;
std::vector<GDALRasterBandH>::size_type data_index = is_x ? 0 : 1;
if ( mBands.find( band_name ) == mBands.end() )
{
// this Face is not yet added at all
// => create new map
timestep_map qMap;
std::vector<GDALRasterBandH> raster_bands( data_count );
raster_bands[data_index] = gdalBand;
qMap[time] = raster_bands;
mBands[band_name] = qMap;
}
else
{
timestep_map::iterator timestep = mBands[band_name].find( time );
if ( timestep == mBands[band_name].end() )
{
// Face is there, but new timestep
// => create just new map entry
std::vector<GDALRasterBandH> raster_bands( data_count );
raster_bands[data_index] = gdalBand;
mBands[band_name][time] = raster_bands;
}
else
{
// Face is there, and timestep too, this must be other part
// of the existing vector
timestep->second[data_index] = gdalBand;
}
}
}
}
int erClXmlParseManifest(char *szContainerPath, clDisplayItem_t * displayItem)
{
int ret = -1; // return value: 0 = ok, -1 = error
xmlDoc *doc = NULL;
xmlNode *rootElement = NULL;
xmlNode *cur = NULL;
xmlNode *symlinkElement = NULL;
xmlChar *targetPath = NULL;
xmlChar *key;
int n = strlen(szContainerPath) + 1 + strlen(MANIFEST_FILENAME) + 1;
char *szFilename = alloca(n);
g_assert(szFilename != NULL);
snprintf(szFilename, n, "%s/" MANIFEST_FILENAME, szContainerPath);
LIBXML_TEST_VERSION doc = xmlParseFile(szFilename);
if (doc == NULL)
{
CL_ERRORPRINTF("Document not parsed successfully");
return ret;
}
/* Get the root element node */
rootElement = xmlDocGetRootElement(doc);
// Check whether we have a document with the correct root (i.e. package)
if (xmlStrcmp(rootElement->name, (const xmlChar *) "package"))
{
CL_ERRORPRINTF("Document of the wrong type, root node != package");
xmlFreeDoc(doc);
return ret;
}
// Check whether this manifest actually is a symlink
symlinkElement = ermXmlGetChildNode(rootElement, "symlink");
if (symlinkElement)
{
// check whether target must be extended with locale
displayItem->fit = mdsFitManifestSymlink;
key = xmlGetProp(symlinkElement, "add-locale");
if (key)
{
if (xmlStrcmp(key, "true") == 0)
{
displayItem->fit = mdsFitManifestSymlinkLocale;
}
xmlFree(key);
}
// get target details
targetPath = xmlNodeGetContent(symlinkElement);
szFilename = getVerifiedPath(targetPath, szContainerPath);
CL_WARNPRINTF("symlink [%s] [%s] --> [%s]", szContainerPath, targetPath, szFilename);
if (szFilename)
{
strcpy(displayItem->szFilename, szFilename);
free(szFilename);
}
else
{
CL_ERRORPRINTF("directory [%s] [%s] is incorrect", szContainerPath, targetPath);
// display as a folder without manifest
strcpy(displayItem->szFilename, szContainerPath);
displayItem->fit = mdsFitFolder;
}
}
else
{
cur = rootElement->xmlChildrenNode;
while (cur != NULL)
{
if ((!xmlStrcmp(cur->name, (const xmlChar *) "metadata")))
{
CL_LOGPRINTF("Found node metadata");
parseMetadata(doc, cur, displayItem, szContainerPath);
}
if ((!xmlStrcmp(cur->name, (const xmlChar *) "storage")))
{
CL_LOGPRINTF("Found node storage");
parseStoragedata(doc, cur, displayItem, szContainerPath);
//update the type of container, since this is a special type of container
displayItem->fit = mdsFitStorage;
}
if ((!xmlStrcmp(cur->name, (const xmlChar *) "application")))
{
CL_LOGPRINTF("Found node application");
parseApplicationdata(doc, cur, displayItem, szContainerPath);
//update the type of container, since this is a special type of container
displayItem->fit = mdsFitApplication;
}
if ((!xmlStrcmp(cur->name, (const xmlChar *) "directory")))
{
CL_LOGPRINTF("Found node directory");
parseDirectorydata(doc, cur, displayItem, szContainerPath);
//update the type of container, since this is a special type of container
displayItem->fit = mdsFitManifestDirectory;
}
cur = cur->next;
}
}
/* free the document */
xmlFreeDoc(doc);
/* Free the global variables that may have been allocated by the parser */
xmlCleanupParser();
return 0;
}
void mapcache_configuration_parse_xml(mapcache_context *ctx, const char *filename, mapcache_cfg *config) {
ezxml_t doc, node;
const char *mode;
doc = ezxml_parse_file(filename);
if (doc == NULL) {
ctx->set_error(ctx,400, "failed to parse file %s. Is it valid XML?", filename);
goto cleanup;
} else {
const char *err = ezxml_error(doc);
if(err && *err) {
ctx->set_error(ctx,400, "failed to parse file %s: %s", filename, err);
goto cleanup;
}
}
if(strcmp(doc->name,"mapcache")) {
ctx->set_error(ctx,400, "failed to parse file %s. first node is not <mapcache>", filename);
goto cleanup;
}
mode = ezxml_attr(doc,"mode");
if(mode) {
if(!strcmp(mode,"combined_mirror")) {
config->mode = MAPCACHE_MODE_MIRROR_COMBINED;
} else if(!strcmp(mode,"split_mirror")) {
config->mode = MAPCACHE_MODE_MIRROR_SPLIT;
} else if(!strcmp(mode,"normal")) {
config->mode = MAPCACHE_MODE_NORMAL;
} else {
ctx->set_error(ctx,400,"unknown mode \"%s\" for <mapcache>",mode);
goto cleanup;
}
} else {
config->mode = MAPCACHE_MODE_NORMAL;
}
for(node = ezxml_child(doc,"metadata"); node; node = node->next) {
parseMetadata(ctx, node, config->metadata);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"source"); node; node = node->next) {
parseSource(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"grid"); node; node = node->next) {
parseGrid(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"format"); node; node = node->next) {
parseFormat(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"cache"); node; node = node->next) {
parseCache(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
for(node = ezxml_child(doc,"tileset"); node; node = node->next) {
parseTileset(ctx, node, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
if ((node = ezxml_child(doc,"service")) != NULL) {
ezxml_t service_node;
for(service_node = node; service_node; service_node = service_node->next) {
char *enabled = (char*)ezxml_attr(service_node,"enabled");
char *type = (char*)ezxml_attr(service_node,"type");
if(!strcasecmp(enabled,"true")) {
if (!strcasecmp(type,"wms")) {
mapcache_service *new_service = mapcache_service_wms_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_WMS] = new_service;
}
else if (!strcasecmp(type,"tms")) {
mapcache_service *new_service = mapcache_service_tms_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_TMS] = new_service;
}
else if (!strcasecmp(type,"wmts")) {
mapcache_service *new_service = mapcache_service_wmts_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_WMTS] = new_service;
}
else if (!strcasecmp(type,"kml")) {
mapcache_service *new_service = mapcache_service_kml_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_KML] = new_service;
}
else if (!strcasecmp(type,"gmaps")) {
mapcache_service *new_service = mapcache_service_gmaps_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_GMAPS] = new_service;
}
else if (!strcasecmp(type,"ve")) {
mapcache_service *new_service = mapcache_service_ve_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_VE] = new_service;
}
else if (!strcasecmp(type,"demo")) {
mapcache_service *new_service = mapcache_service_demo_create(ctx);
if(new_service->configuration_parse_xml) {
new_service->configuration_parse_xml(ctx,service_node,new_service,config);
}
config->services[MAPCACHE_SERVICE_DEMO] = new_service;
} else {
ctx->set_error(ctx,400,"unknown <service> type %s",type);
}
if(GC_HAS_ERROR(ctx)) goto cleanup;
}
}
}
else if ((node = ezxml_child(doc,"services")) != NULL) {
ctx->log(ctx,MAPCACHE_WARN,"<services> tag is deprecated, use <service type=\"wms\" enabled=\"true|false\">");
parseServices(ctx, node, config);
} else {
ctx->set_error(ctx, 400, "no <services> configured");
}
if(GC_HAS_ERROR(ctx)) goto cleanup;
node = ezxml_child(doc,"default_format");
if(!node)
node = ezxml_child(doc,"merge_format");
if (node) {
mapcache_image_format *format = mapcache_configuration_get_image_format(config,node->txt);
if(!format) {
ctx->set_error(ctx, 400, "default_format tag references format %s but it is not configured",
node->txt);
goto cleanup;
}
config->default_image_format = format;
}
if ((node = ezxml_child(doc,"errors")) != NULL) {
if(!strcmp(node->txt,"log")) {
config->reporting = MAPCACHE_REPORT_LOG;
} else if(!strcmp(node->txt,"report")) {
config->reporting = MAPCACHE_REPORT_MSG;
} else if(!strcmp(node->txt,"empty_img")) {
config->reporting = MAPCACHE_REPORT_EMPTY_IMG;
mapcache_image_create_empty(ctx, config);
if(GC_HAS_ERROR(ctx)) goto cleanup;
} else if(!strcmp(node->txt, "report_img")) {
config->reporting = MAPCACHE_REPORT_ERROR_IMG;
ctx->set_error(ctx,501,"<errors>: report_img not implemented");
goto cleanup;
} else {
ctx->set_error(ctx,400,"<errors>: unknown value %s (allowed are log, report, empty_img, report_img)",
node->txt);
goto cleanup;
}
}
if((node = ezxml_child(doc,"lock_dir")) != NULL) {
config->lockdir = apr_pstrdup(ctx->pool, node->txt);
} else {
config->lockdir = apr_pstrdup(ctx->pool,"/tmp");
}
if((node = ezxml_child(doc,"lock_retry")) != NULL) {
char *endptr;
config->lock_retry_interval = (unsigned int)strtol(node->txt,&endptr,10);
if(*endptr != 0 || config->lock_retry_interval < 0) {
ctx->set_error(ctx, 400, "failed to parse lock_retry microseconds \"%s\". Expecting a positive integer",
node->txt);
return;
}
}
if((node = ezxml_child(doc,"threaded_fetching")) != NULL) {
if(!strcasecmp(node->txt,"true")) {
config->threaded_fetching = 1;
} else if(strcasecmp(node->txt,"false")) {
ctx->set_error(ctx, 400, "failed to parse threaded_fetching \"%s\". Expecting true or false",node->txt);
return;
}
}
if((node = ezxml_child(doc,"log_level")) != NULL) {
if(!strcasecmp(node->txt,"debug")) {
config->loglevel = MAPCACHE_DEBUG;
} else if(!strcasecmp(node->txt,"info")) {
config->loglevel = MAPCACHE_INFO;
} else if(!strcasecmp(node->txt,"notice")) {
config->loglevel = MAPCACHE_NOTICE;
} else if(!strcasecmp(node->txt,"warn")) {
config->loglevel = MAPCACHE_WARN;
} else if(!strcasecmp(node->txt,"error")) {
config->loglevel = MAPCACHE_ERROR;
} else if(!strcasecmp(node->txt,"crit")) {
config->loglevel = MAPCACHE_CRIT;
} else if(!strcasecmp(node->txt,"alert")) {
config->loglevel = MAPCACHE_ALERT;
} else if(!strcasecmp(node->txt,"emerg")) {
config->loglevel = MAPCACHE_EMERG;
} else {
ctx->set_error(ctx,500,"failed to parse <log_level> \"%s\". Expecting debug, info, notice, warn, error, crit, alert or emerg",node->txt);
return;
}
}
if((node = ezxml_child(doc,"auto_reload")) != NULL) {
if(!strcasecmp(node->txt,"true")) {
config->autoreload = 1;
} else if(!strcasecmp(node->txt,"false")) {
config->autoreload = 0;
} else {
ctx->set_error(ctx,500,"failed to parse <auto_reload> \"%s\". Expecting true or false",node->txt);
return;
}
}
cleanup:
ezxml_free(doc);
return;
}
void Playlist::checkForCachedMetadata() {
if (QFile(_cachePath.filePath("metadata")).exists()) {
parseMetadata();
}
}
bool parse()
{
class CloseFileClass
{
public:
CloseFileClass(VirtualFile* f): mFile(f) {}
~CloseFileClass()
{
if (mFile)
mFile->close();
}
private:
ref<VirtualFile> mFile;
} CloseFile(inputFile());
inputFile()->close();
inputFile()->open(OM_ReadOnly);
// clear metadata
mMetadata.clear();
// read version and encoding
mVersion = 0;
mEncoding.clear();
if (!parseHeader())
{
Log::error("VLXParserVLB : error parsing VLB header.\n");
return false;
}
if (mVersion != 100)
{
Log::error("VLX version not supported.\n");
return false;
}
if (mEncoding != "ascii")
{
Log::error("Encoding not supported.\n");
return false;
}
unsigned char chunk;
std::string str;
while(readChunk(chunk))
{
if(chunk == VLB_ChunkStructure)
{
ref<VLXStructure> st = new VLXStructure;
if (!parseStructure(st.get()))
{
Log::error( Say("Error parsing binary file at offset %n.\n") << inputFile()->position() );
return false;
}
mStructures.push_back(st);
}
else
{
Log::error( Say("Error parsing binary file at offset %n. Expected chunk structure.\n") << inputFile()->position() );
return false;
}
}
parseMetadata();
return true;
}