Counter.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <cstdint>
#include <unordered_map>
#include <utility>
#include <vector>

#include <glog/logging.h>

namespace tdc {

template<class T>
class Counter {

    std::unordered_map<T, size_t> map;

public:
    typedef std::unordered_map<T, size_t> ranking_t;

    void increase(const T& item) {
        // Indexing is defined as inserting and returning 0
        // in case of missing entry in the map.
        size_t prev_value = map[item];
        map[item] = prev_value + 1;
    }

    void setCount(const T& item, size_t count) {
        map[item] = count;
    }

    size_t getCount(const T& item) {
        return map[item];
    }

    size_t getNumItems() {
        return map.size();
    }

    std::vector<std::pair<T, size_t>> getSorted() {
        std::vector<std::pair<T, size_t>> v(map.begin(), map.end());
        std::sort(v.begin(), v.end(), [] (
            std::pair<T, size_t> a, std::pair<T, size_t> b
        ) {
            // TODO: Only compare first in debug mode to get deterministic output
            if (a.second != b.second) {
                return a.second > b.second;
            } else {
                return a.first < b.first;
            }
        });

        /*
        DLOG(INFO) << "getSorted() [";
        for(auto e : v) {
            DLOG(INFO) << "  " << e.first << " " << e.second;
        }
        DLOG(INFO) << "]";
        */

        return v;
    }

    ranking_t createRanking(size_t num = SIZE_MAX) {
        ranking_t r(num + 1);
        size_t i = 0;
        for (auto pair : getSorted()) {
            r[pair.first] = i++;
            if (i >= num) {
                break;
            }
        }
        return r;
    }
};

}