From edc7d6cd129e4e9dcbe3e2a33a7a31dcd4eaf998 Mon Sep 17 00:00:00 2001 From: Andreas Stöckel Date: Fri, 23 Jan 2015 00:33:47 +0100 Subject: Added ResourceUtils class containing helper functions for deducing resource types. --- src/core/resource/ResourceUtils.cpp | 137 ++++++++++++++++++++++++++++++++++++ src/core/resource/ResourceUtils.hpp | 130 ++++++++++++++++++++++++++++++++++ 2 files changed, 267 insertions(+) create mode 100644 src/core/resource/ResourceUtils.cpp create mode 100644 src/core/resource/ResourceUtils.hpp (limited to 'src') diff --git a/src/core/resource/ResourceUtils.cpp b/src/core/resource/ResourceUtils.cpp new file mode 100644 index 0000000..26faaad --- /dev/null +++ b/src/core/resource/ResourceUtils.cpp @@ -0,0 +1,137 @@ +/* + 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 "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 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 RelRttiTypeMap{ + {"document", &RttiTypes::DOCUMENT}, + {"domain", &RttiTypes::DOMAIN}, + {"typesystem", &RttiTypes::TYPESYSTEM}}; + +/** + * Map mapping from Rtti pointers to the corresponding ResourceType. + */ +static const std::unordered_map 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::toLowercase(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[0]); + if (it != RelResourceTypeMap.end()) { + return it->second; + } + } + return ResourceType::UNKNOWN; +} + +const Rtti *ResourceUtils::deduceRttiType(const std::string &rel) +{ + std::string s = Utils::toLowercase(rel); + if (!s.empty()) { + auto it = RelRttiTypeMap.find(s); + if (it != RelRttiTypeMap.end()) { + return it->second; + } + } + return &ResourceType::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 new file mode 100644 index 0000000..8796e06 --- /dev/null +++ b/src/core/resource/ResourceUtils.hpp @@ -0,0 +1,130 @@ +/* + 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 . +*/ + +/** + * @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 + +#include "Resource.hpp" + +namespace ousia { + +// Forward declarations +class Rtti; +class RttiSet; + +/** + * 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_ */ + -- cgit v1.2.3