/home/marcvs/Desktop/working/pa-materiale/pa/codeBase/C++/include/GraphAdjMat.h

#ifndef __GRAPHADJMAT_H__
#define __GRAPHADJMAP_H__

#pragma once

#include <iostream>
#include <fstream>
#include <vector>
#include <stack>
#include <cstring>

class GraphAdjMat {

private:
        unsigned int n;

        bool directed;

        int ** edges;
        
        int ** detour;

public: 

        static const int NONE = -1;
        
        typedef std::vector< std::pair< std::pair<int, int>, int> > Path;

        inline GraphAdjMat(unsigned int n, bool directed = true) :
                n(n), 
                directed(directed)
        {
                edges = new int*[n];
                detour = new int*[n];
                for (unsigned int i = 0; i < n; i++) {
                        edges[i] = new int[n];
                        detour[i] = new int[n];
                        for (unsigned int j = 0; j < n; j++) {
                                edges[i][j] = NONE;
                                detour[i][j] = NONE;
                        }
                }
        }
        
        inline void clear_paths(){
                for (unsigned int i = 0; i < n; i++) {
                        for (unsigned int j = 0; j < n; j++) {
                                detour[i][j] = NONE;
                        }
                }
        }
        
        inline unsigned int get_n() const {
                return n;
        }

        inline int get_edge(int a, int b) const {
                return edges[a][b];
        }
        
        inline void set_edge(int a, int b, int cost) {
                edges[a][b] = cost;
                if (directed == false) {
                        edges[b][a] = cost;
                }
        }
        
        inline void erase_edge(int a, int b) {
                set_edge(a,b, NONE);
        }
        
        inline void set_detour(int a, int b, int det) {
                detour[a][b] = det;
                if (directed == false) {
                        detour[b][a] = det;
                }
        }
        
        inline Path path(int a, int b) const {
                Path returnValue;
                std::stack< std::pair<int,int> > track;
                track.push(std::pair<int,int>(a,b));
                while (!track.empty()){
                        a = track.top().first;
                        b = track.top().second;
                        track.pop();
                        if (detour[a][b] == NONE){
                                if (edges[a][b] == NONE){
                                        std::cerr << "Broken path! No edge from " << a << " to " << b << "!" << std::endl;
                                        returnValue.clear();
                                        break;
                                } else {
                                        returnValue.push_back(std::pair< std::pair<int,int>, int>(std::pair<int,int>(a,b), edges[a][b]));
                                }
                        } else {
                                track.push(std::pair<int,int>(detour[a][b], b));
                                track.push(std::pair<int,int>(a, detour[a][b]));
                        }
                }
                return returnValue;
        }
        
        friend std::ostream& operator<< (std::ostream& out, Path & path);       
        friend std::ostream& operator<< (std::ostream& out, GraphAdjMat & graph);
        friend std::istream& operator>> (std::istream& in, GraphAdjMat & graph);
        
        ~GraphAdjMat() {
                for (unsigned int i = 0; i < n; i++) {
                        delete[] edges[i];
                        delete[] detour[i];
                }
                delete[] edges;
                delete[] detour;
        }
};

std::ostream& operator<< (std::ostream& out, const GraphAdjMat::Path & path);

std::ostream& operator<< (std::ostream& out, const GraphAdjMat & graph);

std::istream& operator>> (std::istream& out, const GraphAdjMat & graph);

#endif