feat: Add acyclic and tred support

Refactor graphviz to common up buffer usage
Fixed typos in javadoc
Added some simple tests for async and tred
Fixed error reporting for unflatten

Fixes #210

Signed-off-by: Gordon Smith <[email protected]>

Author: GordonSmith

package.json

@@ -172,4 +172,4 @@
     "url": "https://github.com/hpcc-systems/hpcc-js-wasm/issues"
   },
   "homepage": "https://hpcc-systems.github.io/hpcc-js-wasm/"
-}
+}

src-cpp/graphviz/CMakeLists.txt

@@ -32,7 +32,10 @@ set_property(SOURCE main.cpp APPEND PROPERTY OBJECT_DEPENDS ${CMAKE_CURRENT_BINA
 #  ---  ---  ---
 
 set(SRCS
+    main.hpp
     main.cpp
+    util.hpp
+    util.cpp
 )
 
 include_directories(

src-cpp/graphviz/main.cpp

@@ -67,6 +67,11 @@ Graphviz::Graphviz(int yInvert, int nop)
 {
     Y_invert = yInvert > 0 ? yInvert : origYInvert;
     Nop = nop > 0 ? nop : origNop;
+
+    lastErrorStr[0] = '\0';
+    agseterr(AGERR);
+    agseterrf(vizErrorf);
+    agreadline(1);
 }
 
 Graphviz::~Graphviz()
@@ -86,127 +91,84 @@ void Graphviz::createFile(const char *path, const char *data)
         path, data);
 }
 
-const char *Graphviz::lastResult()
-{
-    return m_result.c_str();
-}
-
 const char *Graphviz::layout(const char *src, const char *format, const char *engine)
 {
-    lastErrorStr[0] = '\0';
-    m_result = "";
-
-    // const auto demand_loading = false;
-    // auto gvc = std::make_shared<GVC::GVContext>(lt_preloaded_symbols, demand_loading);
-    // auto g = std::make_shared<CGraph::AGraph>(dot);
-    // const auto layout = GVC::GVLayout(gvc, g, engine);
-    // const auto result = layout.render(format);
-    // m_result = result.string_view();
-
-    // return m_result.c_str();
+    layout_result = "";
 
     GVC_t *gvc = gvContextPlugins(lt_preloaded_symbols, true);
 
-    agseterr(AGERR);
-    agseterrf(vizErrorf);
-
-    agreadline(1);
-
-    Agraph_t *graph;
-    char *data = NULL;
-    unsigned int length;
-    while ((graph = agmemread(src)))
+    Agraph_t *graph = agmemread(src);
+    if (graph)
     {
-        if (data == NULL)
-        {
-            gvLayout(gvc, graph, engine);
-            gvRenderData(gvc, graph, format, &data, &length);
-            gvFreeLayout(gvc, graph);
-        }
-
+        char *data = NULL;
+        unsigned int length;
+
+        gvLayout(gvc, graph, engine);
+        gvRenderData(gvc, graph, format, &data, &length);
+        layout_result = data;
+        gvFreeRenderData(data);
+        gvFreeLayout(gvc, graph);
         agclose(graph);
-
-        src = "";
     }
-    m_result = data;
-    gvFreeRenderData(data);
 
     gvFinalize(gvc);
     gvFreeContext(gvc);
 
-    return m_result.c_str();
+    return layout_result;
 }
 
 bool Graphviz::acyclic(const char *src, bool doWrite, bool verbose)
 {
-    lastErrorStr[0] = '\0';
-    acyclic_outFile_buff = "";
-    acyclic_outFile = acyclic_outFile_buff.c_str();
+    acyclic_outFile = "";
     acyclic_num_rev = 0;
     bool retVal = false;
-    Agraph_t *g = agmemread(src);
-    if (g)
+
+    Agraph_t *graph = agmemread(src);
+    if (graph)
     {
-        FILE *outFile = fopen("tmp.dot", "w");
+        TempFileBuffer outFile;
         graphviz_acyclic_options_t opts = {outFile, doWrite, verbose};
-        retVal = graphviz_acyclic(g, &opts, &acyclic_num_rev);
-        fclose(outFile);
-        std::ifstream file("tmp.dot");
-        std::string graph_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-        remove("tmp.dot");
-        acyclic_outFile_buff = graph_str;
-        acyclic_outFile = acyclic_outFile_buff.c_str();
+        retVal = graphviz_acyclic(graph, &opts, &acyclic_num_rev);
+        acyclic_outFile = outFile;
+        agclose(graph);
     }
     return retVal;
 }
 
 void Graphviz::tred(const char *src, bool verbose, bool printRemovedEdges)
 {
-    lastErrorStr[0] = '\0';
-    tred_out_buff = "";
-    tred_out = tred_out_buff.c_str();
-    tred_err_buff = "";
-    tred_err = tred_err_buff.c_str();
-    Agraph_t *g = agmemread(src);
-    if (g)
+    tred_out = "";
+    tred_err = "";
+
+    Agraph_t *graph = agmemread(src);
+    if (graph)
     {
-        FILE *outFile = fopen("tmp.dot", "w");
-        FILE *errFile = fopen("tmp_err.dot", "w");
-        graphviz_tred_options_t opts = {verbose, printRemovedEdges, outFile, errFile};
-        graphviz_tred(g, &opts);
-        fclose(outFile);
-        std::ifstream file("tmp.dot");
-        std::string outFile_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-        remove("tmp.dot");
-        tred_out_buff = outFile_str;
-        tred_out = tred_out_buff.c_str();
-        std::ifstream file_err("tmp_err.dot");
-        std::string errFile_str((std::istreambuf_iterator<char>(file_err)), std::istreambuf_iterator<char>());
-        remove("tmp_err.dot");
-        tred_err_buff = errFile_str;
-        tred_err = tred_err_buff.c_str();
+        TempFileBuffer out;
+        TempFileBuffer err;
+        graphviz_tred_options_t opts = {verbose, printRemovedEdges, out, err};
+        graphviz_tred(graph, &opts);
+        tred_out = out;
+        tred_err = err;
+        agclose(graph);
     }
 }
 
 const char *Graphviz::unflatten(const char *src, int maxMinlen, bool do_fans, int chainLimit)
 {
-    lastErrorStr[0] = '\0';
-    m_result = "";
-    Agraph_t *g = agmemread(src);
-    if (g)
+    unflatten_out = "";
+
+    Agraph_t *graph = agmemread(src);
+    if (graph)
     {
         graphviz_unflatten_options_t opts = {do_fans, maxMinlen, chainLimit};
-        graphviz_unflatten(g, &opts);
-
-        FILE *fp = fopen("tmp.dot", "w");
-        agwrite(g, fp);
-        fclose(fp);
-        std::ifstream file("tmp.dot");
-        std::string graph_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-        remove("tmp.dot");
-        m_result = graph_str;
+        graphviz_unflatten(graph, &opts);
+
+        TempFileBuffer tempFile;
+        agwrite(graph, tempFile);
+        unflatten_out = tempFile;
+        agclose(graph);
     }
-    return m_result.c_str();
+    return unflatten_out;
 }
 
 //  Include JS Glue  ---

src-cpp/graphviz/main.hpp

@@ -1,10 +1,9 @@
 #include <string>
+#include "util.hpp"
 
 class Graphviz
 {
 private:
-    std::string m_result;
-
 public:
     static const char *version();
     static const char *lastError();
@@ -13,19 +12,18 @@ class Graphviz
     ~Graphviz();
 
     void createFile(const char *path, const char *data);
-    const char *lastResult();
+
+    StringBuffer layout_result;
     const char *layout(const char *dot, const char *format, const char *engine);
 
-    std::string acyclic_outFile_buff;
-    const char *acyclic_outFile;
+    StringBuffer acyclic_outFile;
     size_t acyclic_num_rev;
     bool acyclic(const char *dot, bool doWrite = false, bool verbose = false);
 
-    std::string tred_out_buff;
-    const char *tred_out;
-    std::string tred_err_buff;
-    const char *tred_err;
+    StringBuffer tred_out;
+    StringBuffer tred_err;
     void tred(const char *dot, bool verbose = false, bool printRemovedEdges = false);
 
+    StringBuffer unflatten_out;
     const char *unflatten(const char *dot, int maxMinlen = 0, bool do_fans = false, int chainLimit = 0);
 };

src-cpp/graphviz/main.idl

@@ -4,7 +4,8 @@ interface Graphviz
   [Const] static DOMString version();
   [Const] static DOMString lastError();
   void createFile([Const] DOMString file, [Const] DOMString data);
-  [Const] DOMString lastResult();
+
+  [Const] attribute DOMString layout_result;
   [Const] DOMString layout([Const] DOMString dot, [Const] DOMString format, [Const] DOMString engine);
 
   [Const] attribute DOMString acyclic_outFile;

src-cpp/graphviz/util.cpp

@@ -0,0 +1,55 @@
+#include "util.hpp"
+
+StringBuffer::operator std::string() const
+{
+    return m_buffer;
+}
+
+StringBuffer::operator const char *() const
+{
+    return m_buffer.c_str();
+}
+
+StringBuffer &StringBuffer::operator=(const std::string &str)
+{
+    m_buffer = str;
+    return *this;
+}
+
+TempFileBuffer::TempFileBuffer()
+{
+    if (std::tmpnam(tempFileName) == nullptr)
+        throw std::runtime_error("Failed to generate a unique temporary file name.");
+
+    filePointer = std::fopen(tempFileName, "w+");
+    if (filePointer == nullptr)
+        throw std::runtime_error("Failed to open temporary file for writing.");
+}
+
+TempFileBuffer::~TempFileBuffer()
+{
+    if (filePointer != nullptr)
+    {
+        std::fclose(filePointer);
+        std::remove(tempFileName);
+    }
+}
+
+TempFileBuffer::operator FILE *() const
+{
+    return filePointer;
+}
+
+TempFileBuffer::operator std::string() const
+{
+    std::string content;
+    if (filePointer != nullptr)
+    {
+        std::rewind(filePointer);
+        char buffer[256];
+        size_t bytesRead;
+        while ((bytesRead = std::fread(buffer, 1, sizeof(buffer), filePointer)) > 0)
+            content.append(buffer, bytesRead);
+    }
+    return content;
+}

src-cpp/graphviz/util.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+
+class StringBuffer
+{
+private:
+    std::string m_buffer;
+
+public:
+    operator std::string() const;
+    operator const char *() const;
+    StringBuffer &operator=(const std::string &str);
+};
+
+class TempFileBuffer
+{
+private:
+    FILE *filePointer = nullptr;
+    char tempFileName[L_tmpnam];
+
+public:
+    TempFileBuffer();
+    ~TempFileBuffer();
+
+    operator FILE *() const;
+    operator std::string() const;
+    operator const char *() const;
+};