/// \brief The bipartite graph writer class.

   ///

   /// The \c BpUGraphWriter class provides the ugraph output. To write 

   /// a graph you should first give writing commands to the writer. You can 

   /// declare write command as \c NodeMap, \c EdgeMap or \c UEdgeMap 

   /// writing and labeled Node, Edge or UEdge writing.

   ///

   ///\code

   /// BpUGraphWriter<ListUGraph> writer(std::cout, graph);

   ///\endcode

   ///

   /// The \c writeNodeMap() function declares a \c NodeMap writing 

   /// command in the \c BpUGraphWriter. You should give as parameter 

   /// the name of the map and the map object. The NodeMap writing 

   /// command with name "label" should write a unique map because it 

   /// is regarded as label map.

   ///

   ///\code

   /// IdMap<ListUGraph, Node> nodeLabelMap;

   /// writer.writeNodeMap("label", nodeLabelMap);

   ///

   /// writer.writeNodeMap("coords", coords);

   /// writer.writeNodeMap("color", colorMap);

   ///\endcode

   ///

   /// With the \c writeUEdgeMap() member function you can give an 

   /// undirected edge map writing command similar to the NodeMaps.

   ///

   ///\code

   /// DescriptorMap<ListGraph, Edge, ListGraph::EdgeMap<int> > 

   ///   edgeDescMap(graph);

   /// writer.writeUEdgeMap("descriptor", edgeDescMap);

   ///

   /// writer.writeUEdgeMap("weight", weightMap);

   /// writer.writeUEdgeMap("label", labelMap);

   ///\endcode

   /// 

   /// The EdgeMap handling is just a syntactical sugar. It writes

   /// two undirected edge map with '+' and '-' prefix in the name.

   ///

   ///\code

   /// writer.writeEdgeMap("capacity", capacityMap);

   ///\endcode

   ///

   ///

   /// With \c writeNode() and \c writeUEdge() functions you can 

   /// designate nodes and undirected edges in the graph. For example, you can 

   /// write out the source and target of the graph.

   ///

   ///\code

   /// writer.writeNode("source", sourceNode);

   /// writer.writeNode("target", targetNode);

   ///

   /// writer.writeUEdge("observed", uEdge);

   ///\endcode

   ///

   /// After you give all write commands you must call the \c run() member

   /// function, which executes all the writing commands.

   ///

   ///\code

   /// writer.run();

   ///\endcode

   ///

   /// \see DefaultWriterTraits

   /// \see QuotedStringWriter

   /// \see IdMap

   /// \see DescriptorMap

   /// \see \ref GraphWriter

   /// \see \ref graph-io-page

   /// \author Balazs Dezso

   template <typename _Graph, typename _WriterTraits = DefaultWriterTraits> 

   class BpUGraphWriter {

   public:

     typedef _Graph Graph;

     typedef typename Graph::Node Node;

     typedef typename Graph::Edge Edge;

     typedef typename Graph::UEdge UEdge;

     typedef _WriterTraits WriterTraits;

     /// \brief Construct a new BpUGraphWriter.

     ///

     /// Construct a new BpUGraphWriter. It writes the given graph

     /// to the given stream.

     BpUGraphWriter(std::ostream& _os, const Graph& _graph) 

       : writer(new LemonWriter(_os)), own_writer(true), 

 	nodeset_writer(*writer, _graph, std::string()),

 	uedgeset_writer(*writer, _graph, nodeset_writer, std::string()),

 	node_writer(*writer, nodeset_writer, std::string()),

 	uedge_writer(*writer, uedgeset_writer, std::string()),

 	attribute_writer(*writer, std::string()) {}

     /// \brief Construct a new BpUGraphWriter.

     ///

     /// Construct a new BpUGraphWriter. It writes the given graph

     /// to the given file.

     BpUGraphWriter(const std::string& _filename, const Graph& _graph) 

       : writer(new LemonWriter(_filename)), own_writer(true), 

 	nodeset_writer(*writer, _graph, std::string()),

 	uedgeset_writer(*writer, _graph, nodeset_writer, std::string()),

 	node_writer(*writer, nodeset_writer, std::string()),

 	uedge_writer(*writer, uedgeset_writer, std::string()),

 	attribute_writer(*writer, std::string()) {}

     /// \brief Construct a new BpUGraphWriter.

     ///

     /// Construct a new BpUGraphWriter. It writes the given graph

     /// to given LemonWriter.

     BpUGraphWriter(LemonWriter& _writer, const Graph& _graph)

       : writer(_writer), own_writer(false), 

 	nodeset_writer(*writer, _graph, std::string()),

 	uedgeset_writer(*writer, _graph, nodeset_writer, std::string()),

 	node_writer(*writer, nodeset_writer, std::string()),

 	uedge_writer(*writer, uedgeset_writer, std::string()),

 	attribute_writer(*writer, std::string()) {}

     /// \brief Destruct the graph writer.

     ///

     /// Destruct the graph writer.

     ~BpUGraphWriter() {

       if (own_writer) 

 	delete writer;

     }

     /// \brief Issue a new node map writing command to the writer.

     ///

     /// This function issues a new <i> node map writing command</i> to

     /// the writer.

     template <typename Map>

     BpUGraphWriter& writeNodeMap(std::string label, const Map& map) {

       nodeset_writer.writeNodeMap(label, map);

       return *this;

     }

     /// \brief Issue a new node map writing command to the writer.

     ///

     /// This function issues a new <i> node map writing command</i> to

     /// the writer.

     template <typename ItemWriter, typename Map>

     BpUGraphWriter& writeNodeMap(std::string label, const Map& map, 

 			      const ItemWriter& iw = ItemWriter()) {

       nodeset_writer.writeNodeMap(label, map, iw);

       return *this;

     }

     /// \brief Issue a new A-node map writing command to the writer.

     ///

     /// This function issues a new <i> A-node map writing command</i> to

     /// the writer.

     template <typename Map>

     BpUGraphWriter& writeANodeMap(std::string label, const Map& map) {

       nodeset_writer.writeANodeMap(label, map);

       return *this;

     }

     /// \brief Issue a new A-node map writing command to the writer.

     ///

     /// This function issues a new <i> A-node map writing command</i> to

     /// the writer.

     template <typename ItemWriter, typename Map>

     BpUGraphWriter& writeANodeMap(std::string label, const Map& map, 

 			      const ItemWriter& iw = ItemWriter()) {

       nodeset_writer.writeANodeMap(label, map, iw);

       return *this;

     }

     /// \brief Issue a new B-node map writing command to the writer.

     ///

     /// This function issues a new <i> B-node map writing command</i> to

     /// the writer.

     template <typename Map>

     BpUGraphWriter& writeBNodeMap(std::string label, const Map& map) {

       nodeset_writer.writeBNodeMap(label, map);

       return *this;

     }

     /// \brief Issue a new B-node map writing command to the writer.

     ///

     /// This function issues a new <i> B-node map writing command</i> to

     /// the writer.

     template <typename ItemWriter, typename Map>

     BpUGraphWriter& writeBNodeMap(std::string label, const Map& map, 

 			      const ItemWriter& iw = ItemWriter()) {

       nodeset_writer.writeBNodeMap(label, map, iw);

       return *this;

     }

     /// \brief Issue a new edge map writing command to the writer.

     ///

     /// This function issues a new <i> edge map writing command</i> to

     /// the writer.

     template <typename Map>

     BpUGraphWriter& writeEdgeMap(std::string label, const Map& map) { 

       uedgeset_writer.writeEdgeMap(label, map);

       return *this;

     }

     /// \brief Issue a new edge map writing command to the writer.

     ///

     /// This function issues a new <i> edge map writing command</i> to

     /// the writer.

     template <typename ItemWriter, typename Map>

     BpUGraphWriter& writeEdgeMap(std::string label, const Map& map,

 				   const ItemWriter& iw = ItemWriter()) {

       uedgeset_writer.writeEdgeMap(label, map, iw);

       return *this;

     }

     /// \brief Issue a new undirected edge map writing command to the writer.

     ///

     /// This function issues a new <i> undirected edge map writing

     /// command</i> to the writer.

     template <typename Map>

     BpUGraphWriter& writeUEdgeMap(std::string label, const Map& map) { 

       uedgeset_writer.writeUEdgeMap(label, map);

       return *this;

     }

     /// \brief Issue a new undirected edge map writing command to the writer.

     ///

     /// This function issues a new <i> undirected edge map writing

     /// command</i> to the writer.

    template <typename ItemWriter, typename Map>

     BpUGraphWriter& writeUEdgeMap(std::string label, const Map& map,

 					const ItemWriter& iw = ItemWriter()) {

       uedgeset_writer.writeUEdgeMap(label, map, iw);

       return *this;

     }

     /// \brief Issue a new labeled node writer to the writer.

     ///

     /// This function issues a new <i> labeled node writing

     /// command</i> to the writer.

     BpUGraphWriter& writeNode(std::string label, const Node& node) {

       node_writer.writeNode(label, node);

       return *this;

     }

     /// \brief Issue a new labeled edge writer to the writer.

     ///

     /// This function issues a new <i> labeled edge writing

     /// command</i> to the writer.

     BpUGraphWriter& writeEdge(std::string label, const Edge& edge) {

       uedge_writer.writeEdge(label, edge);

     }

     /// \brief Issue a new labeled undirected edge writing command to

     /// the writer.

     ///

     /// Issue a new <i>labeled undirected edge writing command</i> to

     /// the writer.

     BpUGraphWriter& writeUEdge(std::string label, const UEdge& edge) {

       uedge_writer.writeUEdge(label, edge);

     }

     /// \brief Issue a new attribute writing command.

     ///

     /// This function issues a new <i> attribute writing

     /// command</i> to the writer.

     template <typename Value>

     BpUGraphWriter& writeAttribute(std::string label, const Value& value) {

       attribute_writer.writeAttribute(label, value);

       return *this;

     }

     /// \brief Issue a new attribute writing command.

     ///

     /// This function issues a new <i> attribute writing

     /// command</i> to the writer.

     template <typename ItemWriter, typename Value>

     BpUGraphWriter& writeAttribute(std::string label, const Value& value, 

 			       const ItemWriter& iw = ItemWriter()) {

       attribute_writer.writeAttribute(label, value, iw);

       return *this;

     }

     /// \brief Conversion operator to LemonWriter.

     ///

     /// Conversion operator to LemonWriter. It makes possible

     /// to access the encapsulated \e LemonWriter, this way

     /// you can attach to this writer new instances of 

     /// \e LemonWriter::SectionWriter.

     operator LemonWriter&() {

       return *writer;

     }

     /// \brief Executes the writing commands.

     ///

     /// Executes the writing commands.

     void run() {

       writer->run();

     }

     /// \brief Returns true if the writer can give back the labels by the items.

     ///

     /// Returns true if the writer can give back the the labels by the items.

     bool isLabelWriter() const {

       return nodeset_writer.isLabelWriter() && 

         uedgeset_writer.isLabelWriter();

     }

     /// \brief Write the label of the given node.

     ///

     /// It writes the label of the given node. If there was written a "label"

     /// named node map then it will write the map value belonging to the node.

     void writeLabel(std::ostream& os, const Node& item) const {

       nodeset_writer.writeLabel(os, item);

     } 

     /// \brief Write the label of the given edge.

     ///

     /// It writes the label of the given edge. If there was written a "label"

     /// named edge map then it will write the map value belonging to the edge.

     void writeLabel(std::ostream& os, const Edge& item) const {

       uedgeset_writer.writeLabel(os, item);

     } 

     /// \brief Write the label of the given undirected edge.

     ///

     /// It writes the label of the given undirected edge. If there was

     /// written a "label" named edge map then it will write the map

     /// value belonging to the edge.

     void writeLabel(std::ostream& os, const UEdge& item) const {

       uedgeset_writer.writeLabel(os, item);

     } 

     /// \brief Sorts the given node vector by label.

     ///

     /// Sorts the given node vector by label. If there was written an

     /// "label" named map then the vector will be sorted by the values

     /// of this map. Otherwise if the \c forceLabel parameter was true

     /// it will be sorted by its id in the graph.

     void sortByLabel(std::vector<Node>& nodes) const {

       nodeset_writer.sortByLabel(nodes);

     }

     /// \brief Sorts the given edge vector by label.

     ///

     /// Sorts the given edge vector by label. If there was written an

     /// "label" named map then the vector will be sorted by the values

     /// of this map. Otherwise if the \c forceLabel parameter was true

     /// it will be sorted by its id in the graph.

     void sortByLabel(std::vector<Edge>& edges) const {

       uedgeset_writer.sortByLabel(edges);

     }

     /// \brief Sorts the given undirected edge vector by label.

     ///

     /// Sorts the given undirected edge vector by label. If there was

     /// written an "label" named map then the vector will be sorted by

     /// the values of this map. Otherwise if the \c forceLabel

     /// parameter was true it will be sorted by its id in the graph.

     void sortByLabel(std::vector<UEdge>& uedges) const {

       uedgeset_writer.sortByLabel(uedges);

     }

   private:

     LemonWriter* writer;

     bool own_writer;

     BpNodeSetWriter<Graph, WriterTraits> nodeset_writer;

     UEdgeSetWriter<Graph, WriterTraits> uedgeset_writer;

     NodeWriter<Graph> node_writer;

     UEdgeWriter<Graph> uedge_writer;

     AttributeWriter<WriterTraits> attribute_writer;

   };