source: glemon/gui_writer.cc @ 6:3a44a2bb6da8

/* -*- 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.
 *
 */

#include "gui_writer.h"
#include "io_helper.h"
#include "mapstorage.h"
#include "xml.h"
#include <lemon/dim2.h>
#include <vector>

#include <gui_writer.h>
#include <mapstorage.h>

// std::string GuiWriter::header()
// {
//   return "@gui";
// }

void GuiWriter::write(std::ostream& os)
{
  using std::vector;
  using std::string;
  using std::map;
  using std::string;

  os << "@gui" << std::endl;

  XmlIo x(os);

  vector<string> all_node_map_names = mapstorage->getNodeMapList();
  // name of the maps saved to the nodeset section
  vector<string> main_node_map_names;
  // name of the maps saved to the gui section
  vector<string> gui_node_map_names;

  for (vector<string>::const_iterator it = all_node_map_names.begin();
      it != all_node_map_names.end(); ++it)
  {
    if (mapstorage->getNodeMapSaveDest(*it) == MapStorage::NESET_SECT)
      main_node_map_names.push_back(*it);
    else if (mapstorage->getNodeMapSaveDest(*it) == MapStorage::GUI_SECT)
      gui_node_map_names.push_back(*it);
  }

  { x("main_node_map_names", main_node_map_names); }
  { x("gui_node_map_names", gui_node_map_names); }

  map<string, MapValue::Type> node_map_types;
  for (vector<string>::const_iterator it = main_node_map_names.begin();
      it != main_node_map_names.end(); ++it)
  {
    node_map_types[*it] = mapstorage->getNodeMapElementType(*it);
  }
  for (vector<string>::const_iterator it = gui_node_map_names.begin();
      it != gui_node_map_names.end(); ++it)
  {
    node_map_types[*it] = mapstorage->getNodeMapElementType(*it);
  }

  { x("node_map_types", node_map_types); }


  vector<string> all_arc_map_names = mapstorage->getArcMapList();
  // name of the maps saved to the arcset section
  vector<string> main_arc_map_names;
  // name of the maps saved to the gui section
  vector<string> gui_arc_map_names;

  for (vector<string>::const_iterator it = all_arc_map_names.begin();
      it != all_arc_map_names.end(); ++it)
  {
    if (mapstorage->getArcMapSaveDest(*it) == MapStorage::NESET_SECT)
      main_arc_map_names.push_back(*it);
    if (mapstorage->getArcMapSaveDest(*it) == MapStorage::GUI_SECT)
      gui_arc_map_names.push_back(*it);
  }

  { x("main_arc_map_names", main_arc_map_names); }
  { x("gui_arc_map_names", gui_arc_map_names); }

  map<string, MapValue::Type> arc_map_types;
  for (vector<string>::const_iterator it = main_arc_map_names.begin();
      it != main_arc_map_names.end(); ++it)
  {
    arc_map_types[*it] = mapstorage->getArcMapElementType(*it);
  }
  for (vector<string>::const_iterator it = gui_arc_map_names.begin();
      it != gui_arc_map_names.end(); ++it)
  {
    arc_map_types[*it] = mapstorage->getArcMapElementType(*it);
  }

  { x("arc_map_types", arc_map_types); }

  // write the gui node maps
  for (vector<string>::const_iterator it = gui_node_map_names.begin();
      it != gui_node_map_names.end(); ++it)
  {
    MapValue::Type type = mapstorage->getNodeMapElementType(*it);
    const MapStorage::NodeLabelMap& labels = mapstorage->getNodeLabelMap();
    switch (type)
    {
      case MapValue::NUMERIC:
        {
          std::map<int, double> map_data;
          MapStorage::NumericNodeMap& map =
            mapstorage->getNumericNodeMap(*it);
          for (NodeIt n(mapstorage->getDigraph()); n != INVALID; ++n)
          {
            map_data[labels[n]] = map[n];
          }
          { x(*it, map_data); }
        }
        break;
      case MapValue::STRING:
        {
          std::map<int, std::string> map_data;
          MapStorage::StringNodeMap& map =
            mapstorage->getStringNodeMap(*it);
          for (NodeIt n(mapstorage->getDigraph()); n != INVALID; ++n)
          {
            map_data[labels[n]] = map[n];
          }
          { x(*it, map_data); }
        }
        break;
    }
  }

  // write the gui arc maps
  for (vector<string>::const_iterator it = gui_arc_map_names.begin();
      it != gui_arc_map_names.end(); ++it)
  {
    MapValue::Type type = mapstorage->getArcMapElementType(*it);
    const MapStorage::ArcLabelMap& labels = mapstorage->getArcLabelMap();
    switch (type)
    {
      case MapValue::NUMERIC:
        {
          std::map<int, double> map_data;
          MapStorage::NumericArcMap& map =
            mapstorage->getNumericArcMap(*it);
          for (ArcIt e(mapstorage->getDigraph()); e != INVALID; ++e)
          {
            map_data[labels[e]] = map[e];
          }
          { x(*it, map_data); }
        }
        break;
      case MapValue::STRING:
        {
          std::map<int, std::string> map_data;
          MapStorage::StringArcMap& map =
            mapstorage->getStringArcMap(*it);
          for (ArcIt e(mapstorage->getDigraph()); e != INVALID; ++e)
          {
            map_data[labels[e]] = map[e];
          }
          { x(*it, map_data); }
        }
        break;
    }
  }

  {
    switch (mapstorage->getNodeCoordsSaveDest())
    {
      case MapStorage::SpecMapSaveOpts::GUI_SECT:
        { x("node_coords_save_dest", string("gui_sect")); }
        // write the node coorinates
        {
          const MapStorage::NodeLabelMap& labels =
            mapstorage->getNodeLabelMap();
          std::map<int, XY> node_coord_map;
          MapStorage::NodeCoordMap& map = mapstorage->getNodeCoordMap();
          for (NodeIt n(mapstorage->getDigraph()); n != INVALID; ++n)
          {
            node_coord_map[labels[n]] = map[n];
          }
          { x("node_coord_map", node_coord_map); }
        }
        break;
      case MapStorage::SpecMapSaveOpts::NESET_SECT:
        switch (mapstorage->getNodeCoordsSaveMapNum())
        {
          case MapStorage::SpecMapSaveOpts::ONE_MAP:
            { x("node_coords_save_dest", string("nodeset_sect_1_map")); }
            { x("map_name", mapstorage->getNodeCoordsOneMapName()); }
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            { x("node_coords_save_dest", string("nodeset_sect_2_maps")); }
            { x("map1_name", mapstorage->getNodeCoordsTwoMaps1Name()); }
            { x("map2_name", mapstorage->getNodeCoordsTwoMaps2Name()); }
            break;
        }
        break;
    }
  }

  {
    switch (mapstorage->getArrowCoordsSaveDest())
    {
      case MapStorage::SpecMapSaveOpts::GUI_SECT:
        { x("arrow_coords_save_dest", string("gui_sect")); }
        // write the arrow coorinates
        {
          const MapStorage::ArcLabelMap& labels =
            mapstorage->getArcLabelMap();
          std::map<int, XY> arrow_coord_map;
          MapStorage::ArrowCoordMap& map = mapstorage->getArrowCoordMap();
          for (ArcIt e(mapstorage->getDigraph()); e != INVALID; ++e)
          {
            arrow_coord_map[labels[e]] = map[e];
          }
          { x("arrow_coord_map", arrow_coord_map); }
        }
        break;
      case MapStorage::SpecMapSaveOpts::NESET_SECT:
        switch (mapstorage->getArrowCoordsSaveMapNum())
        {
          case MapStorage::SpecMapSaveOpts::ONE_MAP:
            { x("arrow_coords_save_dest", string("arcset_sect_1_map")); }
            { x("map_name", mapstorage->getArrowCoordsOneMapName()); }
            break;
          case MapStorage::SpecMapSaveOpts::TWO_MAPS:
            { x("arrow_coords_save_dest", string("arcset_sect_2_maps")); }
            { x("map1_name", mapstorage->getArrowCoordsTwoMaps1Name()); }
            { x("map2_name", mapstorage->getArrowCoordsTwoMaps2Name()); }
            break;
        }
        break;
    }
  }


  std::map<int, std::string> nm;
  for(int i=0;i<NODE_PROPERTY_NUM;i++)
    {
      nm[i]=mapstorage->active_nodemaps[i];
    }
  { x("active_nodemaps", nm); }

  std::map<int, std::string> em;
  for(int i=0;i<EDGE_PROPERTY_NUM;i++)
    {
      em[i]=mapstorage->active_arcmaps[i];
    }
  { x("active_arcmaps", em); }

  double attraction;
  double propulsation;
  int iteration;

  mapstorage->get_design_data(attraction, propulsation, iteration);

  { x("redesign-attraction", attraction); }
  { x("redesign-propulsation", propulsation); }
  { x("redesign-iteration", iteration); }
}

//GuiWriter::GuiWriter(LemonWriter& writer, MapStorage* ms) :
GuiWriter::GuiWriter(MapStorage* ms) :
  //Parent(writer),
  mapstorage(ms)
{
}