/* -*- C++ -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2003-2006

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #ifndef LEMON_STATIC_GRAPH_H

 #define LEMON_STATIC_GRAPH_H

 #include <lemon/bits/graph_extender.h>

 #include <lemon/graph_utils.h>

 namespace lemon {

   class StaticGraphBase {

   public:

     StaticGraphBase() 

       : node_num(-1), edge_num(0), 

         node_first_out(0), node_first_in(0),

         edge_source(0), edge_target(0), 

         edge_next_in(0), edge_next_out(0) {}

     ~StaticGraphBase() {

       if (node_num != -1) {

         delete[] node_first_out;

         delete[] node_first_in;

         delete[] edge_source;

         delete[] edge_target;

         delete[] edge_next_out;

         delete[] edge_next_in;

       }

     }

     class Node {

       friend class StaticGraphBase;

     protected:

       int id;

       Node(int _id) : id(_id) {}

     public:

       Node() {}

       Node (Invalid) : id(-1) {}

       bool operator==(const Node& node) const {return id == node.id;}

       bool operator!=(const Node& node) const {return id != node.id;}

       bool operator<(const Node& node) const {return id < node.id;}

     };

     class Edge {

       friend class StaticGraphBase;      

     protected:

       int id;

       Edge(int _id) : id(_id) {}

     public:

       Edge() { }

       Edge (Invalid) { id = -1; }

       bool operator==(const Edge& edge) const {return id == edge.id;}

       bool operator!=(const Edge& edge) const {return id != edge.id;}

       bool operator<(const Edge& edge) const {return id < edge.id;}

     };

     Node source(const Edge& e) const { return Node(edge_source[e.id]); }

     Node target(const Edge& e) const { return Node(edge_target[e.id]); }

     void first(Node& n) const { n.id = node_num - 1; }

     void next(Node& n) const { --n.id; }

     void first(Edge& n) const { n.id = edge_num - 1; }

     void next(Edge& n) const { --n.id; }

     void firstOut(Edge& e, const Node& n) const { 

       e.id = node_first_out[n.id] != node_first_out[n.id + 1] ? 

         node_first_out[n.id] : -1;

     }

     void nextOut(Edge& e) const { e.id = edge_next_out[e.id]; }

     void firstIn(Edge& e, const Node& n) const { e.id = node_first_in[n.id]; }

     void nextIn(Edge& e) const { e.id = edge_next_in[e.id]; }

     int id(const Node& n) const { return n.id; }

     Node nodeFromId(int id) const { return Node(id); }

     int maxNodeId() const { return node_num - 1; }

     int id(const Edge& e) const { return e.id; }

     Edge edgeFromId(int id) const { return Edge(id); }

     int maxEdgeId() const { return edge_num - 1; }

     typedef True NodeNumTag;

     int nodeNum() const { return node_num; }

     typedef True EdgeNumTag;

     int edgeNum() const { return edge_num; }

   private:

     template <typename Graph, typename NodeRefMap>

     class EdgeLess {

     public:

       typedef typename Graph::Edge Edge;

       EdgeLess(const Graph &_graph, const NodeRefMap& _nodeRef) 

         : graph(_graph), nodeRef(_nodeRef) {}

       bool operator()(const Edge& left, const Edge& right) const {

 	return nodeRef[graph.target(left)] < nodeRef[graph.target(right)];

       }

     private:

       const Graph& graph;

       const NodeRefMap& nodeRef;

     };

   public:

     typedef True CloneableTag;

     template <typename Graph, typename NodeRefMap, typename EdgeRefMap>

     void clone(const Graph& graph, NodeRefMap& nodeRef, EdgeRefMap& edgeRef) {

       if (node_num != -1) {

         delete[] node_first_out;

         delete[] node_first_in;

         delete[] edge_source;

         delete[] edge_target;

         delete[] edge_next_out;

         delete[] edge_next_in;

       }

       typedef typename Graph::Node GNode;

       typedef typename Graph::Edge GEdge;

       node_num = countNodes(graph);

       edge_num = countEdges(graph);

       node_first_out = new int[node_num + 1];

       node_first_in = new int[node_num];

       edge_source = new int[edge_num];

       edge_target = new int[edge_num];

       edge_next_out = new int[edge_num];

       edge_next_in = new int[edge_num];

       int node_index = 0;

       for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {

         nodeRef[n] = Node(node_index);

         node_first_in[node_index] = -1;

         ++node_index;

       }

       EdgeLess<Graph, NodeRefMap> edgeLess(graph, nodeRef);

       int edge_index = 0;

       for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {

         int source = nodeRef[n].id;

         std::vector<GEdge> edges;

         for (typename Graph::OutEdgeIt e(graph, n); e != INVALID; ++e) {

           edges.push_back(e);

         }

         if (!edges.empty()) {

           node_first_out[source] = edge_index;

           std::sort(edges.begin(), edges.end(), edgeLess);

           for (typename std::vector<GEdge>::iterator it = edges.begin();

                it != edges.end(); ++it) {

             int target = nodeRef[graph.target(*it)].id;

             edgeRef[*it] = Edge(edge_index);

             edge_source[edge_index] = source; 

             edge_target[edge_index] = target;

             edge_next_in[edge_index] = node_first_in[target];

             node_first_in[target] = edge_index;

             edge_next_out[edge_index] = edge_index + 1;

             ++edge_index;

           }

           edge_next_out[edge_index - 1] = -1;

         } else {

           node_first_out[source] = edge_index;

         }

       }

       node_first_out[node_num] = edge_num;

     }

   protected:

     void fastFirstOut(Edge& e, const Node& n) const {

       e.id = node_first_out[n.id];

     }

     static void fastNextOut(Edge& e) {

       ++e.id;

     }

     void fastLastOut(Edge& e, const Node& n) const {

       e.id = node_first_out[n.id + 1];

     }

   private:

     int node_num;

     int edge_num;

     int *node_first_out;

     int *node_first_in;

     int *edge_source;

     int *edge_target;

     int *edge_next_in;

     int *edge_next_out;

   };

   typedef GraphExtender<StaticGraphBase> ExtendedStaticGraphBase;

   class StaticGraph : public ExtendedStaticGraphBase {

   public:

     typedef ExtendedStaticGraphBase Parent;

   protected:

     using Parent::fastFirstOut;

     using Parent::fastNextOut;

     using Parent::fastLastOut;

   public:

     class OutEdgeIt : public Edge {

     public:

       OutEdgeIt() { }

       OutEdgeIt(Invalid i) : Edge(i) { }

       OutEdgeIt(const StaticGraph& graph, const Node& node) {

 	graph.fastFirstOut(*this, node);

 	graph.fastLastOut(last, node);

         if (last == *this) *this = INVALID;

       }

       OutEdgeIt(const StaticGraph& graph, const Edge& edge) : Edge(edge) {

         graph.fastLastOut(last, graph.source(edge));

       }

       OutEdgeIt& operator++() { 

         StaticGraph::fastNextOut(*this);

         if (last == *this) *this = INVALID;

         return *this; 

       }

     private:

       Edge last;

     };

   };

 }

 #endif