glemon-0.x: comparison mapstorage.h

equal deleted inserted replaced

-:b4f94e66526a
+:ea8b48673dc8
 */
 #ifndef MAPSTORAGE_H
 #define MAPSTORAGE_H
-#include <all_include.h>
+class Mapstorage;
-#include <xymap.h>
+#include <vector>
+#include <map>
+#include <string>
+#include "all_include.h"
+#include "xymap.h"
 #include <libgnomecanvasmm.h>
+#include "map_value.h"
+#include "map_value_map.h"
 ///class MapStorage handles NodeMaps and EdgeMaps.
 ///Class MapStorage is responsible for storing
 ///NodeMaps and EdgeMaps that can be shown later
 private:
 std::string background_file_name;
 bool background_set;
 double background_scaling;
 public:
+class Error : public std::exception
+{
+private:
+std::string message;
+public:
+Error(const std::string& msg) : message(msg) {}
+virtual const char* what() const throw()
+{
+return message.c_str();
+}
+~Error() throw() {}
+};
 void setBackground(const std::string& file_name);
 const std::string& getBackgroundFilename();
 bool isBackgroundSet();
 double getBackgroundScaling();
 void setBackgroundScaling(double scaling);
+enum MapSaveDest { GUI_SECT, NESET_SECT, DONT_SAVE };
+enum GuiSectSaveDest { LGF_FILE, CONF_FILE };
+struct SpecMapSaveOpts
+{
+enum Dest { GUI_SECT, NESET_SECT };
+enum MapNum { ONE_MAP, TWO_MAPS };
+};
+typedef Graph::NodeMap<double> NumericNodeMap;
+typedef Graph::NodeMap<std::string> StringNodeMap;
+typedef Graph::EdgeMap<double> NumericEdgeMap;
+typedef Graph::EdgeMap<std::string> StringEdgeMap;
+typedef Graph::NodeMap<int> NodeLabelMap;
+typedef Graph::EdgeMap<int> EdgeLabelMap;
+typedef XYMap<Graph::NodeMap<double> > NodeCoordMap;
+typedef XYMap<Graph::EdgeMap<double> > ArrowCoordMap;
+struct EdgeMapData
+{
+/// where to save the map
+MapSaveDest save_dest;
+/// read-only or read-write
+bool writeable;
+/// default value
+MapValue default_value;
+virtual MapValue::Type type() = 0;
+virtual MapValue get(Edge e) = 0;
+virtual void set(Edge e, MapValue v) = 0;
+EdgeMapData(MapValue def_val) :
+save_dest(GUI_SECT),
+writeable(true),
+default_value(def_val)
+{}
+};
+struct NumericEdgeMapData : public EdgeMapData
+{
+NumericEdgeMap map;
+MapValue::Type type() { return MapValue::NUMERIC; }
+MapValue get(Edge e) { return MapValue(map[e]); }
+void set(Edge e, MapValue v) { map.set(e, static_cast<double>(v)); }
+NumericEdgeMapData(Graph& g, double def_val) :
+EdgeMapData(MapValue(def_val)),
+map(g, def_val)
+{}
+};
+struct StringEdgeMapData : public EdgeMapData
+{
+StringEdgeMap map;
+MapValue::Type type() { return MapValue::STRING; }
+MapValue get(Edge e) { return MapValue(map[e]); }
+void set(Edge e, MapValue v) { map.set(e, static_cast<std::string>(v)); }
+StringEdgeMapData(Graph& g, std::string def_val) :
+EdgeMapData(MapValue(def_val)),
+map(g, def_val)
+{}
+};
+struct NodeMapData
+{
+/// where to save the map
+MapSaveDest save_dest;
+/// read-only or read-write
+bool writeable;
+/// default value
+MapValue default_value;
+virtual MapValue::Type type() = 0;
+virtual MapValue get(Node e) = 0;
+virtual void set(Node e, MapValue v) = 0;
+NodeMapData(MapValue def_val) :
+save_dest(GUI_SECT),
+writeable(true),
+default_value(def_val)
+{}
+};
+struct NumericNodeMapData : public NodeMapData
+{
+NumericNodeMap map;
+MapValue::Type type() { return MapValue::NUMERIC; }
+MapValue get(Node e) { return MapValue(map[e]); }
+void set(Node e, MapValue v) { map.set(e, static_cast<double>(v)); }
+NumericNodeMapData(Graph& g, double def_val) :
+NodeMapData(MapValue(def_val)),
+map(g, def_val)
+{}
+};
+struct StringNodeMapData : public NodeMapData
+{
+StringNodeMap map;
+MapValue::Type type() { return MapValue::STRING; }
+MapValue get(Node e) { return MapValue(map[e]); }
+void set(Node e, MapValue v) { map.set(e, static_cast<std::string>(v)); }
+StringNodeMapData(Graph& g, std::string def_val) :
+NodeMapData(MapValue(def_val)),
+map(g, def_val)
+{}
+};
+typedef std::map<std::string, NodeMapData*> NodeMapStore;
+typedef std::map<std::string, EdgeMapData*> EdgeMapStore;
+struct GUISectData
+{
+std::vector<std::string> main_node_map_names;
+std::vector<std::string> main_edge_map_names;
+std::vector<std::string> gui_node_map_names;
+std::vector<std::string> gui_edge_map_names;
+std::map<std::string, MapValue::Type> node_map_types;
+std::map<std::string, MapValue::Type> edge_map_types;
+std::map<std::string, std::map<int, double>* > numeric_node_maps;
+std::map<std::string, std::map<int, std::string>* > string_node_maps;
+std::map<std::string, std::map<int, double>* > numeric_edge_maps;
+std::map<std::string, std::map<int, std::string>* > string_edge_maps;
+std::map<int, XY> node_coord_map;
+std::map<int, XY> arrow_coord_map;
+SpecMapSaveOpts::Dest node_coords_save_dest;
+SpecMapSaveOpts::MapNum node_coords_save_map_num;
+std::string node_coords_one_map_name;
+std::string node_coords_two_maps_1_name;
+std::string node_coords_two_maps_2_name;
+SpecMapSaveOpts::Dest arrow_coords_save_dest;
+SpecMapSaveOpts::MapNum arrow_coords_save_map_num;
+std::string arrow_coords_one_map_name;
+std::string arrow_coords_two_maps_1_name;
+std::string arrow_coords_two_maps_2_name;
+~GUISectData()
+{
+using std::map;
+using std::vector;
+using std::pair;
+using std::string;
+for (map<string, map<int, double>* >::iterator it =
+numeric_node_maps.begin(); it != numeric_node_maps.end(); ++it)
+{
+delete it->second;
+}
+for (map<string, map<int, string>* >::iterator it =
+string_node_maps.begin(); it != string_node_maps.end(); ++it)
+{
+delete it->second;
+}
+for (map<string, map<int, double>* >::iterator it =
+numeric_edge_maps.begin(); it != numeric_edge_maps.end(); ++it)
+{
+delete it->second;
+}
+for (map<string, map<int, string>* >::iterator it =
+string_edge_maps.begin(); it != string_edge_maps.end(); ++it)
+{
+delete it->second;
+}
+}
+};
+public:
 ///The graph for which the datas are stored.
 Graph graph;
