You need to complete the implementation of insert$\_$edge, insert$\_$edge$\_$undirected, insert$\_$vertex, erase$\_$edge, erase$\_$vertex functions.

#ifndef $\_$GRAPH$\_$H$\_$

#define $\_$GRAPH$\_$H$\_$

#include

#include

#include

#include

#include

#include

#include

$//$ Uncomment if using unordered$\_$set to store edges with boost hash function

$//$#include

$////////////////////////////////////////////////////////////////////////////////$

$///$ A generic adjacency$-$list graph where each vertex stores a VertexProperty and

$///$ each edge stores an EdgeProperty.

$////////////////////////////////////////////////////////////////////////////////$

template

class graph $\{$

$//$ The vertex and edge classes are forward$-$declared to allow their use in the

$//$ public section below. Their definitions follow in the private section

$//$ afterward.

class vertex;

class edge;

struct vertex$\_$hash;

struct edge$\_$hash;

struct vertex$\_$eq;

struct edge$\_$eq;

struct edge$\_$comp;

public:

$//$ Required public types

$///$ Unique vertex identifier

typedef size$\_$t vertex$\_$descriptor;

$///$ Unique edge identifier represents pair of vertex descriptors

typedef std::pair edge$\_$descriptor;

$///$@brief A container for the vertices. It should contain "vertex$*"$ or

$///$ shared$\_$ptr$.$

typedef std::unordered$\_$set MyVertexContainer;

$///$@brief A container for the edges. It should contain "edge$*"$ or

$///$ shared$\_$ptr$.$

$//$typedef std::unordered$\_$set MyEdgeContainer;

typedef std::set MyEdgeContainer;

$///$@brief A container for the adjacency lists. It should contain

$///$ "edge$*"$ or shared$\_$ptr$.$

$//$typedef std::unordered$\_$set MyAdjEdgeContainer;

typedef std::set MyAdjEdgeContainer;

$//$ Vertex iterators

typedef typename MyVertexContainer::iterator vertex$\_$iterator;

typedef typename MyVertexContainer::const$\_$iterator const$\_$vertex$\_$iterator;

$//$ Edge iterators

typedef typename MyEdgeContainer::iterator edge$\_$iterator;

typedef typename MyEdgeContainer::const$\_$iterator const$\_$edge$\_$iterator;

$//$ Adjacency list iterators

typedef typename MyAdjEdgeContainer::iterator adj$\_$edge$\_$iterator;

typedef typename MyAdjEdgeContainer::const$\_$iterator const$\_$adj$\_$edge$\_$iterator;

$//$ Required graph operations

$///$@brief Constructor$/$destructor

graph$()$ : m$\_$max$\_$vd$(0)\{\}$

~graph$()\{$

clear$()$;

$\}$

graph$($const graph&$)=$ delete; $///<$ Copy is disabled.

graph& operator$=($const graph&$)=$ delete; $///<$ Copy is disabled.

$///$@brief vertex iterator operations

vertex$\_$iterator vertices$\_$begin$()\{$return m$\_$vertices.begin$()$;$\}$

const$\_$vertex$\_$iterator vertices$\_$cbegin$()$ const $\{$return m$\_$vertices.cbegin$()$;$\}$

vertex$\_$iterator vertices$\_$end$()\{$return m$\_$vertices.end$()$;$\}$

const$\_$vertex$\_$iterator vertices$\_$cend$()$ const $\{$return m$\_$vertices.cend$()$;$\}$

$///$@brief edge iterator operations

edge$\_$iterator edges$\_$begin$()\{$return m$\_$edges.begin$()$;$\}$

const$\_$edge$\_$iterator edges$\_$cbegin$()$ const $\{$return m$\_$edges.cbegin$()$;$\}$

edge$\_$iterator edges$\_$end$()\{$return m$\_$edges.end$()$;$\}$

const$\_$edge$\_$iterator edges$\_$cend$()$ const $\{$return m$\_$edges.cend$()$;$\}$

$///$@brief Define accessors

size$\_$t num$\_$vertices$()$ const $\{$return m$\_$vertices.size$()$;$\}$

size$\_$t num$\_$edges$()$ const $\{$return m$\_$edges.size$()$;$\}$

vertex$\_$iterator find$\_$vertex$($vertex$\_$descriptor vd$)\{$

vertex v$($vd$,$ VertexProperty$())$;

return m$\_$vertices.find$($&v$)$;

$\}$

const$\_$vertex$\_$iterator find$\_$vertex$($vertex$\_$descriptor vd$)$ const $\{$

vertex v$($vd$,$ VertexProperty$())$;

return m$\_$vertices.find$($&v$)$;

$\}$

edge$\_$iterator find$\_$edge$($edge$\_$descriptor ed$)\{$

edge e$($ed$.$first, ed$.$second, EdgeProperty$())$;

return m$\_$edges.find$($&e$)$;

$\}$

const$\_$edge$\_$iterator find$\_$edge$($edge$\_$descriptor ed$)$ const $\{$

edge e$($ed$.$first, ed$.$second, EdgeProperty$())$;

return m$\_$edges.find$($&e$)$;

$\}$

$///$@todo Define modifiers

vertex$\_$descriptor insert$\_$vertex$($const VertexProperty& vp$)\{$

return m$\_$max$\_$vd;

$\}$

edge$\_$descriptor insert$\_$edge$($vertex$\_$descriptor sd$,$ vertex$\_$descriptor td$,$

const EdgeProperty& ep$)\{$

return std::make$\_$pair$($sd$,$ td$)$;

$\}$

void insert$\_$edge$\_$undirected$($vertex$\_$descriptor sd$,$ vertex$\_$descriptor td$,$

const EdgeProperty& ep$)\{$

$\}$

void erase$\_$vertex$($vertex$\_$descriptor vd$)\{$

$\}$

void erase$\_$edge$($edge$\_$descriptor ed$)\{$

$\}$

$////$end of @todo

void clear$()\{$

m$\_$max$\_$vd $=0$;

for$($auto v : m$\_$vertices$)$

delete v;

m$\_$vertices.clear$()$;

for$($auto e : m$\_$edges$)$

delete e;

m$\_$edges.clear$()$;

$\}$

$//$ Friend declarations for input$/$output$.$

template