@ladybugmem/icebug 0.1.0

package/vendor/include/networkit/auxiliary/StringBuilder.hpp

@@ -0,0 +1,322 @@
+#ifndef NETWORKIT_AUXILIARY_STRING_BUILDER_HPP_
+#define NETWORKIT_AUXILIARY_STRING_BUILDER_HPP_
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+#include <networkit/auxiliary/TemplateUtils.hpp>
+
+namespace Aux {
+
+template <typename... T>
+std::string toString(const T &...args);
+
+template <typename... T>
+std::ostream &printToStream(std::ostream &stream, const T &...args);
+
+template <typename... T>
+std::string toStringF(std::string_view format, const T &...args);
+
+template <typename... T>
+std::ostream &printToStreamF(std::ostream &stream, std::string_view format, const T &...args);
+
+// Implementation
+/////////////////
+
+namespace Impl {
+
+// Categories of how a type might be printable
+enum class PrintableCategory {
+    UNPRINTABLE,
+    ITERATABLE,
+    PAIR,
+    TUPLE,
+    STREAMABLE,
+    Unprintable = UNPRINTABLE, // this + following added for backwards compatibility
+    Iteratable = ITERATABLE,
+    Pair = PAIR,
+    Tuple = TUPLE,
+    Streamable = STREAMABLE
+};
+
+template <typename T>
+constexpr bool isStreamable();
+template <typename T>
+constexpr bool isPair();
+template <typename T>
+constexpr bool isTuple();
+template <typename T>
+constexpr bool isIteratable();
+
+template <typename T>
+constexpr PrintableCategory getPrintableCategory() {
+    return isStreamable<T>()   ? PrintableCategory::STREAMABLE
+           : isPair<T>()       ? PrintableCategory::PAIR
+           : isTuple<T>()      ? PrintableCategory::TUPLE
+           : isIteratable<T>() ? PrintableCategory::ITERATABLE
+                               :
+                               /* else: */ PrintableCategory::UNPRINTABLE;
+}
+template <PrintableCategory Tag>
+struct PrintableCategoryTag {};
+using IteratableTag = PrintableCategoryTag<PrintableCategory::ITERATABLE>;
+using PairTag = PrintableCategoryTag<PrintableCategory::PAIR>;
+using TupleTag = PrintableCategoryTag<PrintableCategory::TUPLE>;
+using StreamableTag = PrintableCategoryTag<PrintableCategory::STREAMABLE>;
+using UnprintableTag = PrintableCategoryTag<PrintableCategory::UNPRINTABLE>;
+
+template <typename T, typename... Args>
+void printToStream(std::ostream &stream, const T &, const Args &...);
+inline void printToStream(std::ostream &) {}
+
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &, IteratableTag);
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &, PairTag);
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &, TupleTag);
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &, StreamableTag);
+
+// Claim that this function exists somewhere else to keep the errors clean
+// (calling this function is not a problem since the error is already caught earlier
+// in printToStream, and calling it directly will result in a linker-error)
+template <typename T>
+extern void printToStreamTagged(std::ostream &, const T &, UnprintableTag);
+
+template <typename T, typename... Args>
+void printToStream(std::ostream &stream, const T &arg, const Args &...args) {
+    static_assert(getPrintableCategory<T>() != PrintableCategory::UNPRINTABLE,
+                  "printToStream must not be called with an unprintable argument");
+    printToStreamTagged(stream, arg, PrintableCategoryTag<getPrintableCategory<T>()>{});
+    printToStream(stream, args...);
+}
+
+inline std::tuple<std::string_view::const_iterator, bool>
+printFormatPartToStream(std::ostream &stream, std::string_view::const_iterator begin,
+                        std::string_view::const_iterator end);
+
+inline void printToStreamF(std::ostream &stream, std::string_view::const_iterator format_begin,
+                           std::string_view::const_iterator format_end) {
+    bool printArgument;
+    using iterator = std::string_view::const_iterator;
+    iterator it;
+    std::tie(it, printArgument) = printFormatPartToStream(stream, format_begin, format_end);
+    if (printArgument) {
+        throw std::invalid_argument{"formatstring requests more arguments then provided"};
+    }
+}
+template <typename T, typename... Args>
+void printToStreamF(std::ostream &stream, std::string_view::const_iterator format_begin,
+                    std::string_view::const_iterator format_end, const T &arg,
+                    const Args &...args) {
+    bool printArgument;
+    using iterator = std::string_view::const_iterator;
+    iterator it;
+    std::tie(it, printArgument) = printFormatPartToStream(stream, format_begin, format_end);
+    if (printArgument) {
+        printToStream(stream, arg);
+        printToStreamF(stream, it, format_end, args...);
+    } else {
+        assert(it == format_end);
+        return;
+    }
+}
+
+/**
+ * Write the formatstring until the first occurance of "%s"
+ * to stream, '%%' will be replaced by '%'.
+ *
+ * @returns The iterator that points one after the last consumed
+ * character and whether a further argument should be printed.
+ */
+inline auto printFormatPartToStream(std::ostream &stream, std::string_view::const_iterator begin,
+                                    std::string_view::const_iterator end)
+    -> std::tuple<std::string_view::const_iterator, bool> {
+    auto it = begin;
+    while (it != end) {
+        auto nextPercent = std::find(it, end, '%');
+        stream.write(&*it, std::distance(it, nextPercent));
+
+        if (nextPercent == end) {
+            it = nextPercent;
+            break;
+        }
+
+        it = ++nextPercent;
+
+        if (it == end) {
+            throw std::invalid_argument{"formatstrings must not end on unmatched '%'"};
+        } else if (*it == '%') {
+            stream.put('%');
+            ++it;
+        } else if (*it == 's') {
+            ++it;
+            return std::make_tuple(it, true);
+        } else {
+            throw std::invalid_argument{"formatstring contains illegal format-specifier"};
+        }
+    }
+    assert(it == end);
+    return std::make_tuple(end, false);
+}
+
+// Brace Yourself: Templatemetaprogramming is coming
+////////////////////////////////////////////////////
+
+// Iteratable
+struct IsIteratableHelper {
+    static std::false_type isIteratable(...);
+
+    template <
+        typename T, class Iterator = decltype(std::begin(std::declval<T>())),
+        AUX_REQUIRE(EndIteratorValid, isSame<Iterator, decltype(std::end(std::declval<T>()))>()),
+        AUX_REQUIRE(HasInputIterator,
+                    isBaseOrSame<std::input_iterator_tag,
+                                 typename std::iterator_traits<Iterator>::iterator_category>())>
+    static std::true_type isIteratable(const T &);
+};
+template <typename T>
+constexpr bool isIteratable() {
+    return decltype(IsIteratableHelper::isIteratable(std::declval<T>()))::value;
+}
+
+// Pair
+template <typename T>
+struct IsPairHelper : std::false_type {};
+template <typename T1, typename T2>
+struct IsPairHelper<std::pair<T1, T2>> : std::true_type {};
+template <typename T>
+constexpr bool isPair() {
+    return IsPairHelper<T>::value;
+}
+
+// Tuple
+template <typename T>
+struct IsTupleHelper : std::false_type {};
+template <typename... T>
+struct IsTupleHelper<std::tuple<T...>> : std::true_type {};
+template <typename T>
+constexpr bool isTuple() {
+    return IsTupleHelper<T>::value;
+}
+
+// Streamable
+struct IsStreamableHelper {
+    static std::false_type isStreamable(...);
+
+    template <
+        typename T,
+        typename _streamT = typename std::decay<decltype(std::declval<std::ostream &>()
+                                                         << std::declval<const T &>())>::type,
+        typename std::enable_if<std::is_same<std::ostream, _streamT>::value
+                                || std::is_base_of<std::ostream, _streamT>::value> * = nullptr>
+    static std::true_type isStreamable(const T &);
+};
+template <typename T>
+constexpr bool isStreamable() {
+    return decltype(IsStreamableHelper::isStreamable(std::declval<T>()))::value;
+}
+
+// And now: implement the actual printing:
+//////////////////////////////////////////
+
+// Streamable
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &arg, StreamableTag) {
+    stream << arg;
+}
+
+// Pair
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &arg, PairTag) {
+    stream << '(';
+    printToStream(stream, arg.first);
+    stream << ", ";
+    printToStream(stream, arg.second);
+    stream << ')';
+}
+
+// Tuple
+template <typename Tuple, int I, int TupleSize>
+struct printTupleHelper {
+    static void print(std::ostream &stream, const Tuple &arg) {
+        printToStream(stream, std::get<I - 1>(arg));
+        stream << ", ";
+        printTupleHelper<Tuple, I + 1, TupleSize>::print(stream, arg);
+    }
+};
+template <typename Tuple, int I>
+struct printTupleHelper<Tuple, I, I> {
+    static void print(std::ostream &stream, const Tuple &arg) {
+        printToStream(stream, std::get<I - 1>(arg));
+    }
+};
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &arg, TupleTag) {
+    stream << '(';
+    printTupleHelper<T, 1, std::tuple_size<T>::value>::print(stream, arg);
+    stream << ')';
+}
+
+// Iteratable
+template <typename T>
+void printToStreamTagged(std::ostream &stream, const T &arg, IteratableTag) {
+    auto it = std::begin(arg);
+    auto end = std::end(arg);
+    bool firstpass = true;
+    stream << '[';
+    while (it != end) {
+        if (firstpass) {
+            firstpass = false;
+        } else {
+            stream << ", ";
+        }
+        printToStream(stream, *it);
+        ++it;
+    }
+    stream << ']';
+}
+
+} // namespace Impl
+
+// Finally: put together the public interface:
+//////////////////////////////////////////////
+
+template <typename... T>
+std::string toString(const T &...args) {
+    std::stringstream stream;
+    printToStream(stream, args...);
+    return stream.str();
+}
+
+template <typename... T>
+std::ostream &printToStream(std::ostream &stream, const T &...args) {
+    Impl::printToStream(stream, args...);
+    return stream;
+}
+
+template <typename... T>
+std::string toStringF(std::string_view format, const T &...args) {
+    std::stringstream stream;
+    printToStreamF(stream, format, args...);
+    return stream.str();
+}
+
+template <typename... T>
+std::ostream &printToStreamF(std::ostream &stream, std::string_view format, const T &...args) {
+    Impl::printToStreamF(stream, format.begin(), format.end(), args...);
+    return stream;
+}
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_STRING_BUILDER_HPP_

