source: lemon-0.x/lemon/bits/item_reader.h @ 2276:1a8a66b6c6ce

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2006
 * 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 item_io
/// \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 item_io
  ///
  /// \brief Reader class for unformatted strings.
  ///
  /// Reader class for unformatted strings. This class want to be
  /// a general reader type which can read the most 
  ///
  /// \author Balazs Dezso
  class UnformattedReader {
  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.
    UnformattedReader() {} 
    
    /// \brief Reads an unformatted string from the given stream.
    ///
    /// Reads an unformatted string from the given stream.
    void read(std::istream& is, std::string& value) const {
      char c;
      value.clear();
      is >> std::ws;
      while (is.get(c) && !whiteSpace(c)) {
        processChar(c, is, value);
      }
    }

  private:

    void processChar(char c, std::istream& is, Value& value) const {
      switch (c) {
      case '(':
        is.putback(c);
        readParsed('(', ')', is, value);
        break;
      case '[':
        is.putback(c);
        readParsed('[', ']', is, value);
        break;
      case '{':
        is.putback(c);
        readParsed('{', '}', is, value);
        break;
      case '/':
        is.putback(c);
        readParsed('/', '/', is, value);
        break;
      case '\"':
        is.putback(c);
        readQuoted('\"', is, value);
        break;
      case '\'':
        is.putback(c);
        readQuoted('\'', is, value);
        break;
      default:
        value += c;
        break;
      }
    }

    void readParsed(char open, char close, 
                    std::istream& is, Value& value) const {
      char c;
      if (!is.get(c) || c != open)
        throw DataFormatError("Unformatted string format error");
      value += c;
      while (is.get(c) && c != close) {
        processChar(c, is, value);
      }
      if (!is) 
        throw DataFormatError("Unformatted string format error");
      value += c;      
    }

    void readQuoted(char quote, std::istream& is, Value& value) const {
      char c;
      bool esc = false;
      if (!is.get(c) || c != quote)
        throw DataFormatError("Unformatted string format error");
      value += c;
      while (is.get(c) && (c != quote || esc)) {
        if (c == '\\') esc = !esc;
        else esc = false;
        value += c;
      }
      if (!is) 
        throw DataFormatError("Unformatted string format error");
      value += c;
    }



    static bool whiteSpace(char c) {
      return c == ' ' || c == '\t' || c == '\v' || 
        c == '\n' || c == '\r' || c == '\f'; 
    }

    
  };

  /// \ingroup item_io
  ///
  /// \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 {
    friend class QuotedCharReader;
  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 format error");
      while (is.get(c) && c != '\"') {
        if (escaped && c == '\\') {
          value += readEscape(is);
        } else {
          value += c;
        }
      }
      if (!is) throw DataFormatError("Quoted 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 item_io
  ///
  /// \brief Reader class for quoted strings.
  ///
  /// Reader class for quoted strings. It can process the escape
  /// sequences in the string.
  ///
  /// \author Balazs Dezso
  class QuotedCharReader {
  public:
    /// \brief The value type of reader.
    ///
    /// The value type of reader.
    typedef char Value;
    
    /// \brief Constructor for the reader.
    ///
    /// Constructor for the reader. If the given parameter is true
    /// the reader processes the escape sequences.
    QuotedCharReader(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, char& value) const {
      char c;
      is >> std::ws;
      if (!is.get(c) || c != '\'') 
        throw DataFormatError("Quoted format error");
      if (!is.get(c)) 
        throw DataFormatError("Quoted format error");
      if (escaped && c == '\\') {
        value = QuotedStringReader::readEscape(is);
      } else {
        value = c;
      }
      if (!is.get(c) || c != '\'') 
        throw DataFormatError("Quoted format error");
    }

  private:
    bool escaped;
  };

  /// \ingroup item_io
  /// \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 Constructor for InsertReader
    ///
    /// Constructor for InsertReader
    PushBackReader(const ItemReader& _item_reader = ItemReader())
      : item_reader(_item_reader) {}

    /// \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");
    }

  };

  /// \ingroup item_io
  ///
  /// \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 Constructor for InsertReader
    ///
    /// Constructor for InsertReader
    InsertReader(const ItemReader& _item_reader = ItemReader())
      : item_reader(_item_reader) {}

    /// \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");
    }

  };

  /// \ingroup item_io
  /// \brief Reader for parsed string.
  ///
  /// Reader for parsed strings. You can define the open and close
  /// parse characters. It reads from the input a character sequence
  /// which is right parsed.
  ///
  /// \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;
      value.clear();
      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 item_io
  /// \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) const {
      if (skipSpaces) is >> std::ws;
      if (!getline(is, value)) {
        throw DataFormatError("LineReader format error");
      }
    }
  private:
    bool skipSpaces;
  };

  /// \ingroup item_io
  /// \brief Reader for std::pair.
  ///
  /// Reader for std::pair.
  ///
  /// \author Balazs Dezso
  template <typename _Pair, 
            typename _FirstReader = 
            DefaultReader<typename _Pair::first_type>,
            typename _SecondReader = 
            DefaultReader<typename _Pair::second_type> >
  class PairReader {
  public:
    typedef _Pair Value;

    typedef _FirstReader FirstReader;
    typedef _SecondReader SecondReader;

  private:

    FirstReader first_reader;
    SecondReader second_reader;

  public:
    
    /// \brief Constructor.
    ///
    /// Constructor for the PairReader.
    PairReader(const FirstReader& _first_reader = FirstReader(), 
               const SecondReader& _second_reader = SecondReader()) 
      : first_reader(_first_reader), second_reader(_second_reader) {}
    
    /// \brief Reads the pair from the given stream.
    ///
    /// Reads the pair from the given stream.
    void read(std::istream& is, Value& value) const {
      char c;
      if (!(is >> c) || c != '(') {
        throw DataFormatError("PairReader format error");
      }
      first_reader.read(is, value.first);
      if (!(is >> c) || c != '=') {
        throw DataFormatError("PairReader format error");
      }
      if (!(is >> c) || c != '>') {
        throw DataFormatError("PairReader format error");
      }
      second_reader.read(is, value.second);
      if (!(is >> c) || c != ')') {
        throw DataFormatError("PairReader format error");
      }
    }
  };

  /// \ingroup item_io
  /// 
  /// \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 <>
  class DefaultReader<std::string> {
  public:
    typedef std::string Value;
    
    void read(std::istream& is, Value& value) const {
      char c;
      if (!(is >> std::ws >> c)) 
        throw DataFormatError("DefaultReader<string> format error");
      is.putback(c);
      switch (c) {
      case '\"':
        QuotedStringReader().read(is, value);
        break;
      default:
        UnformattedReader().read(is, value);
        break;
      }
    }
    
  };

  template <>
  class DefaultReader<char> {
  public:
    typedef char Value;
    
    void read(std::istream& is, Value& value) const {
      char c;
      if (!(is >> std::ws >> c))
        throw DataFormatError("DefaultReader<char> format error");
      is.putback(c);
      switch (c) {
      case '\'':
        QuotedCharReader().read(is, value);
        break;
      default:
        { 
          int temp;          
          if (!(is >> temp)) 
            throw DataFormatError("DefaultReader<char> format error");
          value = (char)temp;
          break;
        }
      }
    }    
  };

  template <>
  class DefaultReader<bool> {
  public:
    typedef bool Value;
    
    void read(std::istream& is, Value& value) const {
      std::string rep;
      if (!(is >> rep))
        throw DataFormatError("DefaultReader<bool> format error");
      if (rep == "true" || rep == "t" || rep == "1") {
        value = true;
      } else if (rep == "false" || rep == "f" || rep == "0") {
        value = false;
      } else throw DataFormatError("DefaultReader<bool> 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 Key, typename Value>
  class DefaultReader<std::map<Key, Value> > 
    : public InsertReader<std::map<Key, Value>,
                          DefaultReader<std::pair<Key, Value> > > {};

  template <typename Item>
  class DefaultReader<std::multiset<Item> > 
    : public InsertReader<std::multiset<Item> > {};

  template <typename Key, typename Value>
  class DefaultReader<std::multimap<Key, Value> > 
    : public InsertReader<std::multimap<Key, Value>,
                          DefaultReader<std::pair<Key, Value> > > {};

  template <typename First, typename Second>
  class DefaultReader<std::pair<First, Second> > 
    : public PairReader<std::pair<First, Second> > {};

  /// \ingroup item_io
  /// 
  /// \brief The default item reader for skipping a value in the stream.
  ///
  /// The default item reader for skipping a value in the stream.
  ///
  /// \author Balazs Dezso
  class DefaultSkipper : public UnformattedReader {};

  /// \ingroup item_io  
  /// \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