lemon-0.x: comparison lemon/lemon

equal deleted inserted replaced

-:116adb6cea5e
+:2ac77655d3e6
 #include <lemon/error.h>
 #include <lemon/graph_utils.h>
 #include <lemon/utility.h>
 #include <lemon/bits/item_reader.h>
+#include <lemon/xy.h>
 #include <lemon/concept_check.h>
 #include <lemon/concept/maps.h>
 namespace lemon {
 bool operator()(const T& p, const T& q) const {
 	return p < q;
 }
 };
-template <typename M1, typename M2>
+template <typename Map>
-class WriteComposeMap {
+struct Ref { typedef Map& Type; };
+template <typename Map>
+struct Arg { typedef Map& Type; };
+template <typename Graph, typename Map>
+class ForwardComposeMap {
 public:
-typedef True NeedCopy;
+typedef typename Graph::UndirEdge Key;
+typedef typename Map::Value Value;
+ForwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
+	: graph(_graph), map(_map) {}
-typedef typename M2::Key Key;
+void set(const Key& key, const Value& val) {
-typedef typename M1::Value Value;
+	map.set(graph.direct(key, true), val);
+}
-WriteComposeMap(typename SmartParameter<M1>::Type _m1, const M2& _m2)
-	: m1(_m1), m2(_m2) {}
+private:
+typename Ref<Map>::Type map;
+const Graph& graph;
+};
+template <typename Graph, typename Map>
+ForwardComposeMap<Graph, Map>
+forwardComposeMap(const Graph& graph, const Map& map) {
+return ForwardComposeMap<Graph, Map>(graph, map);
+}
+template <typename Graph, typename Map>
+ForwardComposeMap<Graph, Map>
+forwardComposeMap(const Graph& graph, Map& map) {
+return ForwardComposeMap<Graph, Map>(graph, map);
+}
+template <typename Graph, typename Map>
+class BackwardComposeMap {
+public:
+typedef typename Graph::UndirEdge Key;
+typedef typename Map::Value Value;
+BackwardComposeMap(const Graph& _graph, typename Arg<Map>::Type _map)
+	: graph(_graph), map(_map) {}
-void set(const Key& key, const Value& value) {
+void set(const Key& key, const Value& val) {
-	m1.set(m2[key], value);
+	map.set(graph.direct(key, false), val);
 }
 private:
+typename Ref<Map>::Type map;
-typename SmartReference<M1>::Type m1;
+const Graph& graph;
-typename SmartConstReference<M2>::Type m2;
+};
-};
+template <typename Graph, typename Map>
-template <typename M1, typename M2>
+BackwardComposeMap<Graph, Map>
-WriteComposeMap<M1, M2> writeComposeMap(M1& m1, const M2& m2) {
+backwardComposeMap(const Graph& graph, const Map& map) {
-return WriteComposeMap<M1, M2>(m1, m2);
+return BackwardComposeMap<Graph, Map>(graph, map);
 }
-template <typename M1, typename M2>
+template <typename Graph, typename Map>
-WriteComposeMap<M1, M2> writeComposeMap(const M1& m1, const M2& m2) {
+BackwardComposeMap<Graph, Map>
-return WriteComposeMap<M1, M2>(m1, m2);
+backwardComposeMap(const Graph& graph, Map& map) {
-}
+return BackwardComposeMap<Graph, Map>(graph, map);
+}
+template <typename Graph, typename Map>
+struct Ref<ForwardComposeMap<Graph, Map> > {
+typedef ForwardComposeMap<Graph, Map> Type;
+};
+template <typename Graph, typename Map>
+struct Arg<ForwardComposeMap<Graph, Map> > {
+typedef const ForwardComposeMap<Graph, Map>& Type;
+};
+template <typename Graph, typename Map>
+struct Ref<BackwardComposeMap<Graph, Map> > {
+typedef BackwardComposeMap<Graph, Map> Type;
+};
+template <typename Graph, typename Map>
+struct Arg<BackwardComposeMap<Graph, Map> > {
+typedef const BackwardComposeMap<Graph, Map>& Type;
+};
+template <typename Map>
+struct Ref<XMap<Map> > {
+typedef XMap<Map> Type;
+};
+template <typename Map>
+struct Arg<XMap<Map> > {
+typedef const XMap<Map>& Type;
+};
+template <typename Map>
+struct Ref<YMap<Map> > {
+typedef YMap<Map> Type;
+};
+template <typename Map>
+struct Arg<YMap<Map> > {
+typedef const YMap<Map>& Type;
+};
 }
 /// \ingroup io_group
 /// \brief Lemon Format reader class.
 ///
 typedef _Reader Reader;
 typedef typename Reader::Value Value;
 typedef _Map Map;
 typedef std::map<Value, Item, _reader_bits::Less<Value> > Inverse;
-typename SmartReference<Map>::Type map;
+typename _reader_bits::Ref<Map>::Type map;
 Reader reader;
 Inverse inverse;
-MapReaderInverter(typename SmartParameter<Map>::Type _map,
+MapReaderInverter(typename _reader_bits::Arg<Map>::Type _map,
 			const Reader& _reader)
 	: map(_map), reader(_reader) {}
 virtual ~MapReaderInverter() {}
 typedef _Map Map;
 typedef _Reader Reader;
 typedef typename Reader::Value Value;
 typedef _Item Item;
-typename SmartReference<Map>::Type map;
+typename _reader_bits::Ref<Map>::Type map;
 Reader reader;
-MapReader(typename SmartParameter<Map>::Type _map,
+MapReader(typename _reader_bits::Arg<Map>::Type _map,
 		const Reader& _reader)
 	: map(_map), reader(_reader) {}
 virtual ~MapReader() {}
 /// Constructor for NodeSetReader. It creates the NodeSetReader and
 /// attach it into the given LemonReader. The nodeset reader will
 /// add the readed nodes to the given Graph. The reader will read
 /// the section when the \c section_id and the \c _id are the same.
 NodeSetReader(LemonReader& _reader,
-		  typename SmartParameter<Graph>::Type _graph,
+		  Graph& _graph,
 		  const std::string& _id = std::string(),
 		  const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {}
 /// Add a new node map reader command for the reader.
 template <typename Map>
 NodeSetReader& readNodeMap(std::string name, Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
 NodeSetReader& readNodeMap(std::string name, const Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new node map reader command for the reader.
 ///
 /// Add a new node map reader command for the reader.
 template <typename Reader, typename Map>
 NodeSetReader& readNodeMap(std::string name, Map& map,
 			       const Reader& reader = Reader()) {
-return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
+return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 template <typename Reader, typename Map>
 NodeSetReader& readNodeMap(std::string name, const Map& map,
 			       const Reader& reader = Reader()) {
-return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
+return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 private:
 private:
 typedef std::map<std::string, ReaderBase<Node>*> MapReaders;
 MapReaders readers;
-typename SmartReference<Graph>::Type graph;
+Graph& graph;
 std::string id;
 SkipReader<Node, DefaultSkipper> skipper;
 std::auto_ptr<InverterBase<Node> > inverter;
 };
 /// node id reader to read the source and target nodes of the edges.
 /// The reader will read the section only if the \c _id and the
 /// \c edgset_id are the same.
 template <typename NodeIdReader>
 EdgeSetReader(LemonReader& _reader,
-		  typename SmartParameter<Graph>::Type _graph,
+		  Graph& _graph,
 		  const NodeIdReader& _nodeIdReader,
 		  const std::string& _id = std::string(),
 		  const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
 checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
 /// Add a new edge map reader command for the reader.
 template <typename Map>
 EdgeSetReader& readEdgeMap(std::string name, Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
 EdgeSetReader& readEdgeMap(std::string name, const Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new edge map reader command for the reader.
 ///
 /// Add a new edge map reader command for the reader.
 template <typename Reader, typename Map>
 EdgeSetReader& readEdgeMap(std::string name, Map& map,
 			   const Reader& reader = Reader()) {
 return _readMap<Reader, Map,
-	typename SmartParameter<Map>::Type>(name, map, reader);
+	typename _reader_bits::Arg<Map>::Type>(name, map, reader);
 }
 template <typename Reader, typename Map>
 EdgeSetReader& readEdgeMap(std::string name, const Map& map,
 			       const Reader& reader = Reader()) {
 return _readMap<Reader, Map,
-	typename SmartParameter<Map>::Type>(name, map, reader);
+	typename _reader_bits::Arg<Map>::Type>(name, map, reader);
 }
 private:
 template <typename Reader, typename Map, typename MapParameter>
 private:
 typedef std::map<std::string, ReaderBase<Edge>*> MapReaders;
 MapReaders readers;
-typename SmartReference<Graph>::Type graph;
+Graph& graph;
 std::string id;
 SkipReader<Edge, DefaultSkipper> skipper;
 std::auto_ptr<InverterBase<Edge> > inverter;
 std::auto_ptr<IdReaderBase<Node> > nodeIdReader;
 /// will use the given node id reader to read the source and target
 /// nodes of the edges. The reader will read the section only if the
 /// \c _id and the \c undiredgset_id are the same.
 template <typename NodeIdReader>
 UndirEdgeSetReader(LemonReader& _reader,
-		       typename SmartParameter<Graph>::Type _graph,
+		       Graph& _graph,
 		       const NodeIdReader& _nodeIdReader,
 		       const std::string& _id = std::string(),
 		       const DefaultSkipper& _skipper = DefaultSkipper())
 : Parent(_reader), graph(_graph), id(_id), skipper(_skipper) {
 checkConcept<_reader_bits::ItemIdReader<Node>, NodeIdReader>();
 /// Add a new edge undirected map reader command for the reader.
 template <typename Map>
 UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
 UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map) {
 return _readMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new undirected edge map reader command for the reader.
 ///
 /// Add a new edge undirected map reader command for the reader.
 template <typename Reader, typename Map>
 UndirEdgeSetReader& readUndirEdgeMap(std::string name, Map& map,
 					 const Reader& reader = Reader()) {
-return _readMap<Reader, Map, typename SmartParameter<Map>::Type>
+return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 template <typename Reader, typename Map>
 UndirEdgeSetReader& readUndirEdgeMap(std::string name, const Map& map,
 					 const Reader& reader = Reader()) {
-return _readMap<Reader, Map, typename SmartParameter<Map>::Type >
+return _readMap<Reader, Map, typename _reader_bits::Arg<Map>::Type >
 	(name, map, reader);
 }
 private:
 /// Add a new directed edge map reader command for the reader.
 template <typename Map>
 UndirEdgeSetReader& readEdgeMap(std::string name, Map& map) {
 return _readDirMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 template <typename Map>
 UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map) {
 return _readDirMap<
 	typename Traits::template Reader<typename Map::Value>, Map,
-	typename SmartParameter<Map>::Type>(name, map);
+	typename _reader_bits::Arg<Map>::Type>(name, map);
 }
 /// \brief Add a new directed edge map reader command for the reader.
 ///
 /// Add a new directed edge map reader command for the reader.
 template <typename Reader, typename Map>
 UndirEdgeSetReader& readEdgeMap(std::string name, Map& map,
 				    const Reader& reader = Reader()) {
-return _readDirMap<Reader, Map, typename SmartParameter<Map>::Type>
+return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 template <typename Reader, typename Map>
 UndirEdgeSetReader& readEdgeMap(std::string name, const Map& map,
 				    const Reader& reader = Reader()) {
-return _readDirMap<Reader, Map, typename SmartParameter<Map>::Type>
+return _readDirMap<Reader, Map, typename _reader_bits::Arg<Map>::Type>
 	(name, map, reader);
 }
 private:
 UndirEdgeSetReader& _readDirMap(std::string name, MapParameter map,
 				    const Reader& reader = Reader()) {
 checkConcept<_reader_bits::ItemReader<typename Map::Value>, Reader>();
 checkConcept<concept::WriteMap<Edge, typename Map::Value>, Map>();
 readMap("+" + name,
-	      _reader_bits::writeComposeMap(map, forwardMap(graph)), reader);
+	      _reader_bits::forwardComposeMap(graph, map), reader);
 readMap("-" + name,
-	      _reader_bits::writeComposeMap(map, backwardMap(graph)), reader);
+	      _reader_bits::backwardComposeMap(graph, map), reader);
 return *this;
 }
 public:
 private:
 typedef std::map<std::string, ReaderBase<UndirEdge>*> MapReaders;
 MapReaders readers;
-typename SmartReference<Graph>::Type graph;
+Graph& graph;
 std::string id;
 SkipReader<UndirEdge, DefaultSkipper> skipper;
 std::auto_ptr<InverterBase<UndirEdge> > inverter;
 std::auto_ptr<IdReaderBase<Node> > nodeIdReader;

changeset 1719	674182524bd9
parent 1627	3fd1ba6e9872
child 1722	2acb5f9bfa72