PDF typed strings (#347)

Author: andiwand

src/odr/document_element.hpp

@@ -13,8 +13,6 @@ class Element;
 class TextRoot;
 class Slide;
 class Sheet;
-class SheetColumn;
-class SheetRow;
 class SheetCell;
 class Page;
 class MasterPage;

src/odr/internal/html/text_file.cpp

@@ -56,7 +56,7 @@ Html html::translate_text_file(const TextFile &text_file,
     out.write_element_begin("td");
 
     std::ostringstream ss_out;
-    util::stream::pipe_line(*in, ss_out);
+    util::stream::pipe_line(*in, ss_out, false);
     out.out() << escape_text(ss_out.str());
 
     out.write_element_end("td");

src/odr/internal/pdf/pdf_document_parser.cpp

@@ -154,7 +154,7 @@ const FileParser &DocumentParser::parser() const { return m_parser; }
 const Xref &DocumentParser::xref() const { return m_xref; }
 
 IndirectObject DocumentParser::read_object(const ObjectReference &reference) {
-  std::uint32_t position = m_xref.table[reference.first].position;
+  std::uint32_t position = m_xref.table[reference.id].position;
   in().seekg(position);
   return parser().read_indirect_object();
 }

src/odr/internal/pdf/pdf_file_parser.cpp

@@ -20,9 +20,9 @@ const ObjectParser &FileParser::parser() const { return m_parser; }
 IndirectObject FileParser::read_indirect_object() const {
   IndirectObject result;
 
-  result.reference.first = m_parser.read_unsigned_integer();
+  result.reference.id = m_parser.read_unsigned_integer();
   m_parser.skip_whitespace();
-  result.reference.second = m_parser.read_unsigned_integer();
+  result.reference.gen = m_parser.read_unsigned_integer();
   m_parser.skip_whitespace();
   if (std::string line = m_parser.read_line(); line != "obj") {
     throw std::runtime_error("expected obj");

src/odr/internal/pdf/pdf_graphics_operator.cpp

@@ -6,14 +6,29 @@
 
 namespace odr::internal::pdf {
 
+const std::string &SimpleArrayElement::as_string() const {
+  if (is_standard_string()) {
+    return as_standard_string();
+  }
+  if (is_hex_string()) {
+    return as_hex_string();
+  }
+  return as_name();
+}
+
 void SimpleArrayElement::to_stream(std::ostream &out) const {
   if (is_integer()) {
     out << as_integer();
   } else if (is_real()) {
     out << std::setprecision(4) << as_real();
-  } else if (is_string()) {
-    // TODO restore original format
-    out << as_string();
+  } else if (is_standard_string()) {
+    // TODO escape
+    out << "(" << as_standard_string() << ")";
+  } else if (is_hex_string()) {
+    // TODO hex
+    out << "<" << as_hex_string() << ">";
+  } else if (is_name()) {
+    out << "/" << as_name();
   } else {
     throw std::runtime_error("unhandled type");
   }
@@ -42,14 +57,29 @@ std::string SimpleArray::to_string() const {
   return ss.str();
 }
 
+const std::string &GraphicsArgument::as_string() const {
+  if (is_standard_string()) {
+    return as_standard_string();
+  }
+  if (is_hex_string()) {
+    return as_hex_string();
+  }
+  return as_name();
+}
+
 void GraphicsArgument::to_stream(std::ostream &out) const {
   if (is_integer()) {
     out << as_integer();
   } else if (is_real()) {
     out << std::setprecision(4) << as_real();
-  } else if (is_string()) {
-    // TODO restore original format
-    out << as_string();
+  } else if (is_standard_string()) {
+    // TODO escape
+    out << "(" << as_standard_string() << ")";
+  } else if (is_hex_string()) {
+    // TODO hex
+    out << "<" << as_hex_string() << ">";
+  } else if (is_name()) {
+    out << "/" << as_name();
   } else if (is_array()) {
     as_array().to_stream(out);
   } else {

src/odr/internal/pdf/pdf_graphics_operator.hpp

@@ -12,22 +12,34 @@ namespace odr::internal::pdf {
 
 class SimpleArrayElement {
 public:
-  using Holder = std::variant<Integer, Real, std::string>;
+  using Holder = std::variant<Integer, Real, StandardString, HexString, Name>;
 
   SimpleArrayElement(Integer integer) : m_holder{integer} {}
   SimpleArrayElement(Real real) : m_holder{real} {}
-  SimpleArrayElement(std::string string) : m_holder{std::move(string)} {}
+  SimpleArrayElement(StandardString string) : m_holder{std::move(string)} {}
+  SimpleArrayElement(HexString string) : m_holder{std::move(string)} {}
+  SimpleArrayElement(Name name) : m_holder{std::move(name)} {}
 
   Holder &holder() { return m_holder; }
   const Holder &holder() const { return m_holder; }
 
   bool is_integer() const { return is<Integer>(); }
   bool is_real() const { return is<Real>() || is_integer(); }
-  bool is_string() const { return is<std::string>(); }
+  bool is_standard_string() const { return is<StandardString>(); }
+  bool is_hex_string() const { return is<HexString>(); }
+  bool is_name() const { return is<Name>(); }
+  bool is_string() const {
+    return is_standard_string() || is_hex_string() || is_name();
+  }
 
   Integer as_integer() const { return as<Integer>(); }
   Real as_real() const { return is<Real>() ? as<Real>() : as_integer(); }
-  const std::string &as_string() const { return as<std::string>(); }
+  const std::string &as_standard_string() const {
+    return as<StandardString>().string;
+  }
+  const std::string &as_hex_string() const { return as<HexString>().string; }
+  const std::string &as_name() const { return as<Name>().string; }
+  const std::string &as_string() const;
 
   void to_stream(std::ostream &) const;
   std::string to_string() const;
@@ -70,24 +82,37 @@ class SimpleArray {
 
 class GraphicsArgument {
 public:
-  using Holder = std::variant<Integer, Real, std::string, SimpleArray>;
+  using Holder =
+      std::variant<Integer, Real, StandardString, HexString, Name, SimpleArray>;
 
   GraphicsArgument(Integer integer) : m_holder{integer} {}
   GraphicsArgument(Real real) : m_holder{real} {}
-  GraphicsArgument(std::string string) : m_holder{std::move(string)} {}
+  GraphicsArgument(StandardString string) : m_holder{std::move(string)} {}
+  GraphicsArgument(HexString string) : m_holder{std::move(string)} {}
+  GraphicsArgument(Name name) : m_holder{std::move(name)} {}
   GraphicsArgument(SimpleArray array) : m_holder(std::move(array)) {}
 
   Holder &holder() { return m_holder; }
   const Holder &holder() const { return m_holder; }
 
   bool is_integer() const { return is<Integer>(); }
   bool is_real() const { return is<Real>() || is_integer(); }
-  bool is_string() const { return is<std::string>(); }
+  bool is_standard_string() const { return is<StandardString>(); }
+  bool is_hex_string() const { return is<HexString>(); }
+  bool is_name() const { return is<Name>(); }
+  bool is_string() const {
+    return is_standard_string() || is_hex_string() || is_name();
+  }
   bool is_array() const { return is<SimpleArray>(); }
 
   Integer as_integer() const { return as<Integer>(); }
   Real as_real() const { return is<Real>() ? as<Real>() : as_integer(); }
-  const std::string &as_string() const { return as<std::string>(); }
+  const std::string &as_standard_string() const {
+    return as<StandardString>().string;
+  }
+  const std::string &as_hex_string() const { return as<HexString>().string; }
+  const std::string &as_name() const { return as<Name>().string; }
+  const std::string &as_string() const;
   const SimpleArray &as_array() const { return as<SimpleArray>(); }
 
   void to_stream(std::ostream &) const;

src/odr/internal/pdf/pdf_graphics_operator_parser.cpp

@@ -147,7 +147,8 @@ SimpleArrayElement GraphicsOperatorParser::read_array_element() const {
     return m_parser.read_name();
   }
   if (m_parser.peek_string()) {
-    return m_parser.read_string();
+    return std::visit([](auto s) { return SimpleArrayElement(std::move(s)); },
+                      m_parser.read_string());
   }
 
   throw std::runtime_error("unknown element");
@@ -183,7 +184,8 @@ GraphicsOperator GraphicsOperatorParser::read_operator() const {
     } else if (m_parser.peek_name()) {
       result.arguments.push_back(m_parser.read_name());
     } else if (m_parser.peek_string()) {
-      result.arguments.push_back(m_parser.read_string());
+      std::visit([&](auto s) { result.arguments.push_back(std::move(s)); },
+                 m_parser.read_string());
     } else if (m_parser.peek_array()) {
       result.arguments.push_back(read_array());
     } else {

src/odr/internal/pdf/pdf_object.cpp

@@ -11,6 +11,16 @@ Object::Object(Array array) : m_holder{std::move(array)} {}
 
 Object::Object(Dictionary dictionary) : m_holder{std::move(dictionary)} {}
 
+const std::string &Object::as_string() const {
+  if (is_standard_string()) {
+    return as_standard_string();
+  }
+  if (is_hex_string()) {
+    return as_hex_string();
+  }
+  return as_name();
+}
+
 void Object::to_stream(std::ostream &out) const {
   if (is_null()) {
     out << "null";
@@ -24,15 +34,20 @@ void Object::to_stream(std::ostream &out) const {
     out << as_integer();
   } else if (is_real()) {
     out << std::setprecision(4) << as_real();
-  } else if (is_string()) {
-    // TODO restore original format
-    out << as_string();
+  } else if (is_standard_string()) {
+    // TODO escape
+    out << "(" << as_standard_string() << ")";
+  } else if (is_hex_string()) {
+    // TODO hex
+    out << "<" << as_hex_string() << ">";
+  } else if (is_name()) {
+    out << "/" << as_name();
   } else if (is_array()) {
     as_array().to_stream(out);
   } else if (is_dictionary()) {
     as_dictionary().to_stream(out);
   } else if (is_reference()) {
-    out << as_reference().first << " " << as_reference().second << " R";
+    out << as_reference().id << " " << as_reference().gen << " R";
   } else {
     throw std::runtime_error("unhandled type");
   }

src/odr/internal/pdf/pdf_object.hpp

@@ -14,11 +14,33 @@ namespace odr::internal::pdf {
 using UnsignedInteger = std::uint64_t;
 using Integer = std::int64_t;
 using Real = double;
-using IntegerOrReal = std::variant<Integer, Real>;
-using String = std::string;
-using Name = std::string;
 using Boolean = bool;
-using ObjectReference = std::pair<UnsignedInteger, UnsignedInteger>;
+
+struct StandardString {
+  std::string string;
+
+  StandardString(std::string _string) : string{std::move(_string)} {}
+};
+
+struct HexString {
+  std::string string;
+
+  HexString(std::string _string) : string{std::move(_string)} {}
+};
+
+struct Name {
+  std::string string;
+
+  Name(std::string _string) : string{std::move(_string)} {}
+};
+
+struct ObjectReference {
+  std::uint64_t id{};
+  std::uint64_t gen{};
+
+  ObjectReference() = default;
+  ObjectReference(std::uint64_t _id, std::uint64_t _gen) : id{_id}, gen{_gen} {}
+};
 
 class Array;
 class Dictionary;
@@ -31,7 +53,9 @@ class Object {
   Object(Boolean boolean) : m_holder{boolean} {}
   Object(Integer integer) : m_holder{integer} {}
   Object(Real real) : m_holder{real} {}
-  Object(std::string string) : m_holder{std::move(string)} {}
+  Object(StandardString string) : m_holder{std::move(string)} {}
+  Object(HexString string) : m_holder{std::move(string)} {}
+  Object(Name name) : m_holder{std::move(name)} {}
   Object(Array);
   Object(Dictionary);
   Object(ObjectReference reference) : m_holder{std::move(reference)} {}
@@ -43,15 +67,27 @@ class Object {
   bool is_bool() const { return is<Boolean>(); }
   bool is_integer() const { return is<Integer>(); }
   bool is_real() const { return is<Real>() || is_integer(); }
-  bool is_string() const { return is<std::string>(); }
+  bool is_standard_string() const { return is<StandardString>(); }
+  bool is_hex_string() const { return is<HexString>(); }
+  bool is_name() const { return is<Name>(); }
+  bool is_string() const {
+    return is_standard_string() || is_hex_string() || is_name();
+  }
   bool is_array() const { return is<Array>(); }
   bool is_dictionary() const { return is<Dictionary>(); }
   bool is_reference() const { return is<ObjectReference>(); }
 
   Boolean as_bool() const { return as<Boolean>(); }
   Integer as_integer() const { return as<Integer>(); }
   Real as_real() const { return is<Real>() ? as<Real>() : as_integer(); }
-  const std::string &as_string() const { return as<const std::string &>(); }
+  const std::string &as_standard_string() const {
+    return as<const StandardString &>().string;
+  }
+  const std::string &as_hex_string() const {
+    return as<const HexString &>().string;
+  }
+  const std::string &as_name() const { return as<const Name &>().string; }
+  const std::string &as_string() const;
   const Array &as_array() const { return as<const Array &>(); }
   const Dictionary &as_dictionary() const { return as<const Dictionary &>(); }
   const ObjectReference &as_reference() const {
@@ -100,7 +136,7 @@ class Array {
 
 class Dictionary {
 public:
-  using Holder = std::map<Name, Object>;
+  using Holder = std::map<std::string, Object>;
 
   Dictionary() = default;
   explicit Dictionary(Holder holder) : m_holder{std::move(holder)} {}
@@ -112,9 +148,11 @@ class Dictionary {
   Holder::const_iterator begin() const { return std::begin(m_holder); }
   Holder::const_iterator end() const { return std::end(m_holder); }
 
-  const Object &operator[](const Name &name) const { return m_holder.at(name); }
+  const Object &operator[](const std::string &name) const {
+    return m_holder.at(name);
+  }
 
-  bool has_key(const Name &name) const {
+  bool has_key(const std::string &name) const {
     return m_holder.find(name) != std::end(m_holder);
   }