utils.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Graph.h>
#include <ogdf/basic/GraphAttributes.h>
 
#include <cstddef>
#include <limits>
#include <unordered_map>
 
namespace ogdf {
namespace matching_blossom {
 
template<class TWeight>
TWeight infinity() {
    return std::numeric_limits<TWeight>::has_infinity ? std::numeric_limits<TWeight>::infinity()
                                                      : std::numeric_limits<TWeight>::max();
}
 
template<class K, class V>
V* tryGetPointerFromMap(const std::unordered_map<K, V*>& map, const K& key) {
    auto it = map.find(key);
    if (it != map.end()) {
        return it->second;
    } else {
        return nullptr;
    }
}
 
template<class TWeight>
TWeight getWeight(edge e, const EdgeArray<TWeight>& weights) {
    return weights[e];
}
 
template<class TWeight>
TWeight getWeight(edge e, const GraphAttributes& GA) {
    if (std::numeric_limits<TWeight>::is_integer) {
        if (GA.has(GraphAttributes::edgeIntWeight)) {
            return GA.intWeight(e);
        }
    } else if (GA.has(GraphAttributes::edgeIntWeight)) {
        return GA.doubleWeight(e);
    }
    return 1;
}
 
template<typename Key, typename Value>
class MapKeyIterator : public std::unordered_map<Key, Value>::iterator {
    using MapIterator = typename std::unordered_map<Key, Value>::iterator;
 
public:
    MapKeyIterator() : MapIterator() {};
    MapKeyIterator(MapIterator it_) : MapIterator(it_) {};
 
    Key* operator->() { return (Key* const)&(MapIterator::operator->()->first); }
 
    Key operator*() { return MapIterator::operator*().first; }
};
 
template<typename Key, typename Value>
class MapValueIterator : public std::unordered_map<Key, Value>::iterator {
    using MapIterator = typename std::unordered_map<Key, Value>::iterator;
 
public:
    MapValueIterator() : MapIterator() {};
    MapValueIterator(MapIterator it_) : MapIterator(it_) {};
 
    Value* operator->() { return (Value* const)&(MapIterator::operator->()->second); }
 
    Value operator*() { return MapIterator::operator*().second; }
};
 
template<template<typename, typename> class Iterator, typename Key, typename Value>
class BaseIteratorContainer {
    using iterator = Iterator<Key, Value>;
 
    std::unordered_map<Key, Value>& m_map;
 
public:
    BaseIteratorContainer(std::unordered_map<Key, Value>& map) : m_map(map) { }
 
    iterator begin() { return iterator(m_map.begin()); }
 
    iterator end() { return iterator(m_map.end()); }
 
    size_t size() { return m_map.size(); }
};
 
template<typename Key, typename Value>
using KeyIteratorContainer = BaseIteratorContainer<MapKeyIterator, Key, Value>;
 
template<typename Key, typename Value>
using ValueIteratorContainer = BaseIteratorContainer<MapValueIterator, Key, Value>;
 
}
}