v0.2.49..v0.2.50 changeset FormatsDisplayer.cpp

diff --git a/hoot-core/src/main/cpp/hoot/core/info/FormatsDisplayer.cpp b/hoot-core/src/main/cpp/hoot/core/info/FormatsDisplayer.cpp
index 779d5e1..2b18062 100644
--- a/hoot-core/src/main/cpp/hoot/core/info/FormatsDisplayer.cpp
+++ b/hoot-core/src/main/cpp/hoot/core/info/FormatsDisplayer.cpp
@@ -31,10 +31,11 @@
 #include <hoot/core/util/Log.h>
 #include <hoot/core/util/Factory.h>
 #include <hoot/core/io/OgrUtilities.h>
-#include <hoot/core/io/OsmMapReader.h>
-#include <hoot/core/io/OsmMapWriter.h>
 #include <hoot/core/util/Boundable.h>
 #include <hoot/core/io/OsmMapReaderFactory.h>
+#include <hoot/core/io/OsmMapWriterFactory.h>
+#include <hoot/core/io/PartialOsmMapReader.h>
+#include <hoot/core/io/PartialOsmMapWriter.h>
 
 // Qt
 #include <QTextStream>
@@ -42,18 +43,35 @@
 namespace hoot
 {
 
-QString FormatsDisplayer::display(const bool displayInputs, const bool displayOutputs,
-                                  const bool displayInputsSupportingBounds)
+QString FormatsDisplayer::display(
+  const bool displayInputs, const bool displayInputsSupportingStreaming,
+  const bool displayInputsSupportingBounds, const bool displayOutputs,
+  const bool displayOutputsSupportingStreaming, const bool displayOgrOnly)
 {
   DisableLog dl;
 
   QString buffer;
   QTextStream ts(&buffer);
   ts.setCodec("UTF-8");
+
   if (displayInputs)
   {
     ts << "Input formats:" << endl << endl;
-    ts << _getFormatsString<OsmMapReader>(OsmMapReader::className()) << endl;
+    ts << _getFormatsString<OsmMapReader>(
+            OsmMapReader::className(), QStringList(), displayOgrOnly, true)
+       << endl;
+  }
+
+  if (displayInputsSupportingStreaming)
+  {
+    ts << "Input formats supporting streaming:" << endl << endl;
+    ts << _getInputFormatsSupportingStreamingString(displayOgrOnly) << endl;
+  }
+
+  if (displayInputsSupportingBounds)
+  {
+    ts << "Input formats supporting bounded reading:" << endl << endl;
+    ts << _getFormatsSupportingBoundsString(displayOgrOnly) << endl;
   }
 
   if (displayOutputs)
@@ -65,14 +83,15 @@ QString FormatsDisplayer::display(const bool displayInputs, const bool displayOu
     // OsmMapReader/OsmMapwriter with the supportedFormats method to make this better.
     formatsList.append(".osc");
     formatsList.append(".osc.sql");
-    ts << _getFormatsString<OsmMapWriter>(OsmMapWriter::className(), formatsList) << endl;
+    ts << _getFormatsString<OsmMapWriter>(
+            OsmMapWriter::className(), formatsList, displayOgrOnly, false)
+       << endl;
   }
 
-  if (displayInputsSupportingBounds)
+  if (displayOutputsSupportingStreaming)
   {
-    ts << "Input formats supporting bounded reading:" << endl << endl;
-
-    ts << _getFormatsSupportingBoundsString() << endl;
+    ts << "Output formats supporting streaming:" << endl << endl;
+    ts << _getOutputFormatsSupportingStreamingString(displayOgrOnly) << endl;
   }
 
   return ts.readAll();
@@ -80,33 +99,41 @@ QString FormatsDisplayer::display(const bool displayInputs, const bool displayOu
 
 template<typename IoClass>
 QString FormatsDisplayer::_getFormatsString(
-  const std::string& className, const QStringList extraFormats)
+  const std::string& className, const QStringList extraFormats, const bool ogrOnly,
+  const bool ogrReadOnly)
 {
-  return _getPrintableString(_getFormats<IoClass>(className, extraFormats));
+  return _getPrintableString(_getFormats<IoClass>(className, extraFormats, ogrOnly, ogrReadOnly));
 }
 
 template<typename IoClass>
 QStringList FormatsDisplayer::_getFormats(
-  const std::string& className, const QStringList extraFormats)
+  const std::string& className, const QStringList extraFormats, const bool ogrOnly,
+  const bool ogrReadOnly)
 {
-  std::vector<std::string> readerNames =
-    Factory::getInstance().getObjectNamesByBase(className);
   QSet<QString> formats;
-  for (size_t i = 0; i < readerNames.size(); i++)
+
+  if (!ogrOnly)
   {
-    std::shared_ptr<IoClass> ioClass(
-      Factory::getInstance().constructObject<IoClass>(readerNames[i]));
-    const QString supportedFormats = ioClass->supportedFormats();
-    if (!supportedFormats.isEmpty())
+    std::vector<std::string> classNames =
+      Factory::getInstance().getObjectNamesByBase(className);
+    for (size_t i = 0; i < classNames.size(); i++)
     {
-      QStringList supportedFormatsList = supportedFormats.split(";");
-      for (int j = 0; j < supportedFormatsList.size(); j++)
+      std::shared_ptr<IoClass> ioClass(
+        Factory::getInstance().constructObject<IoClass>(classNames[i]));
+      const QString supportedFormats = ioClass->supportedFormats();
+      if (!supportedFormats.isEmpty())
       {
-        formats.insert(supportedFormatsList.at(j));
+        QStringList supportedFormatsList = supportedFormats.split(";");
+        for (int j = 0; j < supportedFormatsList.size(); j++)
+        {
+          formats.insert(supportedFormatsList.at(j));
+        }
       }
     }
   }
-  formats += OgrUtilities::getInstance().getSupportedFormats(true);
+
+  formats += OgrUtilities::getInstance().getSupportedFormats(ogrReadOnly);
+
   QStringList formatsList = formats.toList();
   formatsList.append(extraFormats);
   formatsList.sort();
@@ -124,20 +151,21 @@ QString FormatsDisplayer::_getPrintableString(const QStringList& items)
   return ts.readAll();
 }
 
-QString FormatsDisplayer::_getFormatsSupportingBoundsString()
+QString FormatsDisplayer::_getFormatsSupportingBoundsString(const bool ogrOnly)
 {
-  const QStringList formats = _getFormats<OsmMapReader>(OsmMapReader::className());
+  const QStringList formats =
+    _getFormats<OsmMapReader>(OsmMapReader::className(), QStringList(), ogrOnly, true);
   LOG_VART(formats);
   QStringList boundableFormats;
   for (int i = 0; i < formats.size(); i++)
   {
     QString format = formats[i];
     QString formatTemp = format;
-    if (formatTemp.startsWith("hootapidb://"))
+    if (formatTemp.startsWith(MetadataTags::HootApiDbScheme() + "://"))
     {
       formatTemp += "myhost:5432/mydb/mylayer";
     }
-    else if (formatTemp.startsWith("osmapidb://"))
+    else if (formatTemp.startsWith(MetadataTags::OsmApiDbScheme() + "://"))
     {
       formatTemp += "myhost:5432/osmapi_test";
     }
@@ -159,4 +187,80 @@ QString FormatsDisplayer::_getFormatsSupportingBoundsString()
   return _getPrintableString(boundableFormats);
 }
 
+// TODO: consolidate these two streaming supported methods
+
+QString FormatsDisplayer::_getInputFormatsSupportingStreamingString(const bool ogrOnly)
+{
+  const QStringList formats =
+    _getFormats<OsmMapReader>(OsmMapReader::className(), QStringList(), ogrOnly, true);
+  LOG_VART(formats);
+  QStringList streamableFormats;
+  for (int i = 0; i < formats.size(); i++)
+  {
+    QString format = formats[i];
+    QString formatTemp = format;
+    if (formatTemp.startsWith(MetadataTags::HootApiDbScheme() + "://"))
+    {
+      formatTemp += "myhost:5432/mydb/mylayer";
+    }
+    else if (formatTemp.startsWith(MetadataTags::OsmApiDbScheme() + "://"))
+    {
+      formatTemp += "myhost:5432/osmapi_test";
+    }
+    const QString supportedReaderName = OsmMapReaderFactory::getReaderName(formatTemp);
+    LOG_VART(supportedReaderName);
+    if (!supportedReaderName.trimmed().isEmpty())
+    {
+      std::shared_ptr<OsmMapReader> reader(
+        Factory::getInstance().constructObject<OsmMapReader>(supportedReaderName));
+      LOG_VART(reader.get());
+      std::shared_ptr<PartialOsmMapReader> partial =
+        std::dynamic_pointer_cast<PartialOsmMapReader>(reader);
+      LOG_VART(partial.get());
+      if (partial)
+      {
+        streamableFormats.append(format);
+      }
+    }
+  }
+  return _getPrintableString(streamableFormats);
+}
+
+QString FormatsDisplayer::_getOutputFormatsSupportingStreamingString(const bool ogrOnly)
+{
+  const QStringList formats =
+    _getFormats<OsmMapWriter>(OsmMapWriter::className(), QStringList(), ogrOnly, false);
+  LOG_VART(formats);
+  QStringList streamableFormats;
+  for (int i = 0; i < formats.size(); i++)
+  {
+    QString format = formats[i];
+    QString formatTemp = format;
+    if (formatTemp.startsWith(MetadataTags::HootApiDbScheme() + "://"))
+    {
+      formatTemp += "myhost:5432/mydb/mylayer";
+    }
+    else if (formatTemp.startsWith(MetadataTags::OsmApiDbScheme() + "://"))
+    {
+      formatTemp += "myhost:5432/osmapi_test";
+    }
+    const QString supportedWriterName = OsmMapWriterFactory::getWriterName(formatTemp);
+    LOG_VART(supportedWriterName);
+    if (!supportedWriterName.trimmed().isEmpty())
+    {
+      std::shared_ptr<OsmMapWriter> writer(
+        Factory::getInstance().constructObject<OsmMapWriter>(supportedWriterName));
+      LOG_VART(writer.get());
+      std::shared_ptr<PartialOsmMapWriter> partial =
+        std::dynamic_pointer_cast<PartialOsmMapWriter>(writer);
+      LOG_VART(partial.get());
+      if (partial)
+      {
+        streamableFormats.append(format);
+      }
+    }
+  }
+  return _getPrintableString(streamableFormats);
+}
+
 }