@ladybugmem/icebug 0.1.0 → 0.1.2

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

@@ -1,322 +0,0 @@
-#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

@@ -1,76 +0,0 @@
-/*
- * 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

@@ -1,76 +0,0 @@
-#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

@@ -1,145 +0,0 @@
-/*
- * 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

@@ -1,32 +0,0 @@
-
-#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

@@ -1,41 +0,0 @@
-
-#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_