lemon-main: comparison lemon/lgf

equal deleted inserted replaced

-:78a60dc7dae2
+:506217e6515b
 Converter _converter;
 public:
 ValueStorage(const Value& value, const Converter& converter = Converter())
 : _value(value), _converter(converter) {}
 virtual std::string get() {
 return _converter(_value);
 }
 };
-template <typename Value>
+template <typename Value,
+typename Map = std::map<Value, std::string> >
 struct MapLookUpConverter {
-const std::map<Value, std::string>& _map;
+const Map& _map;
-MapLookUpConverter(const std::map<Value, std::string>& map)
+MapLookUpConverter(const Map& map)
 : _map(map) {}
-std::string operator()(const Value& str) {
+std::string operator()(const Value& value) {
-typename std::map<Value, std::string>::const_iterator it =
+typename Map::const_iterator it = _map.find(value);
-_map.find(str);
 if (it == _map.end()) {
 throw FormatError("Item not found");
 }
 return it->second;
+}
+};
+template <typename Value,
+typename Map1 = std::map<Value, std::string>,
+typename Map2 = std::map<Value, std::string> >
+struct DoubleMapLookUpConverter {
+const Map1& _map1;
+const Map2& _map2;
+DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
+: _map1(map1), _map2(map2) {}
+std::string operator()(const Value& value) {
+typename Map1::const_iterator it1 = _map1.find(value);
+typename Map1::const_iterator it2 = _map2.find(value);
+if (it1 == _map1.end()) {
+if (it2 == _map2.end()) {
+throw FormatError("Item not found");
+} else {
+return it2->second;
+}
+} else {
+if (it2 == _map2.end()) {
+return it1->second;
+} else {
+throw FormatError("Item is ambigous");
+}
+}
 }
 };
 template <typename Graph>
 struct GraphArcLookUpConverter {
 std::string _nodes_caption;
 std::string _edges_caption;
 std::string _attributes_caption;
-typedef std::map<Node, std::string> NodeIndex;
+typedef std::map<Node, std::string> RedNodeIndex;
-NodeIndex _node_index;
+RedNodeIndex _red_node_index;
+typedef std::map<Node, std::string> BlueNodeIndex;
+BlueNodeIndex _blue_node_index;
 typedef std::map<Edge, std::string> EdgeIndex;
 EdgeIndex _edge_index;
 typedef std::vector<std::pair<std::string,
-_writer_bits::MapStorageBase<Node>* > > NodeMaps;
+_writer_bits::MapStorageBase<RedNode>* > > RedNodeMaps;
-NodeMaps _red_maps;
+RedNodeMaps _red_node_maps;
-NodeMaps _blue_maps;
+typedef std::vector<std::pair<std::string,
+_writer_bits::MapStorageBase<BlueNode>* > > BlueNodeMaps;
+BlueNodeMaps _blue_node_maps;
 typedef std::vector<std::pair<std::string,
 _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
 EdgeMaps _edge_maps;
 }
 }
 /// \brief Destructor
 ~BpGraphWriter() {
-for (typename NodeMaps::iterator it = _red_maps.begin();
+for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-it != _red_maps.end(); ++it) {
+it != _red_node_maps.end(); ++it) {
 delete it->second;
 }
-for (typename NodeMaps::iterator it = _blue_maps.begin();
+for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-it != _blue_maps.end(); ++it) {
+it != _blue_node_maps.end(); ++it) {
 delete it->second;
 }
 for (typename EdgeMaps::iterator it = _edge_maps.begin();
 it != _edge_maps.end(); ++it) {
 _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
 other._os = 0;
 other.local_os = false;
-_node_index.swap(other._node_index);
+_red_node_index.swap(other._red_node_index);
+_blue_node_index.swap(other._blue_node_index);
 _edge_index.swap(other._edge_index);
-_red_maps.swap(other._red_maps);
+_red_node_maps.swap(other._red_node_maps);
-_blue_maps.swap(other._blue_maps);
+_blue_node_maps.swap(other._blue_node_maps);
 _edge_maps.swap(other._edge_maps);
 _attributes.swap(other._attributes);
 _nodes_caption = other._nodes_caption;
 _edges_caption = other._edges_caption;
 ///
 /// Add a node map writing rule to the writer.
 template <typename Map>
 BpGraphWriter& nodeMap(const std::string& caption, const Map& map) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* red_storage =
+_writer_bits::MapStorageBase<RedNode>* red_storage =
-new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<RedNode, Map>(map);
-_red_maps.push_back(std::make_pair(caption, red_storage));
+_red_node_maps.push_back(std::make_pair(caption, red_storage));
-_writer_bits::MapStorageBase<Node>* blue_storage =
+_writer_bits::MapStorageBase<BlueNode>* blue_storage =
-new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<BlueNode, Map>(map);
-_blue_maps.push_back(std::make_pair(caption, blue_storage));
+_blue_node_maps.push_back(std::make_pair(caption, blue_storage));
 return *this;
 }
 /// \brief Node map writing rule
 ///
 /// writer.
 template <typename Map, typename Converter>
 BpGraphWriter& nodeMap(const std::string& caption, const Map& map,
 const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* red_storage =
+_writer_bits::MapStorageBase<RedNode>* red_storage =
-new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-_red_maps.push_back(std::make_pair(caption, red_storage));
+_red_node_maps.push_back(std::make_pair(caption, red_storage));
-_writer_bits::MapStorageBase<Node>* blue_storage =
+_writer_bits::MapStorageBase<BlueNode>* blue_storage =
-new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-_blue_maps.push_back(std::make_pair(caption, blue_storage));
+_blue_node_maps.push_back(std::make_pair(caption, blue_storage));
 return *this;
 }
 /// \brief Red node map writing rule
 ///
 /// Add a red node map writing rule to the writer.
 template <typename Map>
 BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
-checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* storage =
+_writer_bits::MapStorageBase<RedNode>* storage =
-new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<RedNode, Map>(map);
-_red_maps.push_back(std::make_pair(caption, storage));
+_red_node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Red node map writing rule
 ///
 /// Add a red node map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
 const Converter& converter = Converter()) {
-checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* storage =
+_writer_bits::MapStorageBase<RedNode>* storage =
-new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-_red_maps.push_back(std::make_pair(caption, storage));
+_red_node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Blue node map writing rule
 ///
 /// Add a blue node map writing rule to the writer.
 template <typename Map>
 BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
-checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* storage =
+_writer_bits::MapStorageBase<BlueNode>* storage =
-new _writer_bits::MapStorage<Node, Map>(map);
+new _writer_bits::MapStorage<BlueNode, Map>(map);
-_blue_maps.push_back(std::make_pair(caption, storage));
+_blue_node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Blue node map writing rule
 ///
 /// Add a blue node map writing rule with specialized converter to the
 /// writer.
 template <typename Map, typename Converter>
 BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
 const Converter& converter = Converter()) {
-checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-_writer_bits::MapStorageBase<Node>* storage =
+_writer_bits::MapStorageBase<BlueNode>* storage =
-new _writer_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-_blue_maps.push_back(std::make_pair(caption, storage));
+_blue_node_maps.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Edge map writing rule
 ///
 /// \brief Node writing rule
 ///
 /// Add a node writing rule to the writer.
 BpGraphWriter& node(const std::string& caption, const Node& node) {
+typedef _writer_bits::DoubleMapLookUpConverter<
+Node, RedNodeIndex, BlueNodeIndex> Converter;
+Converter converter(_red_node_index, _blue_node_index);
+_writer_bits::ValueStorageBase* storage =
+new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+_attributes.push_back(std::make_pair(caption, storage));
+return *this;
+}
+/// \brief Red node writing rule
+///
+/// Add a red node writing rule to the writer.
+BpGraphWriter& redNode(const std::string& caption, const RedNode& node) {
 typedef _writer_bits::MapLookUpConverter<Node> Converter;
-Converter converter(_node_index);
+Converter converter(_red_node_index);
+_writer_bits::ValueStorageBase* storage =
+new _writer_bits::ValueStorage<Node, Converter>(node, converter);
+_attributes.push_back(std::make_pair(caption, storage));
+return *this;
+}
+/// \brief Blue node writing rule
+///
+/// Add a blue node writing rule to the writer.
+BpGraphWriter& blueNode(const std::string& caption, const BlueNode& node) {
+typedef _writer_bits::MapLookUpConverter<Node> Converter;
+Converter converter(_blue_node_index);
 _writer_bits::ValueStorageBase* storage =
 new _writer_bits::ValueStorage<Node, Converter>(node, converter);
 _attributes.push_back(std::make_pair(caption, storage));
 return *this;
 }
 /// @}
 private:
 void writeRedNodes() {
-_writer_bits::MapStorageBase<Node>* label = 0;
+_writer_bits::MapStorageBase<RedNode>* label = 0;
-for (typename NodeMaps::iterator it = _red_maps.begin();
+for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-it != _red_maps.end(); ++it) {
+it != _red_node_maps.end(); ++it) {
 if (it->first == "label") {
 label = it->second;
 break;
 }
 }
 *_os << std::endl;
 if (label == 0) {
 *_os << "label" << '\t';
 }
-for (typename NodeMaps::iterator it = _red_maps.begin();
+for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-it != _red_maps.end(); ++it) {
+it != _red_node_maps.end(); ++it) {
 _writer_bits::writeToken(*_os, it->first) << '\t';
 }
 *_os << std::endl;
-std::vector<Node> nodes;
+std::vector<RedNode> nodes;
 for (RedNodeIt n(_graph); n != INVALID; ++n) {
 nodes.push_back(n);
 }
 if (label == 0) {
 } else {
 label->sort(nodes);
 }
 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-Node n = nodes[i];
+RedNode n = nodes[i];
 if (label == 0) {
 std::ostringstream os;
-os << _graph.id(n);
+os << _graph.id(static_cast<Node>(n));
 _writer_bits::writeToken(*_os, os.str());
 *_os << '\t';
-_node_index.insert(std::make_pair(n, os.str()));
+_red_node_index.insert(std::make_pair(n, os.str()));
 }
-for (typename NodeMaps::iterator it = _red_maps.begin();
+for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-it != _red_maps.end(); ++it) {
+it != _red_node_maps.end(); ++it) {
 std::string value = it->second->get(n);
 _writer_bits::writeToken(*_os, value);
 if (it->first == "label") {
-_node_index.insert(std::make_pair(n, value));
+_red_node_index.insert(std::make_pair(n, value));
 }
 *_os << '\t';
 }
 *_os << std::endl;
 }
 }
 void writeBlueNodes() {
-_writer_bits::MapStorageBase<Node>* label = 0;
+_writer_bits::MapStorageBase<BlueNode>* label = 0;
-for (typename NodeMaps::iterator it = _blue_maps.begin();
+for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-it != _blue_maps.end(); ++it) {
+it != _blue_node_maps.end(); ++it) {
 if (it->first == "label") {
 label = it->second;
 break;
 }
 }
 *_os << std::endl;
 if (label == 0) {
 *_os << "label" << '\t';
 }
-for (typename NodeMaps::iterator it = _blue_maps.begin();
+for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-it != _blue_maps.end(); ++it) {
+it != _blue_node_maps.end(); ++it) {
 _writer_bits::writeToken(*_os, it->first) << '\t';
 }
 *_os << std::endl;
-std::vector<Node> nodes;
+std::vector<BlueNode> nodes;
 for (BlueNodeIt n(_graph); n != INVALID; ++n) {
 nodes.push_back(n);
 }
 if (label == 0) {
 } else {
 label->sort(nodes);
 }
 for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-Node n = nodes[i];
+BlueNode n = nodes[i];
 if (label == 0) {
 std::ostringstream os;
-os << _graph.id(n);
+os << _graph.id(static_cast<Node>(n));
 _writer_bits::writeToken(*_os, os.str());
 *_os << '\t';
-_node_index.insert(std::make_pair(n, os.str()));
+_blue_node_index.insert(std::make_pair(n, os.str()));
 }
-for (typename NodeMaps::iterator it = _blue_maps.begin();
+for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-it != _blue_maps.end(); ++it) {
+it != _blue_node_maps.end(); ++it) {
 std::string value = it->second->get(n);
 _writer_bits::writeToken(*_os, value);
 if (it->first == "label") {
-_node_index.insert(std::make_pair(n, value));
+_blue_node_index.insert(std::make_pair(n, value));
 }
 *_os << '\t';
 }
 *_os << std::endl;
 }
 }
 void createRedNodeIndex() {
-_writer_bits::MapStorageBase<Node>* label = 0;
+_writer_bits::MapStorageBase<RedNode>* label = 0;
-for (typename NodeMaps::iterator it = _red_maps.begin();
+for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-it != _red_maps.end(); ++it) {
+it != _red_node_maps.end(); ++it) {
 if (it->first == "label") {
 label = it->second;
 break;
 }
 }
 if (label == 0) {
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (RedNodeIt n(_graph); n != INVALID; ++n) {
 std::ostringstream os;
 os << _graph.id(n);
-_node_index.insert(std::make_pair(n, os.str()));
+_red_node_index.insert(std::make_pair(n, os.str()));
 }
 } else {
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (RedNodeIt n(_graph); n != INVALID; ++n) {
 std::string value = label->get(n);
-_node_index.insert(std::make_pair(n, value));
+_red_node_index.insert(std::make_pair(n, value));
 }
 }
 }
 void createBlueNodeIndex() {
-_writer_bits::MapStorageBase<Node>* label = 0;
+_writer_bits::MapStorageBase<BlueNode>* label = 0;
-for (typename NodeMaps::iterator it = _blue_maps.begin();
+for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-it != _blue_maps.end(); ++it) {
+it != _blue_node_maps.end(); ++it) {
 if (it->first == "label") {
 label = it->second;
 break;
 }
 }
 if (label == 0) {
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (BlueNodeIt n(_graph); n != INVALID; ++n) {
 std::ostringstream os;
 os << _graph.id(n);
-_node_index.insert(std::make_pair(n, os.str()));
+_blue_node_index.insert(std::make_pair(n, os.str()));
 }
 } else {
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (BlueNodeIt n(_graph); n != INVALID; ++n) {
 std::string value = label->get(n);
-_node_index.insert(std::make_pair(n, value));
+_blue_node_index.insert(std::make_pair(n, value));
 }
 }
 }
 void writeEdges() {
 label->sort(edges);
 }
 for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
 Edge e = edges[i];
-_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _red_node_index.
 find(_graph.redNode(e))->second);
 *_os << '\t';
-_writer_bits::writeToken(*_os, _node_index.
+_writer_bits::writeToken(*_os, _blue_node_index.
 find(_graph.blueNode(e))->second);
 *_os << '\t';
 if (label == 0) {
 std::ostringstream os;
 os << _graph.id(e);

changeset 1053	1c978b5bcc65
parent 1026	699c7eac2c6d
child 1074	97d978243703