include/Utilities/graphIO.h

#ifndef GRAPHIO_H
#define GRAPHIO_H

#include <vector>
#include <Utilities/progressBar.h>
#include <Structs/Arrays/nodeArray.h>
#include <assert.h>
#include <sstream>

//--------------------------------------- READERS --------------------------------------//

template<typename GraphType>
class GraphReader
{
public:
    GraphReader( const std::string& filename):m_filename(filename)
    {
    }
    
    std::vector< typename GraphType::NodeDescriptor>& getIds()
    {
        return m_ids;
    }

    virtual void read( GraphType& G)
    {
    }
protected:
    std::string m_filename; 
    std::vector< typename GraphType::NodeDescriptor> m_ids;
};


template<typename GraphType>
class GMLReader : public GraphReader<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::EdgeDescriptor  EdgeDescriptor;
    typedef typename GraphType::SizeType        SizeType;

    GMLReader( const std::string& filename):GraphReader<GraphType>(filename)
    {
    }

    void read( GraphType& G)
    {
        std::ifstream in;
        std::string token;
        std::cout << "Reading GML from " << GraphReader<GraphType>::m_filename << std::endl;
        GraphReader<GraphType>::m_ids.clear();
        in.exceptions ( std::ifstream::failbit | std::ifstream::badbit );
        
        try {
            in.open( GraphReader<GraphType>::m_filename.c_str());
            
            if (in.is_open())
            {
                in.exceptions ( std::ios_base::goodbit);
                while ( in.good() && !in.eof() )
                {
                    in >> token;
                    //std::cout << token << '\n';
                    if( !token.compare("node"))
                    {
                        readNode( G, in);
                    }
                    if( !token.compare("edge"))
                    {
                        readEdge( G, in);
                    }
                }
                in.close();
            }            
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/reading file '" << GraphReader<GraphType>::m_filename << "'\n";
            throw e;
        }
    }

    void readNode(GraphType& G, std::ifstream& in)
    {
        std::string token,value;
        NodeIterator u;
        NodeDescriptor uD;
        
        uD = G.insertNode();
        GraphReader<GraphType>::m_ids.push_back(uD);
        u = G.getNodeIterator(uD);

        in >> token;
        in >> token;
     
        while( token.compare("]"))
        {
            in >> value;
            u->setProperty( token, value);
            in >> token;
        }
    }

    void readEdge(GraphType& G, std::ifstream& in)
    {
        std::string token,value;
        unsigned int source,target;
        EdgeIterator e;
        EdgeDescriptor eD;

        in >> token;
        in >> token;
        if( !token.compare("source"))
        {
            in >> source;
        }

        in >> token;

        if( !token.compare("target"))
        {
            in >> target;
        }

        eD = G.insertEdge( GraphReader<GraphType>::m_ids[source], GraphReader<GraphType>::m_ids[target]);
        e = G.getEdgeIterator(eD);

        in >> token;

        while( token.compare("]"))
        {
            in >> value;
            e->setProperty( token, value);
            in >> token;
        }
    }

};


