@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/io/EdgeListCoverReader.hpp

@@ -0,0 +1,35 @@
+
+#ifndef NETWORKIT_IO_EDGE_LIST_COVER_READER_HPP_
+#define NETWORKIT_IO_EDGE_LIST_COVER_READER_HPP_
+
+#include <networkit/io/CoverReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class EdgeListCoverReader final : public CoverReader {
+public:
+    /**
+     * Constructs the EdgeListCoverReader class with @a firstNode as the index of the first node in
+     * the file.
+     * @param[in] firstNode Index of the first node in the file.
+     */
+    EdgeListCoverReader(node firstNode = 1);
+
+    /**
+     * Read a cover from a file. File format: each line contains the node ids of one subset.
+     *
+     * @param[in]  path  The path to the input file
+     * @param[in]  G     The graph for which the cover shall be read
+     * @return The cover instance
+     */
+    Cover read(std::string_view path, Graph &G) override;
+
+private:
+    node firstNode;
+};
+} // namespace NetworKit
+
+#endif // NETWORKIT_IO_EDGE_LIST_COVER_READER_HPP_

package/vendor/include/networkit/io/EdgeListPartitionReader.hpp

@@ -0,0 +1,43 @@
+
+#ifndef NETWORKIT_IO_EDGE_LIST_PARTITION_READER_HPP_
+#define NETWORKIT_IO_EDGE_LIST_PARTITION_READER_HPP_
+
+#include <fstream>
+
+#include <networkit/auxiliary/StringTools.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/structures/Partition.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class EdgeListPartitionReader final {
+
+public:
+    /**
+     * Constructs the EdgeListPartitionReader class with @a firstNode as the index of the first node
+     * in the file.
+     * @param[in]  firstNode  Index of the first node in the file.
+     * @param[in]  sepChar    The separator between two elements
+     */
+    EdgeListPartitionReader(node firstNode = 1, char sepChar = '\t');
+
+    /**
+     * Read a clustering from a file. File format:
+     *     A list of the nodes and their membership (memberships are labelled by integer numbers
+     * >=1).
+     *
+     * @param[in]  path  Path to file.
+     * @return The clustering contained in the file at @a path.
+     */
+    Partition read(std::string_view path);
+
+private:
+    node firstNode;
+    char sepChar;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_EDGE_LIST_PARTITION_READER_HPP_

package/vendor/include/networkit/io/EdgeListReader.hpp

