FlowHashMapImplementation.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
/*********************************************************************** * This program is free software; you can
 *redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free
 *Software Foundation; either version 2 of the License, or    * (at your option) any later version. *
 *                                                                      *
 ***************************************************************************/
 
#ifndef __POPULATION_FLOW_H_INCLUDED__
#define __POPULATION_FLOW_H_INCLUDED__
 
#include <algorithm>
#include <cassert>
#include <functional>
#include <iostream> // output operator
#include <unordered_map>
 
namespace quetzal
{
namespace demography
{
template <typename Space, typename Time, typename Value> class FlowHashMapImplementation
{
  public:
    using time_type = Time;
    using coord_type = Space;
    using value_type = Value;
    FlowHashMapImplementation() = default;
    value_type flow_from_to(coord_type const &from, coord_type const &to, time_type t) const
    {
        assert(m_flows.find(key_type(t, from, to)) != m_flows.end());
        return m_flows.at(key_type(t, from, to));
    }
    void set_flow_from_to(coord_type const &from, coord_type const &to, time_type t, value_type v)
    {
        m_flows[key_type(t, from, to)] = v;
        m_reverse_flows[reverse_key_type(to, t)][from] = v;
    }
    void add_to_flow_from_to(coord_type const &from, coord_type const &to, time_type t, value_type v)
    {
        m_flows[key_type(t, from, to)] += v;
        m_reverse_flows[reverse_key_type(to, t)][from] += v;
    }
    std::unordered_map<coord_type, value_type> const &flow_to(coord_type const &x, time_type t) const
    {
        assert(flow_to_is_defined(x, t));
        return m_reverse_flows.at(reverse_key_type(x, t));
    }
    bool flow_to_is_defined(coord_type const &to, time_type const &t) const
    {
        auto it = m_reverse_flows.find(reverse_key_type(to, t));
        return it != m_reverse_flows.end();
    }
    struct key_type
    {
        time_type time;
        coord_type from;
        coord_type to;
        key_type(time_type const &t, coord_type const &origin, coord_type const &destination)
            : time(t), from(origin), to(destination)
        {
        }
        bool operator==(key_type const &other) const
        {
            return (other.time == this->time && other.from == this->from && other.to == this->to);
        }
    }; // end struct Flow::key_type
    auto begin() const
    {
        return m_flows.cbegin();
    }
    auto end() const
    {
        return m_flows.cend();
    }
 
  private:
    struct reverse_key_type
    {
        time_type time;
        coord_type to;
        reverse_key_type(coord_type const &x, time_type const &t) : time(t), to(x)
        {
        }
        bool operator==(reverse_key_type const &other) const
        {
            return (other.time == this->time && other.to == this->to);
        }
    }; // end Flow::reverse_key_type
    struct reverse_key_hash
    {
        std::size_t operator()(const reverse_key_type &k) const
        {
            size_t res = 17;
            res = res * 31 + std::hash<time_type>()(k.time);
            res = res * 31 + std::hash<coord_type>()(k.to);
            return res;
        }
    }; // end Flow::reverse_key_hash
    struct key_hash
    {
        std::size_t operator()(const key_type &k) const
        {
            size_t res = 17;
            res = res * 31 + std::hash<time_type>()(k.time);
            res = res * 31 + std::hash<coord_type>()(k.from);
            res = res * 31 + std::hash<coord_type>()(k.to);
            return res;
        }
    }; // end key_hash
  public:
    using map_type = std::unordered_map<const key_type, value_type, key_hash>;
 
  private:
    using reverse_flow_type =
        std::unordered_map<const reverse_key_type, std::unordered_map<coord_type, value_type>, reverse_key_hash>;
    map_type m_flows;
    reverse_flow_type m_reverse_flows;
}; // end class Flow
template <typename Space, typename Time, typename Value>
std::ostream &operator<<(std::ostream &stream, const FlowHashMapImplementation<Space, Time, Value> &flows)
{
    stream << "time"
           << "\t"
           << "from"
           << "\t"
           << "to"
           << "\t"
           << "flow"
           << "\n";
    for (auto const &it : flows)
    {
        stream << it.first.time << "\t" << it.first.from << "\t" << it.first.to << "\t" << it.second << "\n";
    }
    return stream;
} // end ostream operator
} // namespace demography
} // namespace quetzal
#endif