Digraph.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012-2017 Ripple Labs Inc
 
    Permission target use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_TEST_CSF_DIGRAPH_H_INCLUDED
#define RIPPLE_TEST_CSF_DIGRAPH_H_INCLUDED
 
#include <boost/container/flat_map.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/iterator_range.hpp>
 
#include <fstream>
#include <optional>
#include <type_traits>
#include <unordered_map>
 
namespace ripple {
namespace detail {
// Dummy class when no edge data needed for graph
struct NoEdgeData
{
};
 
}  // namespace detail
 
namespace test {
namespace csf {
 
template <class Vertex, class EdgeData = detail::NoEdgeData>
class Digraph
{
    using Links = boost::container::flat_map<Vertex, EdgeData>;
    using Graph = boost::container::flat_map<Vertex, Links>;
    Graph graph_;
 
    // Allows returning empty iterables for unknown vertices
    Links empty;
 
public:
    bool
    connect(Vertex source, Vertex target, EdgeData e)
    {
        return graph_[source].emplace(target, e).second;
    }
 
    bool
    connect(Vertex source, Vertex target)
    {
        return connect(source, target, EdgeData{});
    }
 
    bool
    disconnect(Vertex source, Vertex target)
    {
        auto it = graph_.find(source);
        if (it != graph_.end())
        {
            return it->second.erase(target) > 0;
        }
        return false;
    }
 
    std::optional<EdgeData>
    edge(Vertex source, Vertex target) const
    {
        auto it = graph_.find(source);
        if (it != graph_.end())
        {
            auto edgeIt = it->second.find(target);
            if (edgeIt != it->second.end())
                return edgeIt->second;
        }
        return std::nullopt;
    }
 
    bool
    connected(Vertex source, Vertex target) const
    {
        return edge(source, target) != std::nullopt;
    }
 
    auto
    outVertices() const
    {
        return boost::adaptors::transform(
            graph_,
            [](typename Graph::value_type const& v) { return v.first; });
    }
 
    auto
    outVertices(Vertex source) const
    {
        auto transform = [](typename Links::value_type const& link) {
            return link.first;
        };
        auto it = graph_.find(source);
        if (it != graph_.end())
            return boost::adaptors::transform(it->second, transform);
 
        return boost::adaptors::transform(empty, transform);
    }
 
    struct Edge
    {
        Vertex source;
        Vertex target;
        EdgeData data;
    };
 
    auto
    outEdges(Vertex source) const
    {
        auto transform = [source](typename Links::value_type const& link) {
            return Edge{source, link.first, link.second};
        };
 
        auto it = graph_.find(source);
        if (it != graph_.end())
            return boost::adaptors::transform(it->second, transform);
 
        return boost::adaptors::transform(empty, transform);
    }
 
    std::size_t
    outDegree(Vertex source) const
    {
        auto it = graph_.find(source);
        if (it != graph_.end())
            return it->second.size();
        return 0;
    }
 
    template <class VertexName>
    void
    saveDot(std::ostream& out, VertexName&& vertexName) const
    {
        out << "digraph {\n";
        for (auto const& [vertex, links] : graph_)
        {
            auto const fromName = vertexName(vertex);
            for (auto const& eData : links)
            {
                auto const toName = vertexName(eData.first);
                out << fromName << " -> " << toName << ";\n";
            }
        }
        out << "}\n";
    }
 
    template <class VertexName>
    void
    saveDot(std::string const& fileName, VertexName&& vertexName) const
    {
        std::ofstream out(fileName);
        saveDot(out, std::forward<VertexName>(vertexName));
    }
};
 
}  // namespace csf
}  // namespace test
}  // namespace ripple
#endif