@@ -0,0 +1,61 @@
+/*
+ * EdgeListReader.hpp
+ *
+ *  Created on: 18.06.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_EDGE_LIST_READER_HPP_
+#define NETWORKIT_IO_EDGE_LIST_READER_HPP_
+
+#include <map>
+#include <string>
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * A reader for various edge list formats, in which each line contains an edge as
+ * two node ids.
+ *
+ */
+class EdgeListReader final : public GraphReader {
+
+public:
+    EdgeListReader() = default; // nullary constructor for Python shell
+
+    /**
+     * @param[in]  separator  character used to separate nodes in an edge line
+     * @param[in]  firstNode  index of the first node in the file
+     * @param[in]  commentPrefix  prefix of comment lines
+     * @param[in]  continuous  boolean to specify if node ids are continuous
+     * @param[in]  directed  read graph as directed
+     */
+    EdgeListReader(char separator, node firstNode, std::string_view commentPrefix = "#",
+                   bool continuous = true, bool directed = false);
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    GraphW read(std::string_view path) override;
+
+    /**
+     * Return the node map, in case node ids are not continuous
+     */
+    const std::map<std::string, node> &getNodeMap() const;
+
+private:
+    char separator; //!< character separating nodes in an edge line
+    std::string commentPrefix;
+    node firstNode;
+    bool continuous;
+    std::map<std::string, node> mapNodeIds;
+    bool directed;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_EDGE_LIST_READER_HPP_

package/vendor/include/networkit/io/EdgeListWriter.hpp

@@ -0,0 +1,48 @@
+/*
+ * EdgeListWriter.hpp
+ *
+ *  Created on: 18.06.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_EDGE_LIST_WRITER_HPP_
+#define NETWORKIT_IO_EDGE_LIST_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * A writer for the edge list format. The output will contain one edge per line,
+ * in the format fromNodeSEPARATORtoNode, where separator can be specified by
+ * the user.
+ */
+class EdgeListWriter final : public GraphWriter {
+
+public:
+    EdgeListWriter() = default; // nullary constructor for Python shell
+
+    /**
+     * @param[in]  separator  character used to separate nodes in an edge line
+     * @param[in]  firstNode  index of the first node in the file
+     * @param[in]  bothDirections  for undirected graphs: if every edge shall be written in both
+     * directions (default: false)
+     */
+    EdgeListWriter(char separator, node firstNode, bool bothDirections = false);
+
+    /**
+     * Write the graph to a file.
+     * @param[in]  G    the graph
+     * @param[in]  path  the output file path
+     */
+    void write(const Graph &G, std::string_view path) override;
+
+private:
+    char separator; //!< character separating nodes in an edge line
+    node firstNode;
+    bool bothDirections;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_EDGE_LIST_WRITER_HPP_

package/vendor/include/networkit/io/GMLGraphReader.hpp

@@ -0,0 +1,33 @@
+/*
+ * GMLGraphReader.hpp
+ *
+ *  Created on: 18.09.2014
+ *      Author: Maximilian Vogel (maximilian.vogel@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_IO_GML_GRAPH_READER_HPP_
+#define NETWORKIT_IO_GML_GRAPH_READER_HPP_
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class GMLGraphReader final : public GraphReader {
+public:
+    GMLGraphReader() = default;
+
+    /**
+     * Takes a file path as parameter and returns a graph file.
+     *
+     * @param[in]  path  file path
+     *
+     * @param[out]  the graph read from file
+     */
+    GraphW read(std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GML_GRAPH_READER_HPP_

package/vendor/include/networkit/io/GMLGraphWriter.hpp

@@ -0,0 +1,33 @@
+/*
+ * GMLGraphWriter.hpp
+ *
+ *  Created on: 30.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_GML_GRAPH_WRITER_HPP_
+#define NETWORKIT_IO_GML_GRAPH_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class GMLGraphWriter final : public GraphWriter {
+public:
+    /** Default constructor */
+    GMLGraphWriter() = default;
+
+    /**
+     * Write a graph @a G and its coordinates to a GML file.
+     *
+     * @param[in]  G     Graph of type NetworKit with 2D coordinates.
+     * @param[in]  path  Path to file.
+     */
+    void write(const Graph &G, std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GML_GRAPH_WRITER_HPP_

package/vendor/include/networkit/io/GraphIO.hpp

@@ -0,0 +1,52 @@
+/*
+ * GraphIO.hpp
+ *
+ *  Created on: 09.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_GRAPH_IO_HPP_
+#define NETWORKIT_IO_GRAPH_IO_HPP_
+
+#include <string>
+
+#include <networkit/auxiliary/Log.hpp>
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class GraphIO final {
+public:
+    /**
+     * Writes graph to text file in edge list format.
+     * Keep in mind that isolated nodes are ignored.
+     *
+     * @param[in]  G  graph
+     * @param[in]  path  file path
+     *
+     * Edge list format:
+     *     for each edge {u, v}:
+     *       write line "u v"
+     */
+    void writeEdgeList(const Graph &G, std::string_view path);
+
+    /**
+     * Writes graph to text file in adjacency list format.
+     *
+     * @param[in]  G  graph
+     * @param[in]  path  file path
+     *
+     * Adjacency list format:
+     *     for each node v:
+     *       write "v"
+     *       write "x" for each edge {v, x}
+     *       end line
+     */
+    void writeAdjacencyList(const Graph &G, std::string_view path);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GRAPH_IO_HPP_

package/vendor/include/networkit/io/GraphReader.hpp

@@ -0,0 +1,40 @@
+/*
+ * GraphReader.hpp
+ *
+ *  Created on: 17.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_GRAPH_READER_HPP_
+#define NETWORKIT_IO_GRAPH_READER_HPP_
+
+#include <networkit/auxiliary/StringTools.hpp>
+#include <networkit/graph/Graph.hpp>
+#include <networkit/graph/GraphW.hpp>
+
+namespace NetworKit {
+/**
+ * @ingroup io
+ * Abstract base class for graph readers.
+ */
+class GraphReader {
+public:
+    // How to deal with multi-edges
+    enum MultipleEdgesHandling {
+        DISCARD_EDGES,  // Reads and selects the first edge which occurs and discards all following
+        SUM_WEIGHTS_UP, // If an edge occurs again, the weight of it is added to the existing edge
+        KEEP_MINIMUM_WEIGHT // The edge with the lowest weight is kept
+    };
+
+    virtual ~GraphReader() = default;
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    virtual GraphW read(std::string_view path) = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GRAPH_READER_HPP_

package/vendor/include/networkit/io/GraphToolBinaryReader.hpp

@@ -0,0 +1,71 @@
+/*
+ * GraphToolBinaryReader.hpp
+ *
+ *  Created on: 02.12.14
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_IO_GRAPH_TOOL_BINARY_READER_HPP_
+#define NETWORKIT_IO_GRAPH_TOOL_BINARY_READER_HPP_
+
+#include <fstream>
+#include <string>
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * Reads graphs from files in the binary format defined by graph-tool[1].
+ * [1]: http://graph-tool.skewed.de/static/doc/gt_format.html
+ */
+class GraphToolBinaryReader final : public GraphReader {
+
+public:
+    GraphToolBinaryReader() = default; // nullary constructor for Python shell
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    GraphW read(std::string_view path) override;
+
+private:
+    bool littleEndianness;
+
+    void addOutNeighbours(std::ifstream &file, uint64_t numNodes, GraphW &G);
+
+    std::vector<std::vector<uint64_t>> getOutNeighbours(std::ifstream &file, uint64_t numNodes);
+
+    uint8_t getAdjacencyWidth(uint64_t n);
+
+    uint64_t getNumNodes(std::ifstream &file);
+
+    bool getDirected(std::ifstream &file);
+
+    std::string readComment(std::ifstream &file);
+
+    bool checkHeader(std::ifstream &file);
+
+    template <typename Type>
+    Type readType(std::ifstream &file, int width) {
+        Type val = 0;
+        uint8_t *bytes = new uint8_t[width];
+        file.read((char *)bytes, width);
+        if (this->littleEndianness) {
+            for (int i = 0; i < width; ++i) {
+                val |= ((Type)bytes[i] << (i * 8));
+            }
+        } else {
+            for (int i = 0; i < width; ++i) {
+                val |= ((Type)bytes[i] << (width - 1 - i) * 8);
+            }
+        }
+        delete[] bytes;
+        return val;
+    }
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GRAPH_TOOL_BINARY_READER_HPP_

package/vendor/include/networkit/io/GraphToolBinaryWriter.hpp

@@ -0,0 +1,61 @@
+/*
+ * GraphToolBinaryWriter.hpp
+ *
+ *  Created on: 02.12.14
+ *      Author: Maximilian Vogel
+ */
+
+#ifndef NETWORKIT_IO_GRAPH_TOOL_BINARY_WRITER_HPP_
+#define NETWORKIT_IO_GRAPH_TOOL_BINARY_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+ * Writes graphs to files in the binary format defined by graph-tool[1].
+ * [1]: http://graph-tool.skewed.de/static/doc/gt_format.html
+ */
+class GraphToolBinaryWriter final : public GraphWriter {
+
+public:
+    GraphToolBinaryWriter(bool littleEndianness = true);
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    void write(const Graph &G, std::string_view path) override;
+
+private:
+    bool littleEndianness;
+
+    void writeAdjacencies(std::ofstream &file, const Graph &G);
+
+    uint8_t getAdjacencyWidth(uint64_t n);
+
+    void writeComment(std::ofstream &file);
+
+    void writeHeader(std::ofstream &file);
+
+    template <typename Type>
+    void writeType(std::ofstream &file, int width, Type val) {
+        // DEBUG("writing ",val, "with width ", width, " to file");
+        uint8_t *bytes = new uint8_t[width];
+        if (this->littleEndianness) {
+            for (int i = 0; i < width; ++i) {
+                bytes[i] = (val >> (i * 8)) & 0xFF;
+            }
+        } else {
+            for (int i = 0; i < width; ++i) {
+                bytes[i] = (val >> ((width - 1 - i) * 8)) & 0xFF;
+            }
+        }
+        file.write((char *)bytes, width);
+        delete[] bytes;
+    }
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GRAPH_TOOL_BINARY_WRITER_HPP_

package/vendor/include/networkit/io/GraphWriter.hpp

@@ -0,0 +1,27 @@
+/*
+ * GraphWriter.hpp
+ *
+ *  Created on: 30.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_GRAPH_WRITER_HPP_
+#define NETWORKIT_IO_GRAPH_WRITER_HPP_
+
+#include <networkit/graph/Graph.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Abstract base class for graph writers.
+ */
+class GraphWriter {
+public:
+    virtual ~GraphWriter() = default;
+
+    virtual void write(const Graph &G, std::string_view path) = 0;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_GRAPH_WRITER_HPP_

package/vendor/include/networkit/io/KONECTGraphReader.hpp

@@ -0,0 +1,44 @@
+/*
+ * KONECTGraphReader.hpp
+ *
+ *  Created on: 11.05.2018
+ *      Author: Roman Bange
+ */
+
+#ifndef NETWORKIT_IO_KONECT_GRAPH_READER_HPP_
+#define NETWORKIT_IO_KONECT_GRAPH_READER_HPP_
+
+#include <unordered_map>
+
+#include <networkit/graph/Graph.hpp>
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+class KONECTGraphReader final : public GraphReader {
+
+public:
+    /*
+     * If the input graph has multiple edges, you can specify on how these edges are handled.
+     * Keep in mind that NetworKit node id's start with 0 while most KONECT graphs start with 1.
+     * See GraphReader.h for a closer description of the parameters.
+     *
+     * @param[in]  remapNodes  specifies whether node ids should be remapped if non consecutive
+     * @param[in]  handlingmethod  specifies how multiple edges should be handled (only relevant if
+     * graph with multiple edges is given)
+     */
+    KONECTGraphReader(bool remapNodes = false,
+                      MultipleEdgesHandling handlingmethod = DISCARD_EDGES);
+
+    /**
+     * Given the path of an input file, read the graph contained.
+     *
+     * @param[in]  path  input file path
+     */
+    GraphW read(std::string_view path) override;
+
+private:
+    bool remapNodes;
+    MultipleEdgesHandling multipleEdgesHandlingMethod;
+};
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_KONECT_GRAPH_READER_HPP_

package/vendor/include/networkit/io/LineFileReader.hpp

@@ -0,0 +1,42 @@
+/*
+ * LineFileReader.hpp
+ *
+ *  Created on: 04.10.2013
+ *      Author: cls
+ */
+
+#ifndef NETWORKIT_IO_LINE_FILE_READER_HPP_
+#define NETWORKIT_IO_LINE_FILE_READER_HPP_
+
+#include <fstream>
+#include <string>
+#include <vector>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reads a file and puts each line as a string into a vector
+ */
+class LineFileReader final {
+public:
+    std::vector<std::string> read(std::string path) {
+        std::ifstream file;
+        std::string line; // the current line
+        file.open(path);
+
+        std::vector<std::string> data;
+
+        while (file.good()) {
+            std::getline(file, line);
+            data.push_back(line);
+        }
+
+        file.close();
+
+        return data;
+    }
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_LINE_FILE_READER_HPP_

package/vendor/include/networkit/io/METISGraphReader.hpp

@@ -0,0 +1,36 @@
+/*
+ * METISGraphReader.hpp
+ *
+ *  Created on: 17.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_METIS_GRAPH_READER_HPP_
+#define NETWORKIT_IO_METIS_GRAPH_READER_HPP_
+
+#include <networkit/io/GraphReader.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ * Reader for the METIS file format documented in [1]
+ *
+ * [1] http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/manual.pdf
+ */
+class METISGraphReader final : public GraphReader {
+public:
+    METISGraphReader() = default;
+
+    /**
+     * Takes a file path as parameter and returns a graph file.
+     *
+     * @param[in]  path  file path
+     *
+     * @param[out]  the graph read from file
+     */
+    GraphW read(std::string_view path) override;
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_METIS_GRAPH_READER_HPP_

package/vendor/include/networkit/io/METISGraphWriter.hpp

@@ -0,0 +1,29 @@
+/*
+ * METISGraphWriter.hpp
+ *
+ *  Created on: 30.01.2013
+ *      Author: Christian Staudt
+ */
+
+#ifndef NETWORKIT_IO_METIS_GRAPH_WRITER_HPP_
+#define NETWORKIT_IO_METIS_GRAPH_WRITER_HPP_
+
+#include <networkit/io/GraphWriter.hpp>
+
+namespace NetworKit {
+
+/**
+ * @ingroup io
+ */
+class METISGraphWriter final : public GraphWriter {
+
+public:
+    METISGraphWriter() = default;
+
+    void write(const Graph &G, std::string_view path) override;
+
+    void write(const Graph &G, bool weighted, std::string_view path);
+};
+
+} /* namespace NetworKit */
+#endif // NETWORKIT_IO_METIS_GRAPH_WRITER_HPP_