+const Graph& getGraph();
+private:
+GuiSectSaveDest gui_sect_save_dest;
+SpecMapSaveOpts::Dest node_coords_save_dest;
+SpecMapSaveOpts::MapNum node_coords_save_map_num;
+SpecMapSaveOpts::Dest arrow_coords_save_dest;
+SpecMapSaveOpts::MapNum arrow_coords_save_map_num;
+NodeMapStore nodemaps;
+EdgeMapStore edgemaps;
+NodeLabelMap node_label;
+EdgeLabelMap edge_label;
 /// the coordinates of the nodes
-XYMap<Graph::NodeMap<double> > coords;
+NodeCoordMap node_coords;
+Graph::NodeMap<double> node_coords_x;
+Graph::NodeMap<double> node_coords_y;
 /// the coordinates of the arrows on the edges
-XYMap<Graph::EdgeMap<double> > arrow_pos;
+ArrowCoordMap arrow_coords;
+Graph::EdgeMap<double> arrow_coords_x;
+Graph::EdgeMap<double> arrow_coords_y;
 ///The content of the object has changed, update is needed.
 bool modified;
 ///Name of file loaded in object.
 std::string file_name;
-///Stores double type NodeMaps
+// the largest node label
-std::map< std::string,Graph::NodeMap<double> * > nodemap_storage;
+int max_node_label;
-///Stores double type EdgeMaps
+// the largest edge label
-std::map< std::string,Graph::EdgeMap<double> * > edgemap_storage;
+int max_edge_label;
+std::string node_coords_one_map_name;
+std::string node_coords_two_maps_1_name;
+std::string node_coords_two_maps_2_name;
+std::string arrow_coords_one_map_name;
+std::string arrow_coords_two_maps_1_name;
+std::string arrow_coords_two_maps_2_name;
+public:
 ///Stores the default values for the different visualization node attributes
 std::vector<Graph::NodeMap<double> > default_nodemaps;
 ///Stores the default values for the different visualization edge attributes
 std::vector<Graph::EdgeMap<double> > default_edgemaps;
 ///Stores the active maps for the different visualization node attributes
 std::vector< std::string > active_nodemaps;
 /// Stores the active maps for the different visualization edge attributes
 std::vector< std::string > active_edgemaps;