package/vendor/include/networkit/auxiliary/StringTools.hpp

@@ -0,0 +1,76 @@
+/*
+ * StringTools.hpp
+ *
+ *  Completely rewritten on: 12.05.2014
+ *      Author: Florian Weber (uagws@student.kit.edu)
+ */
+
+#ifndef NETWORKIT_AUXILIARY_STRING_TOOLS_HPP_
+#define NETWORKIT_AUXILIARY_STRING_TOOLS_HPP_
+
+#include <algorithm>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace Aux {
+
+/**
+ * Missing string functions.
+ */
+namespace StringTools {
+
+/**
+ * Splits a range of characters at a delimiter into a vector of strings.
+ *
+ * Requirements:
+ *   Character must be equality-comparable to char and it must be possible to construct a char from
+ *   any Character.
+ *   Iterator must be an input-iterator over Characters.
+ */
+template <typename Iterator, typename Character>
+std::vector<std::string> split(Iterator begin, Iterator end, Character delim = Character{' '}) {
+
+    // measurements showed that precalculating the number of tokens and
+    // reserving space for them was in fact slower than just letting
+    // the vector grow naturally.
+    std::vector<std::string> tokens;
+
+    auto it = begin;
+    while (it != end) {
+        auto tmp = std::find(it, end, delim);
+        tokens.emplace_back(it, tmp);
+        if (tmp == end) {
+            break;
+        }
+        it = tmp;
+        ++it;
+    }
+    return tokens;
+}
+
+/**
+ * Split a string at delimiter and return vector of parts.
+ */
+inline std::vector<std::string> split(std::string_view s, char delim = ' ') {
+    return split(s.begin(), s.end(), delim);
+}
+
+/**
+ * Determines whether @a str ends with @a suffix.
+ */
+inline bool ends_with(std::string_view str, std::string_view suffix) {
+    return str.size() >= suffix.size()
+           && str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+/**
+ * Determines whether @a str starts with @a prefix.
+ */
+inline bool starts_with(std::string_view str, std::string_view prefix) {
+    return str.size() >= prefix.size() && str.compare(0, prefix.size(), prefix) == 0;
+}
+
+} /* namespace StringTools */
+} /* namespace Aux */
+#endif // NETWORKIT_AUXILIARY_STRING_TOOLS_HPP_

