diff -r 7152559e3d08 -r 892c29484414 src/lemon/bits/item_reader.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/lemon/bits/item_reader.h	Mon May 09 11:24:26 2005 +0000
@@ -0,0 +1,395 @@
+/* -*- C++ -*-
+ * src/lemon/bits/item_reader.h - Part of LEMON, a generic C++ optimization library
+ *
+ * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
+ * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ *
+ * Permission to use, modify and distribute this software is granted
+ * provided that this copyright notice appears in all copies. For
+ * precise terms see the accompanying LICENSE file.
+ *
+ * This software is provided "AS IS" with no warranty of any kind,
+ * express or implied, and with no claim as to its suitability for any
+ * purpose.
+ *
+ */
+
+/// \ingroup io_group
+/// \file
+/// \brief Item reader bits for lemon input.
+
+#ifndef LEMON_BITS_ITEM_READER_H
+#define LEMON_BITS_ITEM_READER_H
+
+#include <iostream>
+#include <string>
+
+#include <vector>
+#include <deque>
+#include <list>
+#include <set>
+
+namespace lemon {
+  
+  template <typename Value>
+  class DefaultReader;
+
+  /// \ingroup io_group
+  ///
+  /// \brief Reader class for quoted strings.
+  ///
+  /// Reader class for quoted strings. It can process the escape
+  /// sequences in the string.
+  ///
+  /// \author Balazs Dezso
+  class QuotedStringReader {
+  public:
+    /// \brief The value type of reader.
+    ///
+    /// The value type of reader.
+    typedef std::string Value;
+    
+    /// \brief Constructor for the reader.
+    ///
+    /// Constructor for the reader. If the given parameter is true
+    /// the reader processes the escape sequences.
+    QuotedStringReader(bool _escaped = true) 
+      : escaped(_escaped) {}
+    
+    /// \brief Reads a quoted string from the given stream.
+    ///
+    /// Reads a quoted string from the given stream.
+    void read(std::istream& is, std::string& value) const {
+      char c;
+      value.clear();
+      is >> std::ws;
+      if (!is.get(c) || c != '\"') 
+	throw DataFormatError("Quoted string format error");
+      while (is.get(c) && c != '\"') {
+	if (escaped && c == '\\') {
+	  value += readEscape(is);
+	} else {
+	  value += c;
+	}
+      }
+      if (!is) throw DataFormatError("Quoted string format error");
+    }
+
+  private:
+    
+    static char readEscape(std::istream& is) {
+      char c;
+      switch (is.get(c), c) {
+      case '\\':
+	return '\\';
+      case '\"':
+	return '\"';
+      case '\'':
+	return '\'';
+      case '\?':
+	return '\?';
+      case 'a':
+	return '\a';
+      case 'b':
+	return '\b';
+      case 'f':
+	return '\f';
+      case 'n':
+	return '\n';
+      case 'r':
+	return '\r';
+      case 't':
+	return '\t';
+      case 'v':
+	return '\v';
+      case 'x':
+	{
+	  int code;
+	  if (!is.get(c) || !isHex(c)) 
+	    throw DataFormatError("Escape format error");
+	  else if (code = valueHex(c), !is.get(c) || !isHex(c)) is.putback(c);
+	  else code = code * 16 + valueHex(c);
+	  return code;
+	}
+      default:
+	{
+	  int code;
+	  if (!isOct(c)) 
+	    throw DataFormatError("Escape format error");
+	  else if (code = valueOct(c), !is.get(c) || !isOct(c)) 
+	    is.putback(c);
+	  else if (code = code * 8 + valueOct(c), !is.get(c) || !isOct(c)) 
+	    is.putback(c);
+	  else code = code * 8 + valueOct(c);
+	  return code;
+	}	      
+      } 
+    }
+
+    static bool isOct(char c) {
+      return '0' <= c && c <='7'; 
+    }
+    
+    static int valueOct(char c) {
+      return c - '0';
+    }
+
+   static bool isHex(char c) {
+      return ('0' <= c && c <= '9') || 
+	('a' <= c && c <= 'z') || 
+	('A' <= c && c <= 'Z'); 
+    }
+    
+    static int valueHex(char c) {
+      if ('0' <= c && c <= '9') return c - '0';
+      if ('a' <= c && c <= 'z') return c - 'a' + 10;
+      return c - 'A' + 10;
+    }
+
+    bool escaped;
+  };
+
+  /// \ingroup io_group
+  /// \brief Reader for standard containers.
+  ///
+  /// Reader for back insertable standard containers. The representation
+  /// of the container is the values enumerated between an open and a
+  /// close parse. 
+  ///
+  /// \author Balazs Dezso
+  template <
+    typename _Container, 
+    typename _ItemReader = DefaultReader<typename _Container::value_type> 
+  >
+  class PushBackReader {
+  public:
+    typedef _Container Value;
+    typedef _ItemReader ItemReader;
+
+  private:
+
+    ItemReader item_reader;
+
+  public:
+
+    /// \brief Reads the values into the container from the given stream.
+    ///
+    /// Reads the values into the container from the given stream.
+    void read(std::istream& is, Value& value) const {
+      char c;
+      if (!(is >> c) || c != '(') 
+	throw DataFormatError("PushBackReader format error");
+      while (is >> c && c != ')') {
+	is.putback(c);
+	typename ItemReader::Value item;
+	item_reader.read(is, item);
+	value.push_back(item);
+      }
+      if (!is) throw DataFormatError("PushBackReader format error");
+      is.putback(c);
+    }
+
+  };
+
+  /// \ingroup io_group
+  ///
+  /// \brief Reader for standard containers.
+  ///
+  /// Reader for insertable standard containers. The representation
+  /// of the container is the values enumerated between an open and a
+  /// close parse. 
+  ///
+  /// \author Balazs Dezso
+  template <
+    typename _Container, 
+    typename _ItemReader = DefaultReader<typename _Container::value_type> 
+  >
+  class InsertReader {
+  public:
+    typedef _Container Value;
+    typedef _ItemReader ItemReader;
+
+  private:
+
+    ItemReader item_reader;
+
+  public:
+
+    /// \brief Reads the values into the container from the given stream.
+    ///
+    /// Reads the values into the container from the given stream.
+    void read(std::istream& is, Value& value) const {
+      char c;
+      if (!(is >> c) || c != '(') 
+	throw DataFormatError("InsertReader format error");
+      while (is >> c && c != ')') {
+	is.putback(c);
+	typename ItemReader::Value item;
+	item_reader.read(is, item);
+	value.insert(item);
+      }
+      if (!is) throw DataFormatError("PushBackReader format error");
+      is.putback(c);
+    }
+
+  };
+
+  /// \ingroup io_group
+  /// \brief Reader for parsed string.
+  ///
+  /// Reader for parsed strings. You can give the open and close
+  /// parse characters.
+  ///
+  /// \author Balazs Dezso
+  class ParsedStringReader {
+  public:
+    typedef std::string Value;
+
+    /// \brief Constructor.
+    ///
+    /// Constructor for ParsedStringReader. You can give as parameter
+    /// the open and close parse characters.
+    ParsedStringReader(char _open = '(', char _close = ')')
+      : open(_open), close(_close) {}
+    
+    
+    /// \brief Reads the parsed string from the given stream.
+    ///
+    /// Reads the parsed string from the given stream.
+    void read(std::istream& is, Value& value) const {
+      char c;
+      if (!(is >> c) || c != open) {
+	throw DataFormatError("ParsedStringReader format error");
+      }
+      value += c;
+      int counter = 1;
+      while (counter > 0 && is >> c) {
+	if (c == close) {
+	  --counter;
+	} else if (c == open) {
+	  ++counter;
+	}
+	value += c;
+      }
+      if (!is) {
+	throw DataFormatError("ParsedStrinReader format error");
+      }
+    }
+
+  private:
+    char open, close;
+
+  };
+
+  /// \ingroup io_group
+  /// \brief Reader for read the whole line.
+  ///
+  /// Reader for read the whole line.
+  ///
+  /// \author Balazs Dezso
+  class LineReader {
+  public:
+    typedef std::string Value;
+
+    /// \brief Constructor.
+    ///
+    /// Constructor for the LineReader. If the given parameter is
+    /// true then the spaces before the first not space character are
+    /// skipped.
+    LineReader(bool _skipSpaces = true) : skipSpaces(_skipSpaces) {}
+    
+    /// \brief Reads the line from the given stream.
+    ///
+    /// Reads the line from the given stream.
+    void read(std::istream& is, Value& value) {
+      if (skipSpaces) is >> std::ws;
+      if (!getline(is, value)) {
+	throw DataFormatError("LineReader forma error");
+      }
+    }
+  private:
+    bool skipSpaces;
+  };
+
+  /// \ingroup io_group
+  /// 
+  /// \brief The default item reader template class.
+  ///
+  /// The default item reader template class. If some section reader
+  /// needs to read a value from a stream it will give the default way for it.
+  ///
+  /// \author Balazs Dezso
+  template <typename _Value>
+  class DefaultReader {
+  public:
+    /// The value type.
+    typedef _Value Value;
+    /// \brief Reads a value from the given stream.
+    ///
+    /// Reads a value from the given stream.
+    void read(std::istream& is, Value& value) const {
+      if (!(is >> value)) 
+	throw DataFormatError("DefaultReader format error");
+    }
+  };
+
+  template <typename Item>
+  class DefaultReader<std::vector<Item> > 
+    : public PushBackReader<std::vector<Item> > {};
+
+  template <typename Item>
+  class DefaultReader<std::deque<Item> > 
+    : public PushBackReader<std::deque<Item> > {};
+
+  template <typename Item>
+  class DefaultReader<std::list<Item> > 
+    : public PushBackReader<std::list<Item> > {};
+
+  template <typename Item>
+  class DefaultReader<std::set<Item> > 
+    : public InsertReader<std::set<Item> > {};
+
+  template <typename Item>
+  class DefaultReader<std::multiset<Item> > 
+    : public InsertReader<std::multiset<Item> > {};
+
+  /// \ingroup io_group
+  class DefaultSkipper {
+  public:
+    typedef std::string Value;
+    
+    void read(std::istream& is, Value& value) const {
+      char c;
+      if (!(is >> c)) return;
+      is.putback(c);
+      switch (c) {
+      case '\"':
+	QuotedStringReader().read(is, value);
+	break;
+      case '(':
+	ParsedStringReader().read(is, value);
+	break;
+      default:
+	DefaultReader<std::string>().read(is, value); 
+	break;
+      }
+    }
+  };
+  
+  /// \brief Standard ReaderTraits for the GraphReader class.
+  ///
+  /// Standard ReaderTraits for the GraphReader class.
+  /// It defines standard reading method for all type of value. 
+  /// \author Balazs Dezso
+  struct DefaultReaderTraits {
+
+    template <typename _Value>
+    struct Reader : DefaultReader<_Value> {};
+
+    typedef DefaultSkipper Skipper;
+
+  };
+
+}
+
+#endif