lib/map.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIB_MAP_H_
#define LIB_MAP_H_
 
#include <iterator>
#include <optional>
 
namespace P4 {

template <typename Map, typename Key>
typename Map::mapped_type get(const Map &m, const Key &key) {
    auto it = m.find(key);
    return it != m.end() ? it->second : typename Map::mapped_type{};
}
template <class Map, typename Key, typename Value>
typename Map::mapped_type get(const Map &m, const Key &key, Value &&def) {
    using M = typename Map::mapped_type;
    auto it = m.find(key);
    return it != m.end() ? it->second : static_cast<M>(std::forward<Value>(def));
}

template <typename Map, typename Key>
const typename Map::mapped_type *getref(const Map &m, const Key &key) {
    auto it = m.find(key);
    return it != m.end() ? &it->second : nullptr;
}
 
template <typename Map, typename Key>
typename Map::mapped_type *getref(Map &m, const Key &key) {
    auto it = m.find(key);
    return it != m.end() ? &it->second : nullptr;
}
 
// Given a map and a key, return a optional<V> if the key exists and None if the
// key does not exist in the map.
template <class Map, typename Key>
std::optional<typename Map::mapped_type> get_optional(const Map &m, const Key &key) {
    auto it = m.find(key);
    if (it != m.end()) return std::optional<typename Map::mapped_type>(it->second);
 
    return {};
}
 
template <typename Map, typename Key>
typename Map::mapped_type get(const Map *m, const Key &key) {
    return m ? get(*m, key) : typename Map::mapped_type{};
}
 
template <class Map, typename Key, typename Value>
typename Map::mapped_type get(const Map *m, const Key &key, Value &&def) {
    return m ? get(*m, key, std::forward(def)) : typename Map::mapped_type{};
}
 
template <typename Map, typename Key>
const typename Map::mapped_type *getref(const Map *m, const Key &key) {
    return m ? getref(*m, key) : nullptr;
}
 
template <typename Map, typename Key>
typename Map::mapped_type *getref(Map *m, const Key &key) {
    return m ? getref(*m, key) : nullptr;
}
 
/* iterate over the keys in a map */
template <class PairIter>
class IterKeys {
    class iterator {
        PairIter it;
 
     public:
        using iterator_category = typename std::iterator_traits<PairIter>::iterator_category;
        using value_type = typename std::iterator_traits<PairIter>::value_type::first_type;
        using difference_type = typename std::iterator_traits<PairIter>::difference_type;
        using pointer = decltype(&it->first);
        using reference = decltype(*&it->first);
 
        explicit iterator(PairIter i) : it(i) {}
        iterator &operator++() {
            ++it;
            return *this;
        }
        iterator &operator--() {
            --it;
            return *this;
        }
        iterator operator++(int) {
            auto copy = *this;
            ++it;
            return copy;
        }
        iterator operator--(int) {
            auto copy = *this;
            --it;
            return copy;
        }
        bool operator==(const iterator &i) const { return it == i.it; }
        bool operator!=(const iterator &i) const { return it != i.it; }
        reference operator*() const { return it->first; }
        pointer operator->() const { return &it->first; }
    } b, e;
 
 public:
    template <class U>
    explicit IterKeys(U &map) : b(map.begin()), e(map.end()) {}
    IterKeys(PairIter b, PairIter e) : b(b), e(e) {}
    iterator begin() const { return b; }
    iterator end() const { return e; }
};
 
template <class Map>
IterKeys<typename Map::iterator> Keys(Map &m) {
    return IterKeys<typename Map::iterator>(m);
}
 
template <class Map>
IterKeys<typename Map::const_iterator> Keys(const Map &m) {
    return IterKeys<typename Map::const_iterator>(m);
}
 
template <class PairIter>
IterKeys<PairIter> Keys(std::pair<PairIter, PairIter> range) {
    return IterKeys<PairIter>(range.first, range.second);
}
 
/* iterate over the values in a map */
template <class PairIter>
class IterValues {
    class iterator {
        PairIter it;
 
     public:
        using iterator_category = typename std::iterator_traits<PairIter>::iterator_category;
        using value_type = typename std::iterator_traits<PairIter>::value_type::second_type;
        using difference_type = typename std::iterator_traits<PairIter>::difference_type;
        using pointer = decltype(&it->second);
        using reference = decltype(*&it->second);
 
        explicit iterator(PairIter i) : it(i) {}
        iterator &operator++() {
            ++it;
            return *this;
        }
        iterator &operator--() {
            --it;
            return *this;
        }
        iterator operator++(int) {
            auto copy = *this;
            ++it;
            return copy;
        }
        iterator operator--(int) {
            auto copy = *this;
            --it;
            return copy;
        }
        bool operator==(const iterator &i) const { return it == i.it; }
        bool operator!=(const iterator &i) const { return it != i.it; }
        reference operator*() const { return it->second; }
        pointer operator->() const { return &it->second; }
    } b, e;
 
 public:
    using value_type = typename std::iterator_traits<PairIter>::value_type::second_type;
 
    template <class U>
    explicit IterValues(U &map) : b(map.begin()), e(map.end()) {}
    IterValues(PairIter b, PairIter e) : b(b), e(e) {}
    iterator begin() const { return b; }
    iterator end() const { return e; }
};
 
template <class Map>
IterValues<typename Map::iterator> Values(Map &m) {
    return IterValues<typename Map::iterator>(m);
}
 
template <class Map>
IterValues<typename Map::const_iterator> Values(const Map &m) {
    return IterValues<typename Map::const_iterator>(m);
}
 
template <class PairIter>
IterValues<PairIter> Values(std::pair<PairIter, PairIter> range) {
    return IterValues<PairIter>(range.first, range.second);
}
 
/* iterate over the values for a single key in a multimap */
template <class M>
class MapForKey {
    M &map;
    typename M::key_type key;
    class iterator {
        using MapIt = decltype(map.begin());
 
        const MapForKey &self;
        MapIt it;
 
     public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = typename M::value_type;
        using difference_type = typename std::iterator_traits<MapIt>::difference_type;
        using pointer = decltype(&it->second);
        using reference = decltype(*&it->second);
 
        iterator(const MapForKey &s, MapIt i) : self(s), it(std::move(i)) {}
        iterator &operator++() {
            if (++it != self.map.end() && it->first != self.key) it = self.map.end();
            return *this;
        }
        iterator operator++(int) {
            auto copy = *this;
            ++*this;
            return copy;
        }
        bool operator==(const iterator &i) const { return it == i.it; }
        bool operator!=(const iterator &i) const { return it != i.it; }
        reference operator*() const { return it->second; }
        pointer operator->() const { return &it->second; }
    };
 
 public:
    MapForKey(M &m, typename M::key_type k) : map(m), key(k) {}
    iterator begin() const { return iterator(*this, map.find(key)); }
    iterator end() const { return iterator(*this, map.end()); }
};
 
template <class M>
MapForKey<M> ValuesForKey(M &m, typename M::key_type k) {
    return MapForKey<M>(m, k);
}
 
}  // namespace P4
 
#endif /* LIB_MAP_H_ */