/* Ousía Copyright (C) 2014, 2015 Benjamin Paaßen, Andreas Stöckel This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include #include #include #include #include #include "ResourceManager.hpp" #include "ResourceUtils.hpp" namespace ousia { /* Static helper functions */ static bool typeSetsIntersect(const RttiSet &s1, const RttiSet &s2) { for (const Rtti *t1 : s1) { if (t1->isOneOf(s2)) { return true; } } return false; } static void logUnsopportedType(Logger &logger, const RttiSet &supportedTypes) { // Build a list containing the expected type names std::vector expected; for (const Rtti *supportedType : supportedTypes) { expected.push_back(supportedType->name); } // Log the actual error message ctx.logger.error( std::string("Expected the file \"") + resource.location + std::string("\" to define one of the following internal types ") + Utils::join(expected, ", ", "{", "}")); } /* Class ResourceManager */ SourceId ResourceManager::allocateSourceId(const Resource &resource) { // Increment the source id and make sure the values don't overflow SourceId sourceId = nextSourceId++; if (sourceId == InvalidSourceId) { nextSourceId = InvalidSourceId; throw OusiaException{"Internal resource handles depleted!"}; } // Register the node and the resource with this id locations[resource.getLocation()] = sourceId; resources[sourceId] = resource; return sourceId; } void ResourceManager::storeNode(SourceId sourceId, Handle node) { nodes[sourceId] = node->getUid(); } void ResourceManager::purgeResource(SourceId sourceId) { Resource res = getResource(sourceId); if (res.isValid()) { locations.erase(res.getLocation()); } resources.erase(sourceId); nodes.erase(sourceId); lineNumberCache.erase(sourceId); } Rooted ResourceManager::parse(ParserContext &ctx, Resource &resource, const std::string &mimetype, const RttiSet &supportedTypes) { // Try to deduce the mimetype of no mimetype was given std::string mime = mimetype; if (mime.empty()) { mime = ctx.registry.getMimetypeForFilename(resource.getLocation()); if (mime.empty()) { ctx.logger.error(std::string("Filename \"") + path + std::string( "\" has an unknown file extension. Explicitly " "specify a mimetype.")); return nullptr; } } // Fetch a parser for the mimetype const std::pair &parserDescr = ctx.registry.getParserForMimetype(mime); Parser *parser = parserDescr.first; // Make sure a parser was found if (!parser) { ctx.logger.error(std::string("Cannot parse files of type \"") + mime + std::string("\"")); return nullptr; } // Make sure the parser returns at least one of the supported types if (!typeSetsIntersect(parserDescr.second, supportedTypes)) { logUnsopportedType(ctx.logger, supportedTypes); return nullptr; } // Allocate a new SourceId handle for this Resource SourceId sourceId = allocateSourceId(resource); // We can now try to parse the given file Rooted node; try { CharReader reader(resource.stream(), sourceId); node = parser->parse(reader, ctx); if (node == nullptr) { throw LoggableException{"Internal error: Parser returned null."}; } } catch (LoggableException ex) { // Remove all data associated with the allocated source id purgeResource(sourceId); // Log the exception and return nullptr ctx.logger.log(ex); return nullptr; } // Store the parsed node along with the sourceId storeNode(sourceId, node); // Return the parsed node return node; } SourceId ResourceManager::getSourceId(const std::string &location) { auto it = locations.find(location); if (it != locations.end()) { return it->second; } return InvalidSourceId; } SourceId ResourceManager::getSourceId(const Resource &resource) { if (resource.isValid()) { return getSourceId(resource.getLocation()); } return InvalidSourceId; } const Resource &ResourceManager::getResource(SourceId sourceId) const { auto it = resources.find(sourceId); if (it != resourced.end()) { return it->second; } return NullResource; } Rooted ResourceManager::getNode(Manager &mgr, SourceId sourceId) { auto it = nodes.find(sourceId); if (it != nodes.end()) { Managed *managed = mgr.getManaged(sourceId); if (managed != nullptr) { return dynamic_cast(managed); } else { purgeResource(sourceId); } } return nullptr; } Rooted ResourceManager::getNode(Manager &mgr, const std::string &location) { return getNode(mgr, getSourceId(location)); } Rooted ResourceManager::getNode(Manager &mgr, const Resource &resource) { return getNode(mgr, getSourceId(resource)); } Rooted ResourceManager::link(ParserContext &ctx, const std::string &path, const std::string &mimetype, const std::string &rel, const RttiSet &supportedTypes, const Resource &relativeTo) { // Try to deduce the ResourceType ResourceType resourceType = ResourceUtils::deduceResourceType(rel, supportedTypes, ctx.logger); // Lookup the resource for given path and resource type Resource resource; if (!ctx.registry.locateResource(resource, path, resourceType, relativeTo)) { ctx.logger.error("File \"" + path + "\" not found."); return nullptr; } // Try to shrink the set of supportedTypes RttiSet types = ResourceUtils::limitRttiTypes(supportedTypes, rel); // Check whether the resource has already been parsed Rooted node = getNode(ctx.manager, resource); if (node == nullptr) { // Node has not already been parsed, parse it now node = parse(ctx, resource, mimetype, supportedTypes); // Abort if parsing failed if (node == nullptr) { return nullptr; } } // Make sure the node has one of the supported types if (!node->type().isOneOf(supportedTypes)) { logUnsopportedType(ctx.logger, supportedTypes); return nullptr; } return node; } Rooted ResourceManager::link(ParserContext &ctx, const std::string &path, const std::string &mimetype, const std::string &rel, const RttiSet &supportedTypes, SourceId relativeTo) { // Fetch the resource corresponding to the source id, make sure it is valid const Resource &relativeResource = getResource(relativeTo); if (!relativeResource.isValid()) { ctx.logger.fatalError("Internal error: Invalid SourceId supplied."); return nullptr; } // Continue with the usual include routine return include(ctx, path, mimetype, rel, supportedTypes, relativeResource); } SourceContext ResourceManager::buildContext(const SourceLocation &location) { SourceContext res; // TODO return res; } } #endif /* _OUSIA_RESOURCE_MANAGER_HPP_ */