routing.h

/*
 * vim: ts=4 sw=4 et tw=0 wm=0
 *
 * libdialect - A library for computing DiAlEcT layouts:
 *                 D = Decompose/Distribute
 *                 A = Arrange
 *                 E = Expand/Emend
 *                 T = Transform
 *
 * Copyright (C) 2018  Monash University
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * See the file LICENSE.LGPL distributed with the library.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Author(s):   Steve Kieffer   <http://skieffer.info>
*/

#ifndef DIALECT_ROUTING_H
#define DIALECT_ROUTING_H

#include <map>
#include <string>
#include <vector>
#include <utility>

#include "libavoid/libavoid.h"

#include "libdialect/commontypes.h"
#include "libdialect/opts.h"
#include "libdialect/ortho.h"
#include "libdialect/logging.h"

namespace dialect {

typedef std::pair<Avoid::ConnDirFlags, Avoid::ConnDirFlags> EdgeConnDirs;
typedef std::map<id_type, EdgeConnDirs> EdgeConnDirsById;

enum class RouteProcessing {
    NONE,
    RECORD,
    REFINE_AND_RECORD
};

struct RoutingAdapter {

    RoutingAdapter(Avoid::RouterFlag flag) : router(flag) {}

    void addNodes(const NodesById &nodes);

    void addEdges(const EdgesById &edges, const EdgeConnDirsById *connDirs = nullptr);

    void route(RouteProcessing processing = RouteProcessing::RECORD);

    void recordRoutes(bool refine = false);

    Avoid::Router router;
    EdgesById edges;
    std::map<id_type, Avoid::ConnRef*> edgeIdToConnRef;
    std::map<id_type, Avoid::ShapeRef*> nodeIdToShapeRef;
};


class LeaflessOrthoRouter {
public:
    LeaflessOrthoRouter(Graph_SP G, const HolaOpts &opts);

    ~LeaflessOrthoRouter(void) {
        /*  The only newly allocated objects are the ConnRefs and ShapeRefs allocated
         *  in the constructor.
         *
         *  But the libavoid::Router takes responsibility for these, and frees them
         *  all in its own destructor.
         *
         *  Since we keep a Router instance, not a pointer, our Router is automatically
         *  destroyed when this LeaflessOrthoRouter is destroyed.
         *
         *  So there is nothing for us to do.
         */
    }

    void route(Logger *logger = nullptr);

    void setShapeBufferDistanceIELScalar(double a);

    bool recordEachAttempt = false;
    std::vector<std::string> routingAttemptTglf;

private:

    CardinalDir departureDir(const Edge_SP &e, const Node_SP &u) const;

    inline bool isSoleDirec(Avoid::ConnDirFlags dirs) const {
        return dirs == Avoid::ConnDirUp || dirs == Avoid::ConnDirUp || dirs == Avoid::ConnDirLeft || dirs == Avoid::ConnDirRight;
    }

    Graph_SP m_graph;
    size_t m_n; // number of nodes in the graph
    RoutingAdapter m_ra;
    double m_iel;

    SparseIdMatrix2d<Avoid::ConnDirFlags>::type m_allowedConnDirs;

};




} // namespace dialect

#endif // DIALECT_ROUTING_H