template<typename GraphType>
class DIMACS10Reader : public GraphReader<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::EdgeDescriptor  EdgeDescriptor;
    typedef typename GraphType::SizeType        SizeType;
    
    DIMACS10Reader( const std::string& filename, const std::string& coordinatesFilename):GraphReader<GraphType>(filename),m_coordinatesFilename(coordinatesFilename)
    {
    }
    
    void read( GraphType& G)
    {
        GraphReader<GraphType>::m_ids.clear();
        std::string token;
        SizeType numNodes, numEdges, source, target,edgeId, x, y;
        NodeDescriptor uD;
        NodeIterator u,end;
        EdgeDescriptor eD;
        EdgeIterator e;
        std::ifstream in;
        in.exceptions ( std::ifstream::failbit | std::ifstream::badbit );
        
        try {
            in.open( GraphReader<GraphType>::m_filename.c_str());
            assert( in.good());
            
            while (getline(in,token)) 
            {
                
                if( token.c_str()[0] == '%') continue;
                //std::cout << "Token: " << token << std::endl;
                std::stringstream graphinfo;
                graphinfo.str(token);   
                graphinfo >> numNodes >> numEdges;             
                break;
            }
    
            G.reserve( numNodes, numEdges << 1);
            G.memUsage();

            std::stringstream nodestream;
            nodestream << "Reading " << numNodes << " nodes";
            ProgressBar node_progress( numNodes,nodestream.str());
            GraphReader<GraphType>::m_ids.push_back(NodeDescriptor());
            
            for( SizeType i = 0; i < numNodes; ++i)
            {
                uD = G.insertNode();
                //G.insertEdge(uD,uD);
                //u = G.getNodeIterator(uD);
                //u->setId( i);
                GraphReader<GraphType>::m_ids.push_back(uD);
                ++node_progress;
            }

            /*for( u = G.beginNodes(), end = G.endNodes(); u != end; ++u)
            {
                V.push_back( u->getDescriptor());
            }*/

            std::stringstream edgestream;
            edgestream << "Reading " << numEdges << " edges";
            ProgressBar edge_progress(numNodes,edgestream.str());

            edgeId = 0;
            for( source = 1; source <= numNodes; ++source)
            {
                getline(in,token);
                while( token.c_str()[0] == '%') getline(in,token);
                std::stringstream edgeinfo;
                edgeinfo.str(token);    
                while( edgeinfo.good())
                {               

                    //NodeIterator u = G.getNodeIterator(V[source]);
                    //std::cout << G.getId(u) << std::endl;
                    edgeinfo >> target;
                    eD = G.insertEdge( GraphReader<GraphType>::m_ids[source], GraphReader<GraphType>::m_ids[target]);  
                    //e = G.getEdgeIterator(eD);
                    //e->setId( edgeId++);
                }

                ++edge_progress;  
            }
            in.close();
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/reading file '" << GraphReader<GraphType>::m_filename << "'\n";
            throw e;
        }
        
        try {
            in.open( m_coordinatesFilename.c_str());
            assert( in.good());

            for( source = 1; source <= numNodes; ++source)
            {
                in >> x >> y >> token;
                u = G.getNodeIterator( GraphReader<GraphType>::m_ids[source]);
                u->x = x;
                u->y = y;
            }

            in.close();
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/reading file '" << m_coordinatesFilename << "'\n";
            throw e;
        }

    } 
private:
    std::string m_coordinatesFilename;
};


template<typename GraphType>
class DIMACS9Reader : public GraphReader<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::EdgeDescriptor  EdgeDescriptor;
    typedef typename GraphType::SizeType        SizeType;
    
    DIMACS9Reader( const std::string& filename):GraphReader<GraphType>(filename)
    {
    }
    
    void read( GraphType& G)
    {
        std::ifstream in;
        in.exceptions ( std::ifstream::failbit | std::ifstream::badbit );
        SizeType nodeId = 0;
        SizeType edgeId = 0;
        try {
            in.open( GraphReader<GraphType>::m_filename.c_str());
            assert( in.good());

            std::string token, dummy1, dummy2;
            SizeType numNodes, numEdges, source, target,edgeId;
            std::vector<NodeDescriptor> V;
            NodeDescriptor uD;
            NodeIterator u;
            EdgeDescriptor eD;
            EdgeIterator e;
            

            while (getline(in,token)) 
            {
                if( (token.c_str()[0] != 'p') ) continue;
                //std::cout << "Token: " << token << std::endl;
                std::stringstream graphinfo;
                graphinfo.str(token);   
                graphinfo >> dummy1 >> dummy2 >> numNodes >> numEdges;             
                break;
            }
    
            std::stringstream nodestream;
            nodestream << "Reading " << numNodes << " nodes";
            ProgressBar node_progress( numNodes,nodestream.str());
            V.push_back(NodeDescriptor());
            
            for( nodeId = 0; nodeId < numNodes; ++nodeId)
            {
                uD = G.insertNode();
                u = G.getNodeIterator(uD);
                V.push_back(uD);
                ++node_progress;
            }

            std::stringstream edgestream;
            edgestream << "Reading " << numEdges << " edges";
            ProgressBar edge_progress(numEdges,edgestream.str());

            edgeId = 0;
            unsigned int weight;

            
            while ( !in.eof()) 
            {
                getline(in,token);
                //std::cout << token << "\n";
                //std::cout << token << "\n";
                
                /*if( edgeId == 0)  
                {
                    std::cout << token << "\n";
                }*/

                if( (token.c_str()[0] != 'a') )
                {
                    //std::cout << "Error!\n";                 
                    continue;
                }

                std::stringstream edgeinfo;
                edgeinfo.str(token);  
     
                while( edgeinfo.good())
                {               
                    edgeinfo >> dummy1 >> source >> target >> weight;
                    if( !G.edgeExists( V[source], V[target]))
                    {
                    eD = G.insertEdge( V[source], V[target]);  
                    e = G.getEdgeIterator(eD);
                    e->setId( edgeId);
                    //std::cout << edgeId << "\n";
                    }
                    edgeId++;
                    //std::cout << edgeId << "\n";
                    ++edge_progress;  
                }
                if( edgeId + 1 == numEdges)
                    break;
            }

            in.close();
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/reading file '" << GraphReader<GraphType>::m_filename << "'\n";
            std::cerr << "Have already read " << nodeId << " nodes and " << edgeId << " edges\n";
            throw e;
        }
    } 
};

