lemon: comparison lemon/lgf

equal deleted inserted replaced

-:2a971021d49d
+:f5dcfc2af6eb
 virtual void set(const std::string& value) {
 _value = _converter(value);
 }
 };
-template <typename Value>
+template <typename Value,
+typename Map = std::map<std::string, Value> >
 struct MapLookUpConverter {
-const std::map<std::string, Value>& _map;
+const Map& _map;
-MapLookUpConverter(const std::map<std::string, Value>& map)
+MapLookUpConverter(const Map& map)
 : _map(map) {}
 Value operator()(const std::string& str) {
-typename std::map<std::string, Value>::const_iterator it =
+typename Map::const_iterator it = _map.find(str);
-_map.find(str);
 if (it == _map.end()) {
 std::ostringstream msg;
 msg << "Item not found: " << str;
 throw FormatError(msg.str());
 }
 return it->second;
+}
+};
+template <typename Value,
+typename Map1 = std::map<std::string, Value>,
+typename Map2 = std::map<std::string, Value> >
+struct DoubleMapLookUpConverter {
+const Map1& _map1;
+const Map2& _map2;
+DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
+: _map1(map1), _map2(map2) {}
+Value operator()(const std::string& str) {
+typename Map1::const_iterator it1 = _map1.find(str);
+typename Map2::const_iterator it2 = _map2.find(str);
+if (it1 == _map1.end()) {
+if (it2 == _map2.end()) {
+std::ostringstream msg;
+msg << "Item not found: " << str;
+throw FormatError(msg.str());
+} else {
+return it2->second;
+}
+} else {
+if (it2 == _map2.end()) {
+return it1->second;
+} else {
+std::ostringstream msg;
+msg << "Item is ambigous: " << str;
+throw FormatError(msg.str());
+}
+}
 }
 };
 template <typename GR>
 struct GraphArcLookUpConverter {
 std::string _nodes_caption;
 std::string _edges_caption;
 std::string _attributes_caption;
-typedef std::map<std::string, Node> NodeIndex;
+typedef std::map<std::string, RedNode> RedNodeIndex;
-NodeIndex _node_index;
+RedNodeIndex _red_node_index;
+typedef std::map<std::string, BlueNode> BlueNodeIndex;
+BlueNodeIndex _blue_node_index;
 typedef std::map<std::string, Edge> EdgeIndex;
 EdgeIndex _edge_index;
 typedef std::vector<std::pair<std::string,
-_reader_bits::MapStorageBase<Node>*> > NodeMaps;
+_reader_bits::MapStorageBase<RedNode>*> > RedNodeMaps;
-NodeMaps _red_maps;
+RedNodeMaps _red_node_maps;
-NodeMaps _blue_maps;
+typedef std::vector<std::pair<std::string,
+_reader_bits::MapStorageBase<BlueNode>*> > BlueNodeMaps;
+BlueNodeMaps _blue_node_maps;
 typedef std::vector<std::pair<std::string,
 _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
 EdgeMaps _edge_maps;
 }
 }
 /// \brief Destructor
 ~BpGraphReader() {
-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._is = 0;
 other.local_is = 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 reading rule to the reader.
 template <typename Map>
 BpGraphReader& nodeMap(const std::string& caption, Map& map) {
 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* red_storage =
+_reader_bits::MapStorageBase<RedNode>* red_storage =
-new _reader_bits::MapStorage<Node, Map>(map);
+new _reader_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));
-_reader_bits::MapStorageBase<Node>* blue_storage =
+_reader_bits::MapStorageBase<BlueNode>* blue_storage =
-new _reader_bits::MapStorage<Node, Map>(map);
+new _reader_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 reading rule
 ///
 /// reader.
 template <typename Map, typename Converter>
 BpGraphReader& nodeMap(const std::string& caption, Map& map,
 const Converter& converter = Converter()) {
 checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* red_storage =
+_reader_bits::MapStorageBase<RedNode>* red_storage =
-new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _reader_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));
-_reader_bits::MapStorageBase<Node>* blue_storage =
+_reader_bits::MapStorageBase<BlueNode>* blue_storage =
-new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _reader_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;
 }
 /// Add a red node map reading rule to the reader.
 template <typename Map>
 BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
-checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* storage =
+_reader_bits::MapStorageBase<RedNode>* storage =
-new _reader_bits::MapStorage<Node, Map>(map);
+new _reader_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 reading rule
 ///
 /// Add a red node map node reading rule with specialized converter to
 /// the reader.
 template <typename Map, typename Converter>
 BpGraphReader& redNodeMap(const std::string& caption, Map& map,
 const Converter& converter = Converter()) {
-checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* storage =
+_reader_bits::MapStorageBase<RedNode>* storage =
-new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _reader_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;
 }
 /// Add a blue node map reading rule to the reader.
 template <typename Map>
 BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
-checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* storage =
+_reader_bits::MapStorageBase<BlueNode>* storage =
-new _reader_bits::MapStorage<Node, Map>(map);
+new _reader_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 reading rule
 ///
 /// Add a blue node map reading rule with specialized converter to
 /// the reader.
 template <typename Map, typename Converter>
 BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
 const Converter& converter = Converter()) {
-checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
+checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-_reader_bits::MapStorageBase<Node>* storage =
+_reader_bits::MapStorageBase<BlueNode>* storage =
-new _reader_bits::MapStorage<Node, Map, Converter>(map, converter);
+new _reader_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 reading rule
 ///
 /// \brief Node reading rule
 ///
 /// Add a node reading rule to reader.
 BpGraphReader& node(const std::string& caption, Node& node) {
-typedef _reader_bits::MapLookUpConverter<Node> Converter;
+typedef _reader_bits::DoubleMapLookUpConverter<
-Converter converter(_node_index);
+Node, RedNodeIndex, BlueNodeIndex> Converter;
+Converter converter(_red_node_index, _blue_node_index);
 _reader_bits::ValueStorageBase* storage =
 new _reader_bits::ValueStorage<Node, Converter>(node, converter);
+_attributes.insert(std::make_pair(caption, storage));
+return *this;
+}
+/// \brief Red node reading rule
+///
+/// Add a red node reading rule to reader.
+BpGraphReader& redNode(const std::string& caption, RedNode& node) {
+typedef _reader_bits::MapLookUpConverter<RedNode> Converter;
+Converter converter(_red_node_index);
+_reader_bits::ValueStorageBase* storage =
+new _reader_bits::ValueStorage<RedNode, Converter>(node, converter);
+_attributes.insert(std::make_pair(caption, storage));
+return *this;
+}
+/// \brief Blue node reading rule
+///
+/// Add a blue node reading rule to reader.
+BpGraphReader& blueNode(const std::string& caption, BlueNode& node) {
+typedef _reader_bits::MapLookUpConverter<BlueNode> Converter;
+Converter converter(_blue_node_index);
+_reader_bits::ValueStorageBase* storage =
+new _reader_bits::ValueStorage<BlueNode, Converter>(node, converter);
 _attributes.insert(std::make_pair(caption, storage));
 return *this;
 }
 /// \brief Edge reading rule
 BpGraphReader& useNodes(const Map& map) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 _use_nodes = true;
 _writer_bits::DefaultConverter<typename Map::Value> converter;
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (RedNodeIt n(_graph); n != INVALID; ++n) {
-_node_index.insert(std::make_pair(converter(map[n]), n));
+_red_node_index.insert(std::make_pair(converter(map[n]), n));
+}
+for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+_blue_node_index.insert(std::make_pair(converter(map[n]), n));
 }
 return *this;
 }
 /// \brief Use previously constructed node set
 BpGraphReader& useNodes(const Map& map,
 const Converter& converter = Converter()) {
 checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
 LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
 _use_nodes = true;
-for (NodeIt n(_graph); n != INVALID; ++n) {
+for (RedNodeIt n(_graph); n != INVALID; ++n) {
-_node_index.insert(std::make_pair(converter(map[n]), n));
+_red_node_index.insert(std::make_pair(converter(map[n]), n));
+}
+for (BlueNodeIt n(_graph); n != INVALID; ++n) {
+_blue_node_index.insert(std::make_pair(converter(map[n]), n));
 }
 return *this;
 }
 /// \brief Use previously constructed edge set
 }
 }
 void readRedNodes() {
-std::vector<int> map_index(_red_maps.size());
+std::vector<int> map_index(_red_node_maps.size());
 int map_num, label_index;
 char c;
 if (!readLine() || !(line >> c) || c == '@') {
 if (readSuccess() && line) line.putback(c);
-if (!_red_maps.empty())
+if (!_red_node_maps.empty())
 throw FormatError("Cannot find map names");
 return;
 }
 line.putback(c);
 }
 maps.insert(std::make_pair(map, index));
 ++index;
 }
-for (int i = 0; i < static_cast<int>(_red_maps.size()); ++i) {
+for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
 std::map<std::string, int>::iterator jt =
-maps.find(_red_maps[i].first);
+maps.find(_red_node_maps[i].first);
 if (jt == maps.end()) {
 std::ostringstream msg;
-msg << "Map not found: " << _red_maps[i].first;
+msg << "Map not found: " << _red_node_maps[i].first;
 throw FormatError(msg.str());
 }
 map_index[i] = jt->second;
 }
 }
 }
 if (line >> std::ws >> c)
 throw FormatError("Extra character at the end of line");
