#include <mapstorage.h>

 MapStorage::MapStorage(Graph & graph):g(graph)

 {

 };

 int MapStorage::addNodeMap(const std::string & name, Graph::NodeMap<double> *nodemap)

 {

   if( nodemap_storage.find(name) == nodemap_storage.end() )

     {

       nodemap_storage[name]=nodemap;

       return 0;

     }

   return 1;

 }

 int MapStorage::addEdgeMap(const std::string & name, Graph::EdgeMap<double> *edgemap)

 {

   if( edgemap_storage.find(name) == edgemap_storage.end() )

     {

       edgemap_storage[name]=edgemap;

       return 0;

     }

   return 1;

 }

 double MapStorage::maxOfNodeMap(const std::string & name)

 {

   double max=0;

   for (NodeIt j(g); j!=INVALID; ++j)

   {

     if( (*nodemap_storage[name])[j]>max )

     {

       max=(*nodemap_storage[name])[j];

     }

   }

   return max;

 }

 double MapStorage::maxOfEdgeMap(const std::string & name)

 {

   double max=0;

   for (EdgeIt j(g); j!=INVALID; ++j)

   {

     if( (*edgemap_storage[name])[j]>max )

     {

       max=(*edgemap_storage[name])[j];

     }

   }

   return max;

 }

 double MapStorage::minOfNodeMap(const std::string & name)

 {

   NodeIt j(g);

   double min=(*nodemap_storage[name])[j];

   for (; j!=INVALID; ++j)

   {

     if( (*nodemap_storage[name])[j]<min )

     {

       min=(*nodemap_storage[name])[j];

     }

   }

   return min;

 }

 double MapStorage::minOfEdgeMap(const std::string & name)

 {

   EdgeIt j(g);

   double min=(*edgemap_storage[name])[j];

   for (EdgeIt j(g); j!=INVALID; ++j)

   {

     if( (*edgemap_storage[name])[j]<min )

     {

       min=(*edgemap_storage[name])[j];

     }

   }

   return min;

 }

 void MapStorage::initMapsForEdge(Graph::Edge e)

 {

   std::map< std::string,Graph::EdgeMap<double> * >::iterator ems_it;

   for(ems_it=edgemap_storage.begin();ems_it!=edgemap_storage.end();ems_it++)

     {

       (*((*ems_it).second))[e]=5;

     }

 }