diff options
Diffstat (limited to 'src/core/resource')
| -rw-r--r-- | src/core/resource/Resource.cpp | 54 | ||||
| -rw-r--r-- | src/core/resource/Resource.hpp | 28 | ||||
| -rw-r--r-- | src/core/resource/ResourceManager.cpp | 234 | ||||
| -rw-r--r-- | src/core/resource/ResourceManager.hpp | 173 | ||||
| -rw-r--r-- | src/core/resource/ResourceRequest.cpp | 238 | ||||
| -rw-r--r-- | src/core/resource/ResourceRequest.hpp | 197 | ||||
| -rw-r--r-- | src/core/resource/ResourceUtils.cpp | 138 | ||||
| -rw-r--r-- | src/core/resource/ResourceUtils.hpp | 128 |
8 files changed, 712 insertions, 478 deletions
diff --git a/src/core/resource/Resource.cpp b/src/core/resource/Resource.cpp index 349c82a..ff3c77f 100644 --- a/src/core/resource/Resource.cpp +++ b/src/core/resource/Resource.cpp @@ -16,11 +16,39 @@ along with this program. If not, see <http://www.gnu.org/licenses/>. */ +#include <core/common/Utils.hpp> + #include "Resource.hpp" #include "ResourceLocator.hpp" namespace ousia { +/* Helper functions for the internal maps */ + +static std::unordered_map<ResourceType, std::string, Utils::EnumHash> reverseMap( + const std::unordered_map<std::string, ResourceType> &m) +{ + std::unordered_map<ResourceType, std::string, Utils::EnumHash> res; + for (auto e : m) { + res.emplace(e.second, e.first); + } + return res; +} + +/* Internal maps */ + +static const std::unordered_map<std::string, ResourceType> + NAME_RESOURCE_TYPE_MAP{{"document", ResourceType::DOCUMENT}, + {"domain", ResourceType::DOMAIN_DESC}, + {"typesystem", ResourceType::TYPESYSTEM}, + {"attributes", ResourceType::ATTRIBUTES}, + {"stylesheet", ResourceType::STYLESHEET}, + {"script", ResourceType::SCRIPT}, + {"data", ResourceType::DATA}}; + +static const std::unordered_map<ResourceType, std::string, Utils::EnumHash> + RESOURCE_TYPE_NAME_MAP = reverseMap(NAME_RESOURCE_TYPE_MAP); + /* Class Resource */ Resource::Resource() @@ -39,6 +67,32 @@ std::unique_ptr<std::istream> Resource::stream() const return locator->stream(location); } +std::string Resource::getResourceTypeName(ResourceType resourceType) +{ + auto it = RESOURCE_TYPE_NAME_MAP.find(resourceType); + if (it != RESOURCE_TYPE_NAME_MAP.end()) { + return it->second; + } + return "unknown"; +} + +ResourceType Resource::getResourceTypeByName(const std::string &name) +{ + std::string normName = Utils::toLower(name); + auto it = NAME_RESOURCE_TYPE_MAP.find(normName); + if (it != NAME_RESOURCE_TYPE_MAP.end()) { + return it->second; + } + return ResourceType::UNKNOWN; +} + +/* Operators */ + +std::ostream &operator<<(std::ostream &os, ResourceType resourceType) +{ + return os << Resource::getResourceTypeName(resourceType); +} + /* NullResource instance */ const Resource NullResource{}; diff --git a/src/core/resource/Resource.hpp b/src/core/resource/Resource.hpp index 1934029..63ed591 100644 --- a/src/core/resource/Resource.hpp +++ b/src/core/resource/Resource.hpp @@ -30,6 +30,7 @@ #include <map> #include <memory> +#include <ostream> #include <string> namespace ousia { @@ -169,9 +170,36 @@ public: * a resource. */ const std::string &getLocation() const { return location; } + + /** + * Returns the name of the given resource type. + * + * @param resourceType is the ResourceType of which the human readable name + * should be returned. + * @return the human readable name of the ResourceType. + */ + static std::string getResourceTypeName(ResourceType resourceType); + + /** + * Returns a resourceType by its name or ResourceType::UNKNOWN if the name + * is invalid. + * + * @param name is the name of the resource type. The name is converted to + * lowercase. + */ + static ResourceType getResourceTypeByName(const std::string &name); }; /** + * Operator used for streaming the name of ResourceType instances. + * + * @param os is the output stream. + * @param resourceType is the type that should be serialized. + * @return the output stream. + */ +std::ostream& operator<<(std::ostream &os, ResourceType resourceType); + +/** * Invalid resource instance. */ extern const Resource NullResource; diff --git a/src/core/resource/ResourceManager.cpp b/src/core/resource/ResourceManager.cpp index 184a16d..03fd65b 100644 --- a/src/core/resource/ResourceManager.cpp +++ b/src/core/resource/ResourceManager.cpp @@ -25,33 +25,17 @@ #include <core/common/SourceContextReader.hpp> #include <core/common/Utils.hpp> #include <core/model/Node.hpp> -#include <core/parser/ParserContext.hpp> +#include <core/model/Project.hpp> #include <core/parser/Parser.hpp> +#include <core/parser/ParserContext.hpp> +#include <core/parser/ParserScope.hpp> #include <core/Registry.hpp> #include "ResourceManager.hpp" -#include "ResourceUtils.hpp" +#include "ResourceRequest.hpp" namespace ousia { -/* Static helper functions */ - -static void logUnsopportedType(Logger &logger, Resource &resource, - const RttiSet &supportedTypes) -{ - // Build a list containing the expected type names - std::vector<std::string> expected; - for (const Rtti *supportedType : supportedTypes) { - expected.push_back(supportedType->name); - } - - // Log the actual error message - logger.error( - std::string("Expected the file \"") + resource.getLocation() + - std::string("\" to define one of the following internal types ") + - Utils::join(expected, ", ", "{", "}")); -} - /* Class ResourceManager */ SourceId ResourceManager::allocateSourceId(const Resource &resource) @@ -86,39 +70,14 @@ void ResourceManager::purgeResource(SourceId sourceId) contextReaders.erase(sourceId); } -Rooted<Node> ResourceManager::parse(ParserContext &ctx, Resource &resource, - const std::string &mimetype, - const RttiSet &supportedTypes) +Rooted<Node> ResourceManager::parse(Registry ®istry, ParserContext &ctx, + const ResourceRequest &req, ParseMode mode) { - // 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 \"") + - resource.getLocation() + - std::string( - "\" has an unknown file extension. Explicitly " - "specify a mimetype.")); - return nullptr; - } - } - - // Fetch a parser for the mimetype - const std::pair<Parser *, RttiSet> &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 (!Rtti::setIsOneOf(parserDescr.second, supportedTypes)) { - logUnsopportedType(ctx.logger, resource, supportedTypes); + // Locate the resource relative to the old resource, abort if this did not + // work + Resource resource; + if (!req.locate(registry, ctx.getLogger(), resource, + getResource(ctx.getSourceId()))) { return nullptr; } @@ -129,16 +88,31 @@ Rooted<Node> ResourceManager::parse(ParserContext &ctx, Resource &resource, Rooted<Node> node; try { // Set the current source id in the logger instance - GuardedLogger logger(ctx.logger, SourceLocation{sourceId}); - - // Fetch the input stream and create a char reader - std::unique_ptr<std::istream> is = resource.stream(); - CharReader reader(*is, sourceId); - - // Actually parse the input stream - node = parser->parse(reader, ctx); + { + GuardedLogger logger(ctx.getLogger(), SourceLocation{sourceId}); + + // Fetch the input stream and create a char reader + std::unique_ptr<std::istream> is = resource.stream(); + CharReader reader(*is, sourceId); + + // Actually parse the input stream, distinguish the LINK and the + // INCLUDE + // mode + switch (mode) { + case ParseMode::LINK: { + ParserScope scope; // New empty parser scope instance + ParserContext childCtx = ctx.clone(scope, sourceId); + node = req.getParser()->parse(reader, childCtx); + } + case ParseMode::INCLUDE: { + ParserContext childCtx = ctx.clone(sourceId); + node = req.getParser()->parse(reader, childCtx); + } + } + } if (node == nullptr) { - throw LoggableException{"Internal error: Parser returned null."}; + throw LoggableException{"File \"" + resource.getLocation() + + "\" cannot be parsed."}; } } catch (LoggableException ex) { @@ -146,17 +120,66 @@ Rooted<Node> ResourceManager::parse(ParserContext &ctx, Resource &resource, purgeResource(sourceId); // Log the exception and return nullptr - ctx.logger.log(ex); + ctx.getLogger().log(ex); return nullptr; } - // Store the parsed node along with the sourceId - storeNode(sourceId, node); + // Store the parsed node along with the sourceId, if we are in the LINK mode + if (mode == ParseMode::LINK) { + storeNode(sourceId, node); + } // Return the parsed node return node; } +Rooted<Node> ResourceManager::link(Registry ®istry, ParserContext &ctx, + const std::string &path, + const std::string &mimetype, + const std::string &rel, + const RttiSet &supportedTypes) +{ + ResourceRequest req{path, mimetype, rel, supportedTypes}; + if (req.deduce(registry, ctx.getLogger())) { + return parse(registry, ctx, req, ParseMode::LINK); + } + return nullptr; +} + +Rooted<Node> ResourceManager::include(Registry ®istry, ParserContext &ctx, + const std::string &path, + const std::string &mimetype, + const std::string &rel, + const RttiSet &supportedTypes) +{ + ResourceRequest req{path, mimetype, rel, supportedTypes}; + if (req.deduce(registry, ctx.getLogger())) { + return parse(registry, ctx, req, ParseMode::INCLUDE); + } + return nullptr; +} + +SourceContext ResourceManager::readContext(const SourceLocation &location, + size_t maxContextLength) +{ + const Resource &resource = getResource(location.getSourceId()); + if (resource.isValid()) { + // Fetch a char reader for the resource + std::unique_ptr<std::istream> is = resource.stream(); + CharReader reader{*is, location.getSourceId()}; + + // Return the context + return contextReaders[location.getSourceId()].readContext( + reader, location, maxContextLength, resource.getLocation()); + } + return SourceContext{}; +} + +SourceContext ResourceManager::readContext(const SourceLocation &location) +{ + return readContext(location, SourceContextReader::MAX_MAX_CONTEXT_LENGTH); +} + SourceId ResourceManager::getSourceId(const std::string &location) { auto it = locations.find(location); @@ -187,7 +210,7 @@ Rooted<Node> ResourceManager::getNode(Manager &mgr, SourceId sourceId) { auto it = nodes.find(sourceId); if (it != nodes.end()) { - Managed *managed = mgr.getManaged(sourceId); + Managed *managed = mgr.getManaged(it->second); if (managed != nullptr) { return dynamic_cast<Node *>(managed); } else { @@ -206,86 +229,5 @@ Rooted<Node> ResourceManager::getNode(Manager &mgr, const Resource &resource) { return getNode(mgr, getSourceId(resource)); } - -Rooted<Node> 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> 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, resource, supportedTypes); - return nullptr; - } - - return node; -} - -Rooted<Node> 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 link(ctx, path, mimetype, rel, supportedTypes, relativeResource); -} - -SourceContext ResourceManager::readContext(const SourceLocation &location, - size_t maxContextLength) -{ - const Resource &resource = getResource(location.getSourceId()); - if (resource.isValid()) { - // Fetch a char reader for the resource - std::unique_ptr<std::istream> is = resource.stream(); - CharReader reader{*is, location.getSourceId()}; - - // Return the context - return contextReaders[location.getSourceId()].readContext( - reader, location, maxContextLength, resource.getLocation()); - } - return SourceContext{}; -} - -SourceContext ResourceManager::readContext(const SourceLocation &location) -{ - return readContext(location, SourceContextReader::MAX_MAX_CONTEXT_LENGTH); -} - } diff --git a/src/core/resource/ResourceManager.hpp b/src/core/resource/ResourceManager.hpp index 221e2cc..6cb3249 100644 --- a/src/core/resource/ResourceManager.hpp +++ b/src/core/resource/ResourceManager.hpp @@ -34,6 +34,7 @@ #include <core/common/Location.hpp> #include <core/common/Rtti.hpp> +#include <core/common/SourceContextReader.hpp> #include <core/managed/Managed.hpp> #include "Resource.hpp" @@ -41,8 +42,11 @@ namespace ousia { // Forward declarations +class Registry; class Node; +class Parser; class ParserContext; +class ResourceRequest; extern const Resource NullResource; /** @@ -51,6 +55,12 @@ extern const Resource NullResource; * and returns references for those resources that already have been parsed. */ class ResourceManager { +public: + /** + * Used internally to set the mode of the Parse function. + */ + enum class ParseMode { LINK, INCLUDE }; + private: /** * Next SourceId to be used. @@ -105,25 +115,113 @@ private: void purgeResource(SourceId sourceId); /** - * Used internally to parse the given resource. + * Used internally to parse the given resource. Can either operate in the + * "link" or the "include" mode. In the latter case the ParserScope instance + * inside the ParserContext is exchanged with an empty one. + * + * @param registry is the registry that should be used to locate the + * resource. + * @param ctx is the context that should be passed to the parser. + * @param req is a ResourceRequest instance that contains all information + * about the requested resource. + * @param mode describes whether the file should be included or linked. + * @return the parsed node or nullptr if something goes wrong. + */ + Rooted<Node> parse(Registry ®istry, ParserContext &ctx, + const ResourceRequest &req, ParseMode mode); + +public: + /** + * Resolves the reference to the file specified by the given path and -- if + * this has not already happened -- parses the file. The parser that is + * called is provided a new ParserContext instance with an empty ParserScope + * which allows the Node instance returned by the parser to be cached. Logs + * any problem in the logger instance of the given ParserContext. + * + * @param registry is the registry instance that should be used to lookup + * the parser instances and to locate the resources. + * @param ctx is the context from which the Logger instance will be looked + * up. This context instance is not directly passed to the Parser, the + * ParserScope instance is replaced with a new one. The sourceId specified + * in the context instance will be used as relative location for looking up + * the new resource. + * @param mimetype is the mimetype of the resource that should be parsed + * (may be empty, in which case the mimetype is deduced from the file + * extension) + * @param rel is a "relation string" supplied by the user which specifies + * the relationship of the specified resource. + * @param supportedTypes contains the types of the returned Node the caller + * can deal with. Note that only the types the parser claims to return are + * checked, not the actual result. + * @return the parsed node or nullptr if something goes wrong. + */ + Rooted<Node> link(Registry ®istry, ParserContext &ctx, + const std::string &path, const std::string &mimetype = "", + const std::string &rel = "", + const RttiSet &supportedTypes = RttiSet{}); + + /** + * Resolves the reference to the file specified by the given path and parses + * the file using the provided context. As the result of the "include" + * function depends on the ParserScope inside the provided ParserContext + * instance, the resource has to be parsed every time this function is + * called. This contasts the behaviour of the "link" function, which creates + * a new ParserScope and thus guarantees reproducible results. Logs any + * problem in the logger instance of the given ParserContext. * - * @param ctx is the context from the Registry and the Logger instance will - * be looked up. - * @param resource is the resource from which the input stream should be - * obtained. + * @param registry is the registry instance that should be used to lookup + * the parser instances and to locate the resources. + * @param ctx is the context from which the Logger instance will be looked + * up. The sourceId specified in the context instance will be used as + * relative location for looking up the new resource. + * @param path is the requested path of the file that should be included. * @param mimetype is the mimetype of the resource that should be parsed * (may be empty, in which case the mimetype is deduced from the file * extension) + * @param rel is a "relation string" supplied by the user which specifies + * the relationship of the specified resource. * @param supportedTypes contains the types of the returned Node the caller * can deal with. Note that only the types the parser claims to return are * checked, not the actual result. * @return the parsed node or nullptr if something goes wrong. */ - Rooted<Node> parse(ParserContext &ctx, Resource &resource, - const std::string &mimetype, - const RttiSet &supportedTypes); + Rooted<Node> include(Registry ®istry, ParserContext &ctx, + const std::string &path, + const std::string &mimetype = "", + const std::string &rel = "", + const RttiSet &supportedTypes = RttiSet{}); + + /** + * Creates and returns a SourceContext structure containing information + * about the given SourceLocation (such as line and column number). Throws + * a LoggableException if an irrecoverable error occurs while looking up the + * context (such as a no longer existing resource). + * + * @param location is the SourceLocation for which context information + * should be retrieved. This method is used by the Logger class to print + * pretty messages. + * @param maxContextLength is the maximum length in character of context + * that should be extracted. + * @return a valid SourceContext if a valid SourceLocation was given or an + * invalid SourceContext if the location is invalid. + */ + SourceContext readContext(const SourceLocation &location, + size_t maxContextLength); + /** + * Creates and returns a SourceContext structure containing information + * about the given SourceLocation (such as line and column number). Throws + * a LoggableException if an irrecoverable error occurs while looking up the + * context (such as a no longer existing resource). Does not limit the + * context length. + * + * @param location is the SourceLocation for which context information + * should be retrieved. This method is used by the Logger class to print + * pretty messages. + * @return a valid SourceContext if a valid SourceLocation was given or an + * invalid SourceContext if the location is invalid. + */ + SourceContext readContext(const SourceLocation &location); -public: /** * Returns the sourceId for the given location string. * @@ -188,63 +286,6 @@ public: * @return the Node instance corresponding to the given resource. */ Rooted<Node> getNode(Manager &mgr, const Resource &resource); - - /** - * Resolves the reference to the file specified by the given path and -- if - * this has not already happened -- parses the file. Logs any problem in - * the logger instance of the given ParserContext. - * - * @param ctx is the context from the Registry and the Logger instance will - * be looked up. - * @param path is the path to the file that should be included. - * @param mimetype is the mimetype the file was included with. If no - * mimetype is given, the path must have an extension that is known by - */ - Rooted<Node> link(ParserContext &ctx, const std::string &path, - const std::string &mimetype = "", - const std::string &rel = "", - const RttiSet &supportedTypes = RttiSet{}, - const Resource &relativeTo = NullResource); - - /** - * Resolves the reference to the file specified by the given path and -- if - * this has not already happened -- parses the file. Logs any problem in - * the logger instance of the given ParserContext. - */ - Rooted<Node> link(ParserContext &ctx, const std::string &path, - const std::string &mimetype, const std::string &rel, - const RttiSet &supportedTypes, SourceId relativeTo); - - /** - * Creates and returns a SourceContext structure containing information - * about the given SourceLocation (such as line and column number). Throws - * a LoggableException if an irrecoverable error occurs while looking up the - * context (such as a no longer existing resource). - * - * @param location is the SourceLocation for which context information - * should be retrieved. This method is used by the Logger class to print - * pretty messages. - * @param maxContextLength is the maximum length in character of context - * that should be extracted. - * @return a valid SourceContext if a valid SourceLocation was given or an - * invalid SourceContext if the location is invalid. - */ - SourceContext readContext(const SourceLocation &location, - size_t maxContextLength); - /** - * Creates and returns a SourceContext structure containing information - * about the given SourceLocation (such as line and column number). Throws - * a LoggableException if an irrecoverable error occurs while looking up the - * context (such as a no longer existing resource). Does not limit the - * context length. - * - * @param location is the SourceLocation for which context information - * should be retrieved. This method is used by the Logger class to print - * pretty messages. - * @return a valid SourceContext if a valid SourceLocation was given or an - * invalid SourceContext if the location is invalid. - */ - SourceContext readContext(const SourceLocation &location); }; } diff --git a/src/core/resource/ResourceRequest.cpp b/src/core/resource/ResourceRequest.cpp new file mode 100644 index 0000000..b047082 --- /dev/null +++ b/src/core/resource/ResourceRequest.cpp @@ -0,0 +1,238 @@ +/* + 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 <http://www.gnu.org/licenses/>. +*/ +#include <string> + +#include <core/common/Logger.hpp> +#include <core/common/Rtti.hpp> +#include <core/common/Utils.hpp> +#include <core/resource/Resource.hpp> +#include <core/resource/Resource.hpp> +#include <core/Registry.hpp> + +#include "ResourceRequest.hpp" + +namespace ousia { + +namespace RttiTypes { +extern const Rtti Document; +extern const Rtti Domain; +extern const Rtti Node; +extern const Rtti Typesystem; +} + +/** + * Map mapping from Rtti pointers to the corresponding ResourceType. + */ +static const std::unordered_map<const Rtti *, ResourceType> + RTTI_RESOURCE_TYPE_MAP{{&RttiTypes::Document, ResourceType::DOCUMENT}, + {&RttiTypes::Domain, ResourceType::DOMAIN_DESC}, + {&RttiTypes::Typesystem, ResourceType::TYPESYSTEM}}; + +/** + * Function used internally to build a set with all currently supported + * ResourceType instances. + * + * @param supportedTypes are all supported types. + * @return a set containing all ResourceTypes that can be used for these + * RTTI descriptors. + */ +static const std::unordered_set<ResourceType, Utils::EnumHash> +supportedResourceTypes(const RttiSet &supportedTypes) +{ + std::unordered_set<ResourceType, Utils::EnumHash> res; + for (const Rtti *supportedType : supportedTypes) { + auto it = RTTI_RESOURCE_TYPE_MAP.find(supportedType); + if (it != RTTI_RESOURCE_TYPE_MAP.end()) { + res.insert(it->second); + } + } + return res; +} + +/** + * Converts a set of supported RTTI descriptors to a string describing the + * corresponding ResourceTypes. + * + * @param supportedTypes are all supported types. + * @return a string containing all corresponding resource types. + */ +static std::string supportedResourceTypesString(const RttiSet &supportedTypes) +{ + return Utils::join(supportedResourceTypes(supportedTypes), ", ", "{", "}"); +} + +/** + * Tries to deduce the resource type from the given set of supported types. + * Returns ResourceType::UNKNOWN if there are ambiguities. + * + * @param supportedTypes are all supported types. + * @return the deduced ResourceType or ResourceType::UNKNOWN if there was an + * ambiguity. + */ +static ResourceType deduceResourceType(const RttiSet &supportedTypes) +{ + ResourceType resourceType = ResourceType::UNKNOWN; + for (const Rtti *supportedType : supportedTypes) { + auto it = RTTI_RESOURCE_TYPE_MAP.find(supportedType); + if (it != RTTI_RESOURCE_TYPE_MAP.end()) { + // Preven ambiguity + if (resourceType != ResourceType::UNKNOWN && + resourceType != it->second) { + resourceType = ResourceType::UNKNOWN; + break; + } + resourceType = it->second; + } + } + return resourceType; +} + +/** + * Function used to limit the supportedTypes to those that correspond to the + * ResourceType. + * + * @param resourceType is the type of the resource type that is going to be + * included. + * @param supportedTypes are all supported types. + * @return a restricted set of supportedTypes that correspond to the + * resourceType. + */ +static RttiSet limitSupportedTypes(ResourceType resourceType, + const RttiSet &supportedTypes) +{ + // Calculate the expected types + RttiSet expectedTypes; + for (auto entry : RTTI_RESOURCE_TYPE_MAP) { + if (entry.second == resourceType) { + expectedTypes.insert(entry.first); + } + } + + // Restrict the supported types to the expected types + return Rtti::setIntersection(supportedTypes, expectedTypes); +} + +/* Class ResourceRequest */ + +ResourceRequest::ResourceRequest(const std::string &path, + const std::string &mimetype, + const std::string &rel, + const RttiSet &supportedTypes) + : path(path), + mimetype(mimetype), + rel(rel), + supportedTypes(supportedTypes), + resourceType(ResourceType::UNKNOWN), + parser(nullptr) +{ +} + +bool ResourceRequest::deduce(Registry ®istry, Logger &logger) +{ + bool ok = true; + + // Try to deduce the mimetype if none was given + if (mimetype.empty()) { + mimetype = registry.getMimetypeForFilename(path); + if (mimetype.empty()) { + logger.error(std::string("Filename \"") + path + + std::string( + "\" has an unknown file extension. Explicitly " + "specify a mimetype.")); + ok = false; + } + } + + // Find a parser for the mimetype + if (!mimetype.empty()) { + auto parserDescr = registry.getParserForMimetype(mimetype); + parser = parserDescr.first; + parserTypes = parserDescr.second; + + // Make sure a valid parser was returned, and if yes, whether the + // parser is allows to run here + if (!parser) { + logger.error(std::string("Cannot parse files of type \"") + + mimetype + std::string("\"")); + ok = false; + } else if (!Rtti::setIsOneOf(parserTypes, supportedTypes)) { + logger.error(std::string("Resource of type \"") + mimetype + + std::string("\" cannot be included here!")); + ok = false; + } + } + + // Limit the supportedTypes to those returned by the parser + supportedTypes = Rtti::setIntersection(supportedTypes, parserTypes); + if (supportedTypes.empty()) { + logger.error(std::string("Cannot include or link a file of type \"") + + mimetype + std::string("\" here!")); + ok = false; + } + + // Try to deduce the ResourceType from the "rel" string + if (!rel.empty()) { + resourceType = Resource::getResourceTypeByName(rel); + if (resourceType == ResourceType::UNKNOWN) { + logger.error(std::string("Unknown relation \"") + rel + + std::string("\", expected one of ") + + supportedResourceTypesString(supportedTypes)); + ok = false; + } + } + + // Try to deduce the ResourceType from the supportedTypes + if (resourceType == ResourceType::UNKNOWN) { + resourceType = deduceResourceType(supportedTypes); + } + + // Further limit the supportedTypes to those types that correspond to the + // specified resource type. + if (resourceType != ResourceType::UNKNOWN) { + supportedTypes = limitSupportedTypes(resourceType, supportedTypes); + if (supportedTypes.empty()) { + logger.error( + std::string("File of type \"") + mimetype + + std::string("\" cannot be included with relationship ") + + Resource::getResourceTypeName(resourceType)); + ok = false; + } + } else { + // Issue a warning if the resource type is unknown + logger.warning(std::string( + "Ambiguous resource relationship, consider " + "specifying one of ") + + supportedResourceTypesString(supportedTypes) + + std::string(" as \"rel\" attribute")); + } + + return ok; +} + +bool ResourceRequest::locate(Registry ®istry, Logger &logger, + Resource &resource, + const Resource &relativeTo) const +{ + if (!registry.locateResource(resource, path, resourceType, relativeTo)) { + logger.error(std::string("File not found: ") + path); + return false; + } + return true; +} +} + diff --git a/src/core/resource/ResourceRequest.hpp b/src/core/resource/ResourceRequest.hpp new file mode 100644 index 0000000..9d5728f --- /dev/null +++ b/src/core/resource/ResourceRequest.hpp @@ -0,0 +1,197 @@ +/* + 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 <http://www.gnu.org/licenses/>. +*/ + +/** + * @file ResourceRequest.hpp + * + * Defines the ResourceRequest class used by the ResourceManager to deduce as + * much information as possible about a resource that was included by the user. + * + * @author Andreas Stöckel (astoecke@techfak.uni-bielefeld.de) + */ + +#ifndef _OUSIA_RESOURCE_REQUEST_HPP_ +#define _OUSIA_RESOURCE_REQUEST_HPP_ + +#include <string> + +#include <core/common/Rtti.hpp> +#include <core/resource/Resource.hpp> + +namespace ousia { + +// Forward declarations +class Logger; +class Parser; +class Registry; + +/** + * The ResourceRequest class contains user provided data about a Resource that + * should be opened and parsed. The ResourceRequest class can then be used to + * deduce missing information about the resource and finally to locate the + * Resource in the filesystem and to find a parser that is capable of parsing + * the Resource. + */ +class ResourceRequest { +private: + /** + * Requested path of the file that should be included. + */ + std::string path; + + /** + * Mimetype of the resource that should be parsed. + */ + std::string mimetype; + + /** + * Relation string specifing the relationship of the resource within the + * document it is included in. + */ + std::string rel; + + /** + * Specifies the types of the Node that may result from the resource once it + * has been parsed. + */ + RttiSet supportedTypes; + + /** + * Types the parser is expected to return. + */ + RttiSet parserTypes; + + /** + * ResourceType as deduced from the user provided values. + */ + ResourceType resourceType; + + /** + * Pointer at the Parser instance that may be used to parse the resource. + */ + Parser *parser; + +public: + /** + * Constructor of the ResourceRequest class. Takes the user provided data + * about the resource request. + * + * @param path is the requested path of the file that should be included. + * @param mimetype is the mimetype of the resource that should be parsed + * (may be empty, in which case the mimetype is deduced from the file + * extension) + * @param rel is a "relation string" supplied by the user which specifies + * the relationship of the specified resource within the document it is + * included in. + * @param supportedTypes specifies the types of the Node that may result + * from the resource once it has been parsed. This value is not directly + * provided by the user, but by the calling code. + */ + ResourceRequest(const std::string &path, const std::string &mimetype, + const std::string &rel, const RttiSet &supportedTypes); + + /** + * Tries to deduce all possible information and produces log messages for + * the user. + * + * @param registry from which registered parsers, mimetypes and file + * extensions are looked up. + * @param logger is the logger instance to which errors or warnings are + * logged. + * @return true if a parser has been found that could potentially be used to + * parse the file. + */ + bool deduce(Registry ®istry, Logger &logger); + + /** + * Tries to locate the specified resource. + * + * @param registry from which registered parsers, mimetypes and file + * extensions are looked up. + * @param logger is the logger instance to which errors or warnings are + * logged. + * @param resource is the Resource descriptor that should be filled with the + * actual location. + * @param relativeTo is another resource relative to which the Resource + * should be looked up. + * @return true if a resource was found, false otherwise. Equivalent to + * the value of resource.isValid(). + */ + bool locate(Registry ®istry, Logger &logger, Resource &resource, + const Resource &relativeTo = NullResource) const; + + /** + * Returns the requested path of the file that should be included. + * + * @param path given by the user (not the location of an actually found + * resource). + */ + const std::string &getPath() const { return path; } + + /** + * Returns the mimetype of the resource that should be parsed. + * + * @return the deduced mimetype. + */ + const std::string &getMimetype() const { return mimetype; } + + /** + * Returns the relation string which specifies the relationship of the + * resource within the document it is included in. + * + * @return the deduced relation string. + */ + const std::string &getRel() const { return rel; } + + /** + * Returns the types of the Node that may result from the resource once it + * has been parsed. Restricted to the types that may actually returned by + * the parser. + * + * @return the deduced supported types. + */ + const RttiSet &getSupportedTypes() const { return supportedTypes; } + + /** + * Returns the ResourceType as deduced from the user provided values. + * + * @return deduced ResourceType or ResourceType::UNKNOWN if none could be + * deduced. + */ + ResourceType getResourceType() const { return resourceType; } + + /** + * Returns the parser that was deduced according to the given resource + * descriptors. + * + * @return the pointer at the parser instance or nullptr if none was found. + */ + Parser *getParser() const { return parser; } + + /** + * Returns the types the parser may return or an empty set if no parser was + * found. + * + * @return the types the parser may return. + */ + RttiSet getParserTypes() const { return parserTypes; } +}; +} + +#endif /* _OUSIA_RESOURCE_REQUEST_HPP_ */ + diff --git a/src/core/resource/ResourceUtils.cpp b/src/core/resource/ResourceUtils.cpp deleted file mode 100644 index 7c42716..0000000 --- a/src/core/resource/ResourceUtils.cpp +++ /dev/null @@ -1,138 +0,0 @@ -/* - 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 <http://www.gnu.org/licenses/>. -*/ - -#include <core/common/Logger.hpp> -#include <core/common/Rtti.hpp> -#include <core/common/Utils.hpp> - -#include "ResourceUtils.hpp" - -namespace ousia { - -namespace RttiTypes { -extern const Rtti Document; -extern const Rtti Domain; -extern const Rtti Node; -extern const Rtti Typesystem; -} - -/** - * Map mapping from relations (the "rel" attribute in includes) to the - * corresponding ResourceType. - */ -static const std::unordered_map<std::string, ResourceType> RelResourceTypeMap{ - {"document", ResourceType::DOCUMENT}, - {"domain", ResourceType::DOMAIN_DESC}, - {"typesystem", ResourceType::TYPESYSTEM}}; - -/** - * Map mapping from relations to the corresponding Rtti descriptor. - */ -static const std::unordered_map<std::string, const Rtti *> RelRttiTypeMap{ - {"document", &RttiTypes::Document}, - {"domain", &RttiTypes::Domain}, - {"typesystem", &RttiTypes::Typesystem}}; - -/** - * Map mapping from Rtti pointers to the corresponding ResourceType. - */ -static const std::unordered_map<const Rtti *, ResourceType> RttiResourceTypeMap{ - {&RttiTypes::Document, ResourceType::DOCUMENT}, - {&RttiTypes::Domain, ResourceType::DOMAIN_DESC}, - {&RttiTypes::Typesystem, ResourceType::TYPESYSTEM}}; - -ResourceType ResourceUtils::deduceResourceType(const std::string &rel, - const RttiSet &supportedTypes, - Logger &logger) -{ - ResourceType res; - - // Try to deduce the ResourceType from the "rel" attribute - res = deduceResourceType(rel, logger); - - // If this did not work, try to deduce the ResourceType from the - // supportedTypes supplied by the Parser instance. - if (res == ResourceType::UNKNOWN) { - res = deduceResourceType(supportedTypes, logger); - } - if (res == ResourceType::UNKNOWN) { - logger.note( - "Ambigous resource type, consider specifying the \"rel\" " - "attribute"); - } - return res; -} - -ResourceType ResourceUtils::deduceResourceType(const std::string &rel, - Logger &logger) -{ - std::string s = Utils::toLower(rel); - if (!s.empty()) { - auto it = RelResourceTypeMap.find(s); - if (it != RelResourceTypeMap.end()) { - return it->second; - } else { - logger.error(std::string("Unknown relation \"") + rel + - std::string("\"")); - } - } - return ResourceType::UNKNOWN; -} - -ResourceType ResourceUtils::deduceResourceType(const RttiSet &supportedTypes, - Logger &logger) -{ - if (supportedTypes.size() == 1U) { - auto it = RttiResourceTypeMap.find(*supportedTypes.begin()); - if (it != RttiResourceTypeMap.end()) { - return it->second; - } - } - return ResourceType::UNKNOWN; -} - -const Rtti *ResourceUtils::deduceRttiType(const std::string &rel) -{ - std::string s = Utils::toLower(rel); - if (!s.empty()) { - auto it = RelRttiTypeMap.find(s); - if (it != RelRttiTypeMap.end()) { - return it->second; - } - } - return &RttiTypes::Node; -} - -RttiSet ResourceUtils::limitRttiTypes(const RttiSet &supportedTypes, - const std::string &rel) -{ - return limitRttiTypes(supportedTypes, deduceRttiType(rel)); -} - -RttiSet ResourceUtils::limitRttiTypes(const RttiSet &supportedTypes, - const Rtti *type) -{ - RttiSet res; - for (const Rtti *supportedType : supportedTypes) { - if (supportedType->isa(*type)) { - res.insert(supportedType); - } - } - return res; -} -} diff --git a/src/core/resource/ResourceUtils.hpp b/src/core/resource/ResourceUtils.hpp deleted file mode 100644 index 13f9251..0000000 --- a/src/core/resource/ResourceUtils.hpp +++ /dev/null @@ -1,128 +0,0 @@ -/* - 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 <http://www.gnu.org/licenses/>. -*/ - -/** - * @file ResourceUtils.hpp - * - * Contains the ResourceUtils class which defines a set of static utility - * functions for dealing with Resources and ResourceTypes. - * - * @author Andreas Stöckel (astoecke@techfak.uni-bielefeld.de) - */ - -#ifndef _OUSIA_RESOURCE_UTILS_HPP_ -#define _OUSIA_RESOURCE_UTILS_HPP_ - -#include <string> - -#include <core/common/Rtti.hpp> - -#include "Resource.hpp" - -namespace ousia { - -/** - * Class containing static utility functions for dealing with Resources and - * ResourceTypes. - */ -class ResourceUtils { -public: - /** - * Function used to deduce the resource type from a given "relation" string - * and a set of RTTI types into which the resource should be converted by a - * parser. - * - * @param rel is a relation string which specifies the type of the resource. - * May be empty. - * @param supportedTypes is a set of RTTI types into which the resource - * should be converted by a parser. Set may be empty. - * @param logger is the Logger instance to which errors should be logged. - * @return a ResourceType specifier. - */ - static ResourceType deduceResourceType(const std::string &rel, - const RttiSet &supportedTypes, - Logger &logger); - - /** - * Function used to deduce the resource type from a given "relation" string. - * - * @param rel is a relation string which specifies the type of the resource. - * May be empty. - * @param logger is the Logger instance to which errors should be logged - * (e.g. if the relation string is invalid). - * @return a ResourceType specifier. - */ - static ResourceType deduceResourceType(const std::string &rel, - Logger &logger); - - /** - * Function used to deduce the resource type from a set of RTTI types into - * which the resource should be converted by a parser. - * - * @param supportedTypes is a set of RTTI types into which the resource - * should be converted by a parser. Set may be empty. - * @param logger is the Logger instance to which errors should be logged. - * @return a ResourceType specifier. - */ - static ResourceType deduceResourceType(const RttiSet &supportedTypes, - Logger &logger); - - /** - * Transforms the given relation string to the corresponding RttiType. - * - * @param rel is a relation string which specifies the type of the resource. - * May be empty. - * @return a pointer at the corresponding Rtti instance or a pointer at the - * Rtti descriptor of the Node class (the most general Node type) if the - * given relation type is unknown. - */ - static const Rtti *deduceRttiType(const std::string &rel); - - /** - * Reduces the number of types supported by a parser as the type of a - * resource to the intersection of the given supported types and the RTTI - * type associated with the given relation string. - * - * @param supportedTypes is a set of RTTI types into which the resource - * should be converted by a parser. Set may be empty. - * @param rel is a relation string which specifies the type of the resource. - * @return the supported type set limited to those types that can actually - * be returned according to the given relation string. - */ - static RttiSet limitRttiTypes(const RttiSet &supportedTypes, - const std::string &rel); - - /** - * Reduces the number of types supported by a parser as the type of a - * resource to the intersection of the given supported types and the RTTI - * type associated with the given relation string. - * - * @param supportedTypes is a set of RTTI types into which the resource - * should be converted by a parser. Set may be empty. - * @param type is the type that is to be expected from the parser. - * @return the supported type set limited to those types that can actually - * be returned according to the given relation string (form an isa - * relationship with the given type). - */ - static RttiSet limitRttiTypes(const RttiSet &supportedTypes, - const Rtti *type); -}; -} - -#endif /* _OUSIA_RESOURCE_UTILS_HPP_ */ - |