test_indexedgraph.cxx

Go to the documentation of this file.

#include "WireCellUtil/IndexedGraph.h"
#include "WireCellUtil/Testing.h"

#include <boost/graph/graphviz.hpp>

using namespace WireCell;

char foo(size_t ind)
{
    return "if"[ind];
}

typedef std::shared_ptr<int> iptr_t;
typedef std::shared_ptr<float> fptr_t;
typedef std::variant<iptr_t, fptr_t> if_t;

struct if_node_t {
    if_t ptr;
    if_node_t() : ptr() { }
    if_node_t(const if_t& ift) : ptr(ift) { }
    if_node_t(const iptr_t& i) : ptr(i) { }
    if_node_t(const fptr_t& f) : ptr(f) { }
        
    bool operator==(const if_node_t &other) const {
        return ptr == other.ptr;
    }
};


namespace std {
    template<>
    struct hash<if_node_t> {
        std::size_t operator()(const if_node_t& n) const {
            if (std::holds_alternative<iptr_t>(n.ptr)) {
                return (size_t)(std::get<iptr_t>(n.ptr).get());
            }
            if (std::holds_alternative<fptr_t>(n.ptr)) {
                return (size_t)(std::get<fptr_t>(n.ptr).get());
            }
            return 0;
        }
    };
}

int main()
{


    std::unordered_map<if_t, int> p2i;

    typedef IndexedGraph<if_node_t> indexed_graph_t;
    indexed_graph_t g;
    if_t one = std::make_shared<int>(42);
    if_t two = std::make_shared<float>(6.9);
    if_t tre = std::make_shared<float>(33);

    p2i[one] = 1;
    p2i[two] = 2;
    p2i[tre] = 3;

    // test variant
    Assert(1 == tre.index());
    Assert(*std::get<1>(two) < *std::get<1>(tre));
    Assert(one < two);      // caution: compares against indices first!
    Assert(*std::get<0>(one) == 42);
    Assert(nullptr == std::get_if<1>(&one));
    Assert('i' == foo(0));
    Assert('f' == foo(1));

    if_t oneprime = one;
    Assert(one == oneprime);

    auto v1 = g.vertex(one);
    auto v2 = g.vertex(one);
    Assert(v1 == v2);
    g.edge(one, two);
    g.edge(one, two);
    g.edge(two, one);
    g.edge(one, tre);
    auto verts = boost::vertices(g.graph());
    Assert(verts.second-verts.first == 3);

    Assert(g.has(oneprime));

    indexed_graph_t g2(g.graph());

    for (auto n : g2.neighbors(two)) {
        Assert(g2.has(n));
    }



    std::vector<std::string> names{"one","two","tre"};
    std::unordered_map<indexed_graph_t::vdesc_t, std::string> ids;
    for (auto u : boost::make_iterator_range(vertices(g2.graph()))) {
        ids[u] = names[ids.size()];
    }
    boost::default_writer w;
    boost::write_graphviz(std::cout,
                          g2.graph(),
                          w,w,w,
                          boost::make_assoc_property_map(ids));

    return 0;

}