-Node n;
+RedNode n;
 if (!_use_nodes) {
 n = _graph.addRedNode();
 if (label_index != -1)
-_node_index.insert(std::make_pair(tokens[label_index], n));
+_red_node_index.insert(std::make_pair(tokens[label_index], n));
 } else {
 if (label_index == -1)
 throw FormatError("Label map not found");
-typename std::map<std::string, Node>::iterator it =
+typename std::map<std::string, RedNode>::iterator it =
-_node_index.find(tokens[label_index]);
+_red_node_index.find(tokens[label_index]);
-if (it == _node_index.end()) {
+if (it == _red_node_index.end()) {
 std::ostringstream msg;
 msg << "Node with label not found: " << tokens[label_index];
 throw FormatError(msg.str());
 }
 n = it->second;
 }
-for (int i = 0; i < static_cast<int>(_red_maps.size()); ++i) {
+for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
-_red_maps[i].second->set(n, tokens[map_index[i]]);
+_red_node_maps[i].second->set(n, tokens[map_index[i]]);
 }
 }
 if (readSuccess()) {
 line.putback(c);
 }
 }
 void readBlueNodes() {
-std::vector<int> map_index(_blue_maps.size());
+std::vector<int> map_index(_blue_node_maps.size());
 int map_num, label_index;
 char c;
 if (!readLine() || !(line >> c) || c == '@') {
 if (readSuccess() && line) line.putback(c);
-if (!_blue_maps.empty())
+if (!_blue_node_maps.empty())
 throw FormatError("Cannot find map names");
 return;
 }
 line.putback(c);
 }
 maps.insert(std::make_pair(map, index));
 ++index;
 }
-for (int i = 0; i < static_cast<int>(_blue_maps.size()); ++i) {
+for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
 std::map<std::string, int>::iterator jt =
-maps.find(_blue_maps[i].first);
+maps.find(_blue_node_maps[i].first);
 if (jt == maps.end()) {
 std::ostringstream msg;
-msg << "Map not found: " << _blue_maps[i].first;
+msg << "Map not found: " << _blue_node_maps[i].first;
 throw FormatError(msg.str());
 }
 map_index[i] = jt->second;
 }
 }
 }
 if (line >> std::ws >> c)
 throw FormatError("Extra character at the end of line");
-Node n;
+BlueNode n;
 if (!_use_nodes) {
 n = _graph.addBlueNode();
 if (label_index != -1)
-_node_index.insert(std::make_pair(tokens[label_index], n));
+_blue_node_index.insert(std::make_pair(tokens[label_index], n));
 } else {
 if (label_index == -1)
 throw FormatError("Label map not found");
-typename std::map<std::string, Node>::iterator it =
+typename std::map<std::string, BlueNode>::iterator it =
-_node_index.find(tokens[label_index]);
+_blue_node_index.find(tokens[label_index]);
-if (it == _node_index.end()) {
+if (it == _blue_node_index.end()) {
 std::ostringstream msg;
 msg << "Node with label not found: " << tokens[label_index];
 throw FormatError(msg.str());
 }
 n = it->second;
 }
-for (int i = 0; i < static_cast<int>(_blue_maps.size()); ++i) {
+for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
-_blue_maps[i].second->set(n, tokens[map_index[i]]);
+_blue_node_maps[i].second->set(n, tokens[map_index[i]]);
 }
 }
 if (readSuccess()) {
 line.putback(c);
 if (line >> std::ws >> c)
 throw FormatError("Extra character at the end of line");
 Edge e;
 if (!_use_edges) {
+typename RedNodeIndex::iterator rit =
-typename NodeIndex::iterator it;
+_red_node_index.find(source_token);
+if (rit == _red_node_index.end()) {
-it = _node_index.find(source_token);
-if (it == _node_index.end()) {
 std::ostringstream msg;
 msg << "Item not found: " << source_token;
 throw FormatError(msg.str());
 }
-Node source = it->second;
+RedNode source = rit->second;
-if (!_graph.red(source)) {
+typename BlueNodeIndex::iterator it =
-std::ostringstream msg;
+_blue_node_index.find(target_token);
-msg << "Item is not red node: " << source_token;
+if (it == _blue_node_index.end()) {
-throw FormatError(msg.str());
-}
-it = _node_index.find(target_token);
-if (it == _node_index.end()) {
 std::ostringstream msg;
 msg << "Item not found: " << target_token;
 throw FormatError(msg.str());
 }
-Node target = it->second;
+BlueNode target = it->second;
-if (!_graph.blue(target)) {
-std::ostringstream msg;
-msg << "Item is not red node: " << source_token;
-throw FormatError(msg.str());
-}
 // It is checked that source is red and
 // target is blue, so this should be safe:
-e = _graph.addEdge(_graph.asRedNodeUnsafe(source),
+e = _graph.addEdge(source, target);
-_graph.asBlueNodeUnsafe(target));
 if (label_index != -1)
 _edge_index.insert(std::make_pair(tokens[label_index], e));
 } else {
 if (label_index == -1)
 throw FormatError("Label map not found");

changeset 1198	4936be66d2f5
parent 1197	374a9519986b
child 1250	97d978243703