-/// Default values for the maps
-std::map< std::string, double > nodemap_default;
-/// Default values for the maps
-std::map< std::string, double > edgemap_default;
-bool arrow_pos_read_ok;
 protected:
 /// Signal emitted on any change made on map values
 /// Signal emitted in the case of nodemap addition
 /// std::string is the
 ///name of the new map
-sigc::signal<void, std::string> signal_node_map;
+sigc::signal<void, std::string, MapValue::Type> signal_node_map;
 /// Signal emitted in the case of edgemap addition
 /// std::string is the
 ///name of the new map
-sigc::signal<void, std::string> signal_edge_map;
+sigc::signal<void, std::string, MapValue::Type> signal_edge_map;
 /// Signal emitted, when entry in \ref MapWin should be changed.
 sigc::signal<void, bool, int, std::string> signal_map_win;
 /// Signal emitted, when entry in \ref DesignWin should be changed.
 /// \param prop is the property
 ///that shows the requested map.
 std::string getActiveNodeMap(int prop);
 /// Returns the names of the edgemaps stored here.
-std::vector<std::string> getEdgeMapList();
+std::vector<std::string> getEdgeMapList(MapType type = ALL);
 /// Returns the names of the nodemaps stored here.
-std::vector<std::string> getNodeMapList();
+std::vector<std::string> getNodeMapList(MapType type = ALL);
 ///returns \ref signal_prop to be able to connect functions to it
 sigc::signal<void, bool, int> signal_prop_ch();
 ///returns \ref signal_node_map to be able to connect functions to it
-sigc::signal<void, std::string> signal_node_map_ch(){return signal_node_map;};
+sigc::signal<void, std::string, MapValue::Type> signal_node_map_ch(){return signal_node_map;};
 ///returns \ref signal_edge_map to be able to connect functions to it
-sigc::signal<void, std::string> signal_edge_map_ch(){return signal_edge_map;};
+sigc::signal<void, std::string, MapValue::Type> signal_edge_map_ch(){return signal_edge_map;};
 ///returns \ref signal_map_win to be able to connect functions to it
 sigc::signal<void, bool, int, std::string> signal_map_win_ch(){return signal_map_win;};
 ///returns \ref signal_design_win to be able to connect functions to it
 sigc::signal<void, double, double, int> signal_design_win_ch(){return signal_design_win;};
+void createNodeMap(const std::string& name, MapValue::Type type,
+MapValue def_val);
+void createEdgeMap(const std::string& name, MapValue::Type type,
+MapValue def_val);
 ///returns \ref signal_background to be able to connect functions to it
 sigc::signal<void> signal_background_ch(){return signal_background;};
 ///Adds given map to storage.
