Implement LiteralOrIri

src/parser/CMakeLists.txt

@@ -21,6 +21,14 @@ add_library(parser
         SelectClause.cpp
         GraphPatternOperation.cpp
         # The `Variable.cpp` from the subdirectory is linked here because otherwise we get linking errors.
-        GraphPattern.cpp data/VariableToColumnMapPrinters.cpp)
+        GraphPattern.cpp data/VariableToColumnMapPrinters.cpp
+        LiteralType.h
+        IriType.h
+        IriType.cpp
+        LiteralType.cpp
+        LiteralOrIriType.cpp
+        LiteralOrIriType.h
+        NormalizedString.cpp
+        NormalizedString.h)
 qlever_target_link_libraries(parser sparqlParser parserData sparqlExpressions rdfEscaping re2::re2 util engine)
 

src/parser/IriType.cpp

@@ -0,0 +1,11 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#include "IriType.h"
+
+#include <utility>
+
+IriType::IriType(NormalizedString iri) { this->iri = std::move(iri); }
+
+NormalizedStringView IriType::getIri() const { return this->iri; }

src/parser/IriType.h

@@ -0,0 +1,22 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#pragma once
+
+#include <string>
+
+#include "NormalizedString.h"
+
+class IriType {
+ private:
+  // Stores the string value of the IRI
+  NormalizedString iri;
+
+ public:
+  // Created a new iri object
+  explicit IriType(NormalizedString iri);
+
+  // Returns the string value of the iri object
+  [[nodiscard]] NormalizedStringView getIri() const;
+};

src/parser/LiteralOrIriType.cpp

@@ -0,0 +1,64 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#include "LiteralOrIriType.h"
+
+LiteralOrIriType::LiteralOrIriType(IriType data) : data(data) {}
+LiteralOrIriType::LiteralOrIriType(LiteralType data) : data(data) {}
+
+bool LiteralOrIriType::isIri() const {
+  return std::holds_alternative<IriType>(data);
+}
+
+IriType& LiteralOrIriType::getIriTypeObject() {
+  if (!isIri()) {
+    AD_THROW(
+        "LiteralOrIriType object does not contain an IriType object and thus "
+        "cannot return it");
+  }
+  return std::get<IriType>(data);
+}
+
+NormalizedStringView LiteralOrIriType::getIriString() {
+  IriType& iriType = getIriTypeObject();
+  return iriType.getIri();
+}
+
+bool LiteralOrIriType::isLiteral() const {
+  return std::holds_alternative<LiteralType>(data);
+}
+
+LiteralType& LiteralOrIriType::getLiteralTypeObject() {
+  if (!isLiteral()) {
+    AD_THROW(
+        "LiteralOrIriType object does not contain an LiteralType object and "
+        "thus cannot return it");
+  }
+  return std::get<LiteralType>(data);
+}
+
+bool LiteralOrIriType::hasLanguageTag() {
+  LiteralType& literal = getLiteralTypeObject();
+  return literal.hasLanguageTag();
+}
+
+bool LiteralOrIriType::hasDatatype() {
+  LiteralType& literal = getLiteralTypeObject();
+  return literal.hasDatatype();
+}
+
+NormalizedStringView LiteralOrIriType::getLiteralContent() {
+  LiteralType& literal = getLiteralTypeObject();
+  return literal.getContent();
+}
+
+NormalizedStringView LiteralOrIriType::getLanguageTag() {
+  LiteralType& literal = getLiteralTypeObject();
+  return literal.getLanguageTag();
+}
+
+NormalizedStringView LiteralOrIriType::getDatatype() {
+  LiteralType& literal = getLiteralTypeObject();
+  return literal.getDatatype();
+}

src/parser/LiteralOrIriType.h

@@ -0,0 +1,50 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#pragma once
+
+#include "IriType.h"
+#include "LiteralType.h"
+
+class LiteralOrIriType {
+ private:
+  using LiteralOrIriVariant = std::variant<LiteralType, IriType>;
+  LiteralOrIriVariant data;
+
+  // Returns contained IriType object if available, throws exception otherwise
+  IriType& getIriTypeObject();
+  // Returns contained LiteralType object if available, throws exception
+  // otherwise
+  LiteralType& getLiteralTypeObject();
+
+ public:
+  // Creates a new LiteralOrIriType based on a LiteralType object
+  explicit LiteralOrIriType(LiteralType data);
+  // Creates a new LiteralOrIriType based on a IriType object
+  explicit LiteralOrIriType(IriType data);
+
+  // Returns true, if object contains an IriType object
+  [[nodiscard]] bool isIri() const;
+  // Returns iri string of contained IriType object if available, throws
+  // exception otherwise
+  NormalizedStringView getIriString();
+
+  // Returns true, if object contains an LiteralType object
+  [[nodiscard]] bool isLiteral() const;
+  // Returns true if contained LiteralType object has a language tag, throws
+  // exception if no LiteralType object is contained
+  bool hasLanguageTag();
+  // Returns true if contained LiteralType object has a datatype, throws
+  // exception if no LiteralType object is contained
+  bool hasDatatype();
+  // Returns content of contained LiteralType as string, throws exception if no
+  // LiteralType object is contained
+  NormalizedStringView getLiteralContent();
+  // Returns the language tag of the contained LiteralType, throws exception if
+  // no LiteralType object is contained or object has no language tag
+  NormalizedStringView getLanguageTag();
+  // Returns the datatype of the contained LiteralType, throws exception if no
+  // LiteralType object is contained or object has no datatype
+  NormalizedStringView getDatatype();
+};