template<typename GraphType>
class GraphWinReader : public GraphReader<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::SizeType        SizeType;
    
    GraphWinReader( const std::string& filename):GraphReader<GraphType>(filename)
    {
    }
    
    void read( GraphType& G)
    {
        std::ifstream in;
        in.exceptions ( std::ifstream::failbit | std::ifstream::badbit );
        try {
            in.open( GraphReader<GraphType>::m_filename.c_str());
            assert( in.good());
            SizeType numNodes, numEdges, source, target;
            std::vector<NodeDescriptor> V;
        
            for( unsigned int i = 0; i < 4; i++)
            {
                in.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
            }   
            
            in >> numNodes;
            std::stringstream nodestream;
            nodestream << "Reading " << numNodes << " nodes";
            ProgressBar node_progress( numNodes,nodestream.str());
            V.push_back(NodeDescriptor());
            
            for( SizeType i = 0; i < numNodes; ++i)
            {
                V.push_back(G.insertNode());
                in.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
                ++node_progress;
            }
            in.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
        
            in >> numEdges;
            std::stringstream edgestream;
            edgestream << "Reading " << numEdges << " edges";
            ProgressBar edge_progress(numEdges,edgestream.str());
            for( SizeType i = 0; i < numEdges; ++i)
            {
                in >> source;
                in >> target;
                std::cout << source << " " << target << "\n";
                G.insertEdge( V[source], V[target]);
                in.ignore(std::numeric_limits<std::streamsize>::max(),'\n');
                ++edge_progress;
            }
            std::cout << "\rReading edges...done!\n";
            in.close();
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/reading file '" << GraphReader<GraphType>::m_filename << "'\n";
            throw e;
        }
    } 
};


//--------------------------------------- WRITERS --------------------------------------//

template<typename GraphType>
class GraphWriter
{
public:
    GraphWriter( const std::string& filename):m_filename(filename)
    {
    }
    
    virtual void write( GraphType& G)
    {
    } 
protected:
    std::string m_filename;
};

template<typename GraphType>
class GraphVizWriter : public GraphWriter<GraphType>
{
public:
    
    typedef typename GraphType::NodeIterator NodeIterator;
    typedef typename GraphType::EdgeIterator EdgeIterator;
    typedef typename GraphType::SizeType SizeType;
    
    GraphVizWriter( const std::string& filename):GraphWriter<GraphType>(filename)
    {
    }
    