package/vendor/include/networkit/auxiliary/TemplateUtils.hpp

@@ -0,0 +1,76 @@
+#ifndef NETWORKIT_AUXILIARY_TEMPLATE_UTILS_HPP_
+#define NETWORKIT_AUXILIARY_TEMPLATE_UTILS_HPP_
+
+#include <type_traits>
+
+/**
+ * The macro makes the use of std::enable_if much easier by removing all the boilerplate.
+ *
+ * The 'what' argument must be a valid identifier that describes, what is required.
+ * Example: you want to require that T is an integer, than what should be something like
+ *          T_is_integer
+ *
+ * The second argument must be a constant boolean expression. In order to allow templates that
+ * would otherwise confuse the preprocessor, this is passed as variadic argument (this is however
+ * an implementation detail and you should never actually pass more than one argument.
+ */
+#define AUX_REQUIRE(what, ...) class what = typename ::std::enable_if<__VA_ARGS__>::type
+
+/**
+ * If two templates only differ in the default-values of their template-arguments
+ * C++ considers this to be a compilation-error. A simple way to prevent this is to
+ * add further defaulted template-arguments, which is what this macro provides in a
+ * semantic way.
+ *
+ * Example:
+ *
+ * template<typename T, AUX_REQUIRE(isInteger, [...])>
+ * void fun(T) {...}
+ *
+ * template<typename T, AUX_REQUIRE(isFloat, [...]), AUX_DUMMY_ARGUMENT>
+ * void fun(T) {...}
+ *
+ * Note however that it may often be a cleaner solution to use compile-time dispatching instead
+ * of hacks that envolve enable-if.
+ */
+#define AUX_DUMMY_ARGUMENT class = void
+
+namespace Aux {
+
+/**
+ * This is a backport of C++14 std::decay_t
+ */
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+/**
+ * Returns the corresponding std::integral_constant<bool, B> to a boolean
+ * value B.
+ */
+template <bool B>
+using boolToType = std::integral_constant<bool, B>;
+
+/**
+ * This is just a wrapper around std::is_same in order to provide a nicer interface.
+ *
+ * With C++14 this could use template-variables, but with C++11 we are stuck with
+ * constexpr-functions.
+ */
+template <typename T1, typename T2>
+constexpr bool isSame() {
+    return std::is_same<T1, T2>::value;
+}
+
+/**
+ * Checks whether Derived is either a type that derives from Base or is identical to Base.
+ *
+ * This is very usefull for situations in which you work with iterator-traits or the like.
+ */
+template <typename Base, typename Derived>
+constexpr bool isBaseOrSame() {
+    return isSame<Base, Derived>() || std::is_base_of<Base, Derived>::value;
+}
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_TEMPLATE_UTILS_HPP_

package/vendor/include/networkit/auxiliary/Timer.hpp

@@ -0,0 +1,145 @@
+/*
+ * Timer.hpp
+ *
+ *  Created on: 14.01.2013
+ *      Author: Christian Staudt (christian.staudt@kit.edu)
+ */
+
+#ifndef NETWORKIT_AUXILIARY_TIMER_HPP_
+#define NETWORKIT_AUXILIARY_TIMER_HPP_
+
+#include <chrono>
+#include <cstdint>
+#include <string>
+
+#include <networkit/auxiliary/Log.hpp>
+
+namespace Aux {
+
+/**
+ * A timer for running time measurements.
+ */
+class Timer {
+public:
+#ifdef __MIC__
+    using my_steady_clock = std::chrono::monotonic_clock;
+#else
+    using my_steady_clock = std::chrono::steady_clock;
+#endif // __MIC__
+
+    Timer() = default;
+
+    /**
+     * Start the clock.
+     * Returns the time at which the instance was started.
+     */
+    my_steady_clock::time_point start() noexcept;
+
+    /**
+     * Stops the clock permanently for the instance of the Timer.
+     * Returns the time at which the instance was stopped.
+     */
+    my_steady_clock::time_point stop() noexcept;
+
+    /**
+     * Returns a chrono::duration since the Timer was started.
+     * If stop() was called, the duration is between the start() and stop()
+     * calls is returned.
+     */
+    std::chrono::duration<uint64_t, std::milli> elapsed() const noexcept;
+
+    /**
+     * Returns the number of milliseconds since the Timer was started.
+     * If stop() was called, the duration is between the start() and stop()
+     * calls is returned.
+     */
+    uint64_t elapsedMilliseconds() const noexcept;
+
+    /**
+     * Returns the number of microseconds since the Timer was started.
+     * If stop() was called, the duration is between the start() and stop()
+     * calls is returned.
+     */
+    uint64_t elapsedMicroseconds() const noexcept;
+
+    /**
+     * Returns the number of nanoseconds since the Timer was started.
+     * If stop() was called, the duration is between the start() and stop()
+     * calls is returned.
+     */
+    uint64_t elapsedNanoseconds() const noexcept;
+
+    /**
+     * Returns the time at which the instance was started.
+     */
+    my_steady_clock::time_point startTime() const noexcept;
+
+    /**
+     * Returns the time at which the instance was stopped.
+     */
+    my_steady_clock::time_point stopTime() const noexcept;
+
+    /**
+     * Returns a human-readable representation including the elapsed time and unit.
+     */
+    std::string elapsedTag() const;
+
+protected:
+    bool running{false}; //!< true if timer has been started and not stopped after that
+    my_steady_clock::time_point started; //!< time at which timer has been started
+    my_steady_clock::time_point stopped; //!< time at which timer has been stopped
+
+    /// If running returns now, otherwise the stop time
+    my_steady_clock::time_point stopTimeOrNow() const noexcept;
+};
+
+/**
+ * A timer for running time measurements.
+ * Same as Timer but automatically starts on construction.
+ */
+class StartedTimer : public Timer {
+public:
+    StartedTimer() : Timer() { start(); }
+};
+
+/**
+ * A timer for running time measurements within a scope.
+ *
+ * Same as Timer but automatically starts on construction and report on destruction.
+ *
+ * @code
+ * {
+ *    Aux::ScopedTimer("Algorithm A"); // WRONG; will directly report without measuring the scope
+ *    Aux::ScopedTimer someName("Algorithm B"); // OK: the named instance is valid until the end of
+ * the scope
+ *    // some expensive operations
+ *
+ *
+ * } // <- Report time since creation of the timer object via Aux::Log
+ * @endcode
+ *
+ * @warning
+ * As the timer exploits RAII, it requires a named instance to extend its life time until the
+ * end of the current scope. In the example above "someName" is used. If the time measured seems
+ * too short, make you created a named instances.
+ */
+class LoggingTimer : public Timer {
+public:
+    /**
+     * @param label The label printed out next to the measurement
+     * @param level Only measure if logging at the provided LogLevel is enabled during runtime.
+     *              If logging at the given level is disable the Timer is very cheap to construct.
+     *              If logging is disabled during construction or destruction, no message is shown.
+     */
+    explicit LoggingTimer(std::string_view label = "",
+                          Aux::Log::LogLevel level = Aux::Log::LogLevel::DEBUG);
+    ~LoggingTimer();
+
+private:
+    Aux::Log::LogLevel level;
+    std::string label;
+};
+
+} /* namespace Aux */
+
+#endif // NETWORKIT_AUXILIARY_TIMER_HPP_

package/vendor/include/networkit/auxiliary/VectorComparator.hpp

@@ -0,0 +1,32 @@
+
+#ifndef NETWORKIT_AUXILIARY_VECTOR_COMPARATOR_HPP_
+#define NETWORKIT_AUXILIARY_VECTOR_COMPARATOR_HPP_
+
+#include <cstdint>
+#include <vector>
+
+namespace Aux {
+
+// Implementation of vector-based comparators
+
+template <class Type>
+struct LessInVector {
+    LessInVector(const std::vector<Type> &vec) : vec(&vec) {}
+    bool operator()(uint64_t x, uint64_t y) const noexcept { return (*vec)[x] < (*vec)[y]; }
+
+private:
+    const std::vector<Type> *vec;
+};
+
+template <class Type>
+struct GreaterInVector {
+    GreaterInVector(const std::vector<Type> &vec) : vec(&vec) {}
+    bool operator()(uint64_t x, uint64_t y) const noexcept { return (*vec)[x] > (*vec)[y]; }
+
+private:
+    const std::vector<Type> *vec;
+};
+
+} // namespace Aux
+
+#endif // NETWORKIT_AUXILIARY_VECTOR_COMPARATOR_HPP_

package/vendor/include/networkit/base/Algorithm.hpp

@@ -0,0 +1,41 @@
+
+#ifndef NETWORKIT_BASE_ALGORITHM_HPP_
+#define NETWORKIT_BASE_ALGORITHM_HPP_
+
+#include <stdexcept>
+#include <string>
+
+namespace NetworKit {
+
+class Algorithm {
+protected:
+    bool hasRun = false;
+
+public:
+    virtual ~Algorithm() = default;
+
+    /**
+     * The generic run method which calls runImpl() and takes care of setting @ref hasRun to the
+     * appropriate value.
+     */
+    virtual void run() = 0;
+
+    /**
+     * Indicates whether an algorithm has completed computation or not.
+     *
+     * @return The value of @ref hasRun.
+     */
+    bool hasFinished() const noexcept { return hasRun; }
+
+    /**
+     * Assure that the algorithm has been run, throws a std::runtime_error otherwise.
+     */
+    void assureFinished() const {
+        if (!hasRun)
+            throw std::runtime_error("Error, run must be called first");
+    }
+};
+
+} // namespace NetworKit
+
+#endif // NETWORKIT_BASE_ALGORITHM_HPP_