-///A name and the map itself has to be provided.
-///\param mapname is the name of map
-///\param nodemap is the pointer of the given nodemap
-///\param def the default value of the map. If not given, it will be 0.
-///If new edge is added to graph the value of it in the map will be this.
-///\todo map should be given by reference!
-///\todo why is default value stored?
-int addNodeMap(const std::string & mapname,Graph::NodeMap<double> * nodemap, double def=0.0);
-///Adds given map to storage. A name and the map itself has to be provided.
-///A name and the map itself has to be provided.
-///\param mapname is the name of map
-///\param edgemap is the pointer of the given edgemap
-///\param def the default value of the map. If not given, it will be 0.
-///If new edge is added to graph the value of it in the map will be this.
-///\todo map should be given by reference!
-int addEdgeMap(const std::string & mapname,Graph::EdgeMap<double> * edgemap, double def=0.0);
-///Returns how much nodemaps is stored in \ref MapStorage
-int numOfNodeMaps() {return nodemap_storage.size();};
-///Returns how much edgemaps is stored in \ref MapStorage
-int numOfEdgeMaps() {return edgemap_storage.size();};
-///Returns the maximum value of the given NodeMap.
-///NodeMap has to be given by its name.
-///\param name the name of map of which maximum is searched
-double maxOfNodeMap(const std::string & name);
-///Returns the maximum value of the given EdgeMap.
-///EdgeMap has to be given by its name.
-///\param name the name of map of which maximum is searched
-double maxOfEdgeMap(const std::string & name);
-///Returns the minimum value of the given NodeMap.
-///NodeMap has to be given by its name.
-///\param name the name of map of which minimum is searched
-double minOfNodeMap(const std::string & name);
-///Returns the minimum value of the given EdgeMap.
-///EdgeMap has to be given by its name.
-///\param name the name of map of which minimum is searched
-double minOfEdgeMap(const std::string & name);
-///Returns iterator pointing to the first NodeMap in storage.
-///To be able to iterate through each maps this function
-///returns an iterator pointing to the first nodemap in
-///the storage.
-std::map< std::string,Graph::NodeMap<double> * >::iterator beginOfNodeMaps(){return nodemap_storage.begin();};
-///Returns iterator pointing to the first EdgeMap in storage.
-///To be able to iterate through each maps this function
-///returns an iterator pointing to the first edgemap in
-///the storage.
-std::map< std::string,Graph::EdgeMap<double> * >::iterator beginOfEdgeMaps(){return edgemap_storage.begin();};
-///Returns iterator pointing after the last NodeMap in storage.
-///To be able to iterate through each maps this function
-///returns an iterator pointing to the last nodemap in the storage.
-std::map< std::string,Graph::NodeMap<double> * >::iterator endOfNodeMaps(){return nodemap_storage.end();};
-///Returns iterator pointing after the last EdgeMap in storage.
-///To be able to iterate through each maps this function
-///returns an iterator pointing to the last edgemap in the storage.
-std::map< std::string,Graph::EdgeMap<double> * >::iterator endOfEdgeMaps(){return edgemap_storage.end();};
 ///Emits \ref signal_prop if mapvalues have changed, and MapStorage gets to know it.
 ///If values in a map have changed, this function checks, whether it is displayed.
 ///This check means searching the given mapname between active maps
 void writeToFile(const std::string &);
 ///Deletes all datastructures stored here.
 void clear();
-void ArrowPosReadOK();
 void get_design_data(double &, double &, int &);
 void set_attraction(double);
 void set_propulsation(double);
 void set_iteration(int);
 void redesign_data_changed();