    virtual void write( GraphType& G)
    {
        std::ofstream out;
        out.exceptions ( std::ofstream::failbit | std::ofstream::badbit );
        try { 
            out.open( GraphWriter<GraphType>::m_filename.c_str());
            out << "digraph BFS {\n\tedge [len=3]\n\tnode  [fontname=\"Arial\"]\n";

            NodeIterator u,v,lastnode;
            EdgeIterator e,lastedge;
            
            //G.addNodeProperty( "dotId", false); 

            NodeArray<SizeType, GraphType> dotId( &G,std::numeric_limits<SizeType>::max());

            SizeType i = 0;
            
            std::stringstream nodestream;
            nodestream << "Writing out " << G.getNumNodes() << " nodes";
            ProgressBar node_progress( G.getNumNodes(),nodestream.str());

            for( u = G.beginNodes(), lastnode = G.endNodes(); u != lastnode; ++u, ++i)  
                {
                out << i;
                //G.setProperty( u, "dotId", i);
                dotId[u] = i;

                //assert(G.getProperty( u, "dotId") == dotId[u]);

                        out << "[label=\"" << G.getRelativePosition(u) << " ";
                u->print(out);    
                out << "\"]\n"; 
                ++node_progress;
            }

            std::stringstream edgestream;
            edgestream << "Writing out " << G.getNumEdges() << " edges";
            ProgressBar edge_progress( G.getNumEdges(),edgestream.str());

            for( u = G.beginNodes(), lastnode = G.endNodes(); u != lastnode; ++u)
            {
                    for( e = G.beginEdges(u), lastedge = G.endEdges(u); e != lastedge; ++e)
                    {
                    v = G.target(e);
                    //out << G.getProperty( u, "dotId") << "->" << G.getProperty( v, "dotId");
                    out << dotId[u] << "->" << dotId[v];
                            out << "[label=\"" ;
                    e->print(out);
                        out << "\"]\n";
                    ++edge_progress;
                    }
            }

            //G.removeNodeProperty( "dotId");

            out << "}";
            out.close(); 
        }
        catch (std::ofstream::failure e) {
            std::cout << "Exception opening/writing file '" << GraphWriter<GraphType>::m_filename << "'\n";
            throw e;
        }
    } 
};

template<typename GraphType>
class GMLWriter : public GraphWriter<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::EdgeDescriptor  EdgeDescriptor;
    typedef typename GraphType::SizeType        SizeType;

    GMLWriter( const std::string& filename):GraphWriter<GraphType>(filename)
    {
    }

    void write( GraphType& G)
    {
        std::ofstream out;
        std::cout << "Writing GML to " << GraphWriter<GraphType>::m_filename << std::endl;
        V.clear();
        out.exceptions ( std::ofstream::failbit | std::ofstream::badbit );
        
        try {
            out.open( GraphWriter<GraphType>::m_filename.c_str());
            
            if (out.is_open())
            {
                out.exceptions ( std::ios_base::goodbit);

                std::stringstream node_stream, edge_stream;
                node_stream << "Writing " << G.getNumNodes() << " nodes";
                edge_stream << "Writing " << G.getNumEdges() << " edges";
                ProgressBar node_progress( G.getNumNodes(),node_stream.str());  
                ProgressBar edge_progress( G.getNumEdges(),edge_stream.str());                  

                out << "graph [\n";
                
                NodeIterator u, lastNode;
                EdgeIterator e, lastEdge;

                nodeId = 0;
                for( u = G.beginNodes(), lastNode = G.endNodes(); u != lastNode; ++u)
                {
                    writeNode( G, u, out);
                    ++node_progress;
                }
                
                for( u = G.beginNodes(), lastNode = G.endNodes(); u != lastNode; ++u)
                {
                    for( e = G.beginEdges(u), lastEdge = G.endEdges(u); e != lastEdge; ++e) 
                    { 
                        writeEdge( G, u, e, out);
                        ++edge_progress;
                    }
                }
                           
                out << "]\n";

                out.close();
            }            
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/writing file '" << GraphWriter<GraphType>::m_filename << "'\n";
            throw e;
        }
    }

    void writeNode(GraphType& G, NodeIterator& u, std::ofstream& out)
    {
        out << "node [" << std::endl;
        out << "id " << nodeId++ << "\n";
        u->writeProperties(out);
        out << "]" << std::endl;
    }

    void writeEdge(GraphType& G, NodeIterator& u, EdgeIterator& e, std::ofstream& out)
    {
        out << "edge [" << std::endl;
        out << "source " << G.getRelativePosition(u) << std::endl; 
        NodeIterator v = G.target(e);
        out << "target " << G.getRelativePosition(v) << std::endl; 
        e->writeProperties(out);
        out << "]" << std::endl;
    }