src/parser/LiteralType.cpp

@@ -0,0 +1,44 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#include "LiteralType.h"
+
+#include <utility>
+
+LiteralType::LiteralType(NormalizedString content) {
+  this->content = std::move(content);
+  this->descriptorType = LiteralDescriptor::NONE;
+}
+
+LiteralType::LiteralType(NormalizedString content,
+                         NormalizedString datatypeOrLanguageTag,
+                         LiteralDescriptor type) {
+  this->content = std::move(content);
+  this->descriptorType = type;
+  this->descriptorValue = std::move(datatypeOrLanguageTag);
+}
+
+bool LiteralType::hasLanguageTag() const {
+  return this->descriptorType == LiteralDescriptor::LANGUAGE_TAG;
+}
+
+bool LiteralType::hasDatatype() const {
+  return this->descriptorType == LiteralDescriptor::DATATYPE;
+}
+
+NormalizedStringView LiteralType::getContent() const { return this->content; }
+
+NormalizedStringView LiteralType::getDatatype() const {
+  if (!hasDatatype()) {
+    AD_THROW("The literal does not have an explicit datatype.");
+  }
+  return this->descriptorValue;
+}
+
+NormalizedStringView LiteralType::getLanguageTag() const {
+  if (!hasLanguageTag()) {
+    AD_THROW("The literal does not have an explicit language tag.");
+  }
+  return this->descriptorValue;
+}

src/parser/LiteralType.h

@@ -0,0 +1,45 @@
+// Copyright 2023, University of Freiburg,
+//                 Chair of Algorithms and Data Structures.
+// Author: Benedikt Maria Beckermann <[email protected]>
+
+#pragma once
+
+#include "NormalizedString.h"
+
+enum LiteralDescriptor { NONE, LANGUAGE_TAG, DATATYPE };
+
+class LiteralType {
+ private:
+  // Stores the string value of the literal
+  NormalizedString content;
+  // Stores the optional language tag or the optional datatype if applicable
+  NormalizedString descriptorValue;
+  // Stores information if the literal has a language tag, a datatype, or non of
+  // these two assigned to it
+  LiteralDescriptor descriptorType;
+
+ public:
+  // Creates a new literal without any descriptor
+  LiteralType(NormalizedString content);
+
+  // Created a new literal with the given descriptor
+  LiteralType(NormalizedString content, NormalizedString datatypeOrLanguageTag,
+              LiteralDescriptor type);
+
+  // Returns true if the literal has an assigned language tag
+  bool hasLanguageTag() const;
+
+  // Returns true if the literal has an assigned datatype
+  bool hasDatatype() const;
+
+  // Returns the value of the literal, without any datatype or language tag
+  NormalizedStringView getContent() const;
+
+  // Returns the language tag of the literal if available.
+  // Throws an exception if the literal has no language tag.
+  NormalizedStringView getLanguageTag() const;
+
+  // Returns the datatype of the literal if available.
+  // Throws an exception if the literal has no datatype.
+  NormalizedStringView getDatatype() const;
+};

src/parser/NormalizedString.cpp

@@ -0,0 +1,32 @@
+//
+// Created by beckermann on 1/19/24.
+//
+
+#include "NormalizedString.h"
+
+#include <iostream>
+
+std::ostream& operator<<(std::ostream& str, NormalizedChar c) {
+  str << c.c_;
+  return str;
+}
+
+NormalizedString fromStringUnsafe(std::string_view input) {
+  NormalizedString normalizedString;
+  normalizedString.resize(input.size());
+
+  std::transform(input.begin(), input.end(), normalizedString.begin(),
+                 [](char c) { return NormalizedChar{c}; });
+
+  return normalizedString;
+}
+
+NormalizedString normalizeFromLiteralContent(std::string_view literal) {
+  // TODO remove and replace invalid characters
+  return fromStringUnsafe(literal);
+}
+
+std::string_view asStringView(NormalizedStringView normalizedStringView) {
+  return {reinterpret_cast<const char*>(normalizedStringView.data()),
+          normalizedStringView.size()};
+}

src/parser/NormalizedString.h

@@ -0,0 +1,27 @@
+//
+// Created by beckermann on 1/19/24.
+//
+
+#pragma once
+
+#include <string>
+#include <string_view>
+
+struct NormalizedChar {
+  char c_;
+};
+
+using NormalizedStringView = std::basic_string_view<NormalizedChar>;
+using NormalizedString = std::basic_string<NormalizedChar>;
+
+// Creates a new NormalizedString object by just copying the contents of the
+// input.
+//  Warning: This function should only be used for testing as is to be removed
+//           once the normalizeFromLiteralContent function is implemented
+NormalizedString fromStringUnsafe(std::string_view input);
+
+// Normalizes the given literal and returns is as a new NormalizedString object
+NormalizedString normalizeFromLiteralContent(std::string_view literal);
+
+// Returns the given NormalizedStringView as a string_view.
+std::string_view asStringView(NormalizedStringView normalizedStringView);

test/parser/CMakeLists.txt

@@ -1 +1,2 @@
 addLinkAndDiscoverTest(ParallelBufferTest parser)
+addLinkAndDiscoverTest(LiteralOrIriTypeTest)