+XY getNodeCoords(Node n) const;
+void setNodeCoords(Node n, XY c);
+XY getArrowCoords(Edge e) const;
+void setArrowCoords(Edge e, XY c);
+MapValue get(const std::string& name, Node node) const;
+void set(const std::string& name, Node node, MapValue val);
+MapValue get(const std::string& name, Edge edge) const;
+void set(const std::string& name, Edge edge, MapValue val);
+const std::string& getFileName() const;
+void setFileName(const std::string& fn);
+bool getModified() const;
+void setModified(bool m = true);
+Node addNode(XY);
+Edge addEdge(Node, Node);
+NumericNodeMap& getNumericNodeMap(const std::string& name);
+StringNodeMap& getStringNodeMap(const std::string& name);
+NumericEdgeMap& getNumericEdgeMap(const std::string& name);
+StringEdgeMap& getStringEdgeMap(const std::string& name);
+MapValueEdgeMap getEdgeMap(const std::string& name);
+MapValueNodeMap getNodeMap(const std::string& name);
+int getLabel(Node) const;
+int getLabel(Edge) const;
+GuiSectSaveDest getGUIDataSaveLocation();
+void setGUIDataSaveLocation(GuiSectSaveDest dest);
+MapSaveDest getNodeMapSaveDest(std::string name) const;
+MapSaveDest getEdgeMapSaveDest(std::string name) const;
+void setNodeMapSaveDest(std::string name, MapSaveDest dest);
+void setEdgeMapSaveDest(std::string name, MapSaveDest dest);
+SpecMapSaveOpts::Dest getNodeCoordsSaveDest();
+SpecMapSaveOpts::Dest getArrowCoordsSaveDest();
+void setNodeCoordsSaveDest(SpecMapSaveOpts::Dest dest);
+void setArrowCoordsSaveDest(SpecMapSaveOpts::Dest dest);
+SpecMapSaveOpts::MapNum getNodeCoordsSaveMapNum();
+SpecMapSaveOpts::MapNum getArrowCoordsSaveMapNum();
+void setNodeCoordsSaveMapNum(SpecMapSaveOpts::MapNum num);
+void setArrowCoordsSaveMapNum(SpecMapSaveOpts::MapNum num);
+MapValue::Type getNodeMapElementType(std::string name) const;
+MapValue::Type getEdgeMapElementType(std::string name) const;
+const NodeLabelMap& getNodeLabelMap();
+const EdgeLabelMap& getEdgeLabelMap();
+bool nodeMapExists(std::string name);
+bool edgeMapExists(std::string name);
+std::vector<std::string> getEdgeMaps(MapType type = ALL);
+std::vector<std::string> getNodeMaps(MapType type = ALL);
+NodeCoordMap& getNodeCoordMap();
+ArrowCoordMap& getArrowCoordMap();
+const std::string& getNodeCoordsOneMapName();
+const std::string& getNodeCoordsTwoMaps1Name();
+const std::string& getNodeCoordsTwoMaps2Name();
+void setNodeCoordsOneMapName(const std::string& name);
+void setNodeCoordsTwoMaps1Name(const std::string& name);
+void setNodeCoordsTwoMaps2Name(const std::string& name);
+const std::string& getArrowCoordsOneMapName();
+const std::string& getArrowCoordsTwoMaps1Name();
+const std::string& getArrowCoordsTwoMaps2Name();
+void setArrowCoordsOneMapName(const std::string& name);
+void setArrowCoordsTwoMaps1Name(const std::string& name);
+void setArrowCoordsTwoMaps2Name(const std::string& name);
+private:
+EdgeMapData* getEdgeMapData(std::string name) const;
+NodeMapData* getNodeMapData(std::string name) const;
+void readLGF(
+const std::string& filename,
+bool read_edge_label,
+const std::vector<std::string>& node_map_names,
+const std::vector<std::string>& edge_map_names,
+const std::map<std::string, MapValue::Type>& node_map_types,
+const std::map<std::string, MapValue::Type>& edge_map_types,
+const std::string& node_coord_xmap_name,
+const std::string& node_coord_ymap_name,
+const std::string& arrow_coord_xmap_name,
+const std::string& arrow_coord_ymap_name);
+public:
 void exportGraphToEPS(std::vector<bool>, std::string, std::string);
 };
 #endif //MAPSTORAGE_H

changeset 202	09f6dfdbb3b4
parent 198	d6cc0579b94b