private:
    std::vector<NodeDescriptor> V;
    unsigned int nodeId;
};


template<typename GraphType>
class JSONWriter : public GraphWriter<GraphType>
{
public:
    typedef typename GraphType::NodeIterator    NodeIterator;
    typedef typename GraphType::EdgeIterator    EdgeIterator;
    typedef typename GraphType::NodeDescriptor  NodeDescriptor;
    typedef typename GraphType::EdgeDescriptor  EdgeDescriptor;
    typedef typename GraphType::SizeType        SizeType;

    JSONWriter( const std::string& filename):GraphWriter<GraphType>(filename)
    {
    }

    void write( GraphType& G)
    {
        std::ofstream out;
        std::cout << "Writing JSON to " << GraphWriter<GraphType>::m_filename << std::endl;
        V.clear();
        out.exceptions ( std::ofstream::failbit | std::ofstream::badbit );
        
        try {
            out.open( GraphWriter<GraphType>::m_filename.c_str());
            
            if (out.is_open())
            {
                out.exceptions ( std::ios_base::goodbit);
                std::stringstream node_stream, edge_stream;
                node_stream << "Writing " << G.getNumNodes() << " nodes";
                edge_stream << "Writing " << G.getNumEdges() << " edges";
                ProgressBar node_progress( G.getNumNodes(),node_stream.str());  
                ProgressBar edge_progress( G.getNumEdges(),edge_stream.str());                


                out << "{\n\"graph\": [\n";
                
                NodeIterator u, w, lastNode;
                EdgeIterator e, k, lastEdge;

                out << "\"nodes\": [\n";
                
                nodeId = 0;
                w = G.beginNodes();
                ++w;
                for( u = G.beginNodes(), lastNode = G.endNodes(); u != lastNode; ++u, ++w)
                {
                    writeNode( G, u, out);
                    ++node_progress;
                    if( w != lastNode) out << ",";
                    out << "\n";
                }
                
                out << "],\n\"edges\": [\n";
                
                w = G.beginNodes();
                ++w;
                for( u = G.beginNodes(), lastNode = G.endNodes(); u != lastNode; ++u)
                {
                    k = G.beginEdges(u);
                    ++k;
                    for( e = G.beginEdges(u), lastEdge = G.endEdges(u); e != lastEdge; ++e) 
                    { 
                        writeEdge( G, u, e, out);
                        ++edge_progress;
                        if( w != lastNode) out << ",";
                        else
                        {
                            if( k != lastEdge) out << ",";
                        }
                        out << "\n";
                    }
                }
                           
                out << "}\n";

                out.close();
            }            
        }
        catch (std::ifstream::failure e) {
            std::cerr << "Exception opening/writing file '" << GraphWriter<GraphType>::m_filename << "'\n";
            throw e;
        }
    }

    void writeNode(GraphType& G, NodeIterator& u, std::ofstream& out)
    {
        out << "{" ;
        out << "\"id\":" << nodeId++ << "";
        u->writeJSON(out);
        out << "}";
    }

    void writeEdge(GraphType& G, NodeIterator& u, EdgeIterator& e, std::ofstream& out)
    {
        out << "{" ;
        out << "\"s\":" << G.getRelativePosition(u) << ","; 
        NodeIterator v = G.target(e);
        out << "\"t\":" << G.getRelativePosition(v) << ","; 
        e->writeJSON(out);
        out << "}";
    }

private:
    std::vector<NodeDescriptor> V;
    unsigned int nodeId;
};


#endif //GRAPHIO_H

---