/* -*- C++ -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library

 *

 * Copyright (C) 2003-2007

 * 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 writer bits for lemon output.

#ifndef LEMON_BITS_ITEM_WRITER_H

#define LEMON_BITS_ITEM_WRITER_H

#include <iostream>

#include <sstream>

#include <string>

#include <vector>

#include <deque>

#include <list>

#include <set>

namespace lemon {

  template <typename Value>

  class DefaultWriter;

  /// \ingroup item_io

  /// \brief Writer class for quoted strings.

  ///

  /// Writer class for unformatted strings.

  /// \author Balazs Dezso

  class UnformattedWriter {

  public:

    typedef std::string Value;

    /// \brief Constructor for the writer.

    ///

    /// Constructor for the writer.

    UnformattedWriter() {}

    /// \brief Writes an unformatted string to the given stream.

    ///

    /// Writes an unformatted string to the given stream.

    void write(std::ostream& os, const std::string& value) const {

      os << value;

    }

    bool readable(const std::string& value) const {

      std::istringstream is(value);

      char c;

      while (is.get(c) && !whiteSpace(c)) {

        if (!processChar(c, is)) return false;

      }

      if (is) return false;

      return true;

    }

  private:

    bool processChar(char c, std::istream& is) const {

      switch (c) {

      case '(':

        is.putback(c);

        if (!readableParsed('(', ')', is)) return false;

        break;

      case '[':

        is.putback(c);

        if (!readableParsed('[', ']', is)) return false;

        break;

      case '{':

        is.putback(c);

        if (!readableParsed('{', '}', is)) return false;

        break;

      case '/':

        is.putback(c);

        if (!readableParsed('/', '/', is)) return false;

        break;

      case '\"':

        is.putback(c);

        if (!readableQuoted('\"', is)) return false;

        break;

      case '\'':

        is.putback(c);

        if (!readableQuoted('\'', is)) return false;

        break;

      default:

        break;

      }

      return true;

    }

    bool readableParsed(char open, char close, std::istream& is) const {

      char c;

      if (!is.get(c) || c != open) return false;

      while (is.get(c) && c != close) {

        if (!processChar(c, is)) return false;

      }

      if (!is) return false;

      return true;

    }

    bool readableQuoted(char quote, std::istream& is) const {

      char c;

      bool esc = false;

      if (!is.get(c) || c != quote) return false;

      while (is.get(c) && (c != quote || esc)) {

        if (c == '\\') esc = !esc;

        else esc = false;

      }

      if (!is) return false;

      return true;

    }

    static bool whiteSpace(char c) {

      return c == ' ' || c == '\t' || c == '\v' || 

        c == '\n' || c == '\r' || c == '\f'; 

    }

  };

  /// \ingroup item_io

  /// \brief Writer class for quoted strings.

  ///

  /// Writer class for quoted strings. It can process the escape

  /// sequences in the string.

  /// \author Balazs Dezso

  class QuotedStringWriter {

    friend class QuotedCharWriter;

  public:

    typedef std::string Value;

    /// \brief Constructor for the writer.

    ///

    /// Constructor for the writer. If the given parameter is true

    /// the writer creates escape sequences from special characters.

    QuotedStringWriter(bool _escaped = true) : escaped(_escaped) {}

    /// \brief Writes a quoted string to the given stream.

    ///

    /// Writes a quoted string to the given stream.

    void write(std::ostream& os, const std::string& value) const {

      os << "\"";

      if (escaped) {

	std::ostringstream ls;

	for (int i = 0; i < int(value.size()); ++i) {

	  writeEscape(ls, value[i]);

	}

	os << ls.str();

      } else {

	os << value;

      }

      os << "\"";

    }

  private:

    static void writeEscape(std::ostream& os, char c) {

      switch (c) {

      case '\\':

	os << "\\\\";

	return;

      case '\"':

	os << "\\\"";

	return;

      case '\'':

	os << "\\\'";

	return;

      case '\?':

	os << "\\\?";

	return;

      case '\a':

	os << "\\a";

	return;

      case '\b':

	os << "\\b";

	return;

      case '\f':

	os << "\\f";

	return;

      case '\r':

	os << "\\r";

	return;

      case '\n':

	os << "\\n";

	return;

      case '\t':

	os << "\\t";

	return;

      case '\v':

	os << "\\v";

	return;

      default:

	if (c < 0x20) {

	  os << '\\' << std::oct << static_cast<int>(c);

	} else {

	  os << c;

	}

	return;

      }     

    }

  private:

    bool escaped;

  };

  /// \ingroup item_io

  /// \brief Writer class for quoted chars.

  ///

  /// Writer class for quoted char. It can process the escape

  /// sequences in the string.

  /// \author Balazs Dezso

  class QuotedCharWriter {

  public:

    typedef char Value;

    /// \brief Constructor for the writer.

    ///

    /// Constructor for the writer. If the given parameter is true

    /// the writer creates escape sequences from special characters.

    QuotedCharWriter(bool _escaped = true) : escaped(_escaped) {}

    /// \brief Writes a quoted char to the given stream.

    ///

    /// Writes a quoted char to the given stream.

    void write(std::ostream& os, const char& value) const {

      os << "\'";

      if (escaped) {

	std::ostringstream ls;

        QuotedStringWriter::writeEscape(ls, value);

	os << ls.str();

      } else {

	os << value;

      }

      os << "\'";

    }

  private:

    bool escaped;

  };

  /// \ingroup item_io

  /// \brief Writer class for quoted char array.

  ///

  /// Writer class for quoted char array. It can process the escape

  /// sequences in the char array.

  /// \author Balazs Dezso

  class QuotedCharArrayWriter {

  public:

    typedef const char* Value;

    /// \brief Constructor for the writer.

    ///

    /// Constructor for the writer. If the given parameter is true

    /// the writer creates escape sequences from special characters.

    QuotedCharArrayWriter(bool _escaped = true) : escaped(_escaped) {}

    /// \brief Writes a quoted char array to the given stream.

    ///

    /// Writes a quoted char array to the given stream.

    void write(std::ostream& os, const char* value) const {

      QuotedStringWriter(escaped).write(os, std::string(value));

    }

  private:    

    bool escaped;

  };

  /// \ingroup item_io

  ///

  /// \brief Writer for standard containers.

  ///

  /// Writer for each iterable 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 _ItemWriter = DefaultWriter<typename _Container::value_type> 

  >

  class IterableWriter {

  public:

    typedef _Container Value;

    typedef _ItemWriter ItemWriter;

  private:

    ItemWriter item_writer;

  public:

    IterableWriter(const ItemWriter& _item_writer = ItemWriter())

      : item_writer(_item_writer) {}

    /// \brief Writes the values of the container to the given stream.

    ///

    /// Writes the values of the container to the given stream.

    void write(std::ostream& os, const Value& value) const {

      typename Value::const_iterator it;

      os << '(';

      for (it = value.begin(); it != value.end(); ++it) {

	item_writer.write(os, *it);

	os << ' ';

      }

      os << ')';

    }

  };

  /// \ingroup item_io

  ///

  /// \brief Writer for standard pairs.

  ///

  /// Writer for standard pairs. The representation of a pair is

  ///\code ( first_value => second_value ) \endcode.

  /// \author Balazs Dezso

  template <typename _Pair, 

	    typename _FirstWriter = 

	    DefaultWriter<typename _Pair::first_type>,

	    typename _SecondWriter = 

	    DefaultWriter<typename _Pair::second_type> >

  class PairWriter {

  public:

    typedef _Pair Value;

    typedef _FirstWriter FirstWriter;

    typedef _SecondWriter SecondWriter;

  private:

    FirstWriter first_writer;

    SecondWriter second_writer;

  public:

    /// \brief Constructor.

    ///

    /// Constructor for the PairWriter.

    PairWriter(const FirstWriter& _first_writer = FirstWriter(), 

	       const SecondWriter& _second_writer = SecondWriter()) 

      : first_writer(_first_writer), second_writer(_second_writer) {}

    /// \brief Writes the pair from the given stream.

    ///

    /// Writes the pair from the given stream.

    void write(std::ostream& os, const Value& value) const {

      os << "( ";

      first_writer.write(os, value.first);

      os << " => ";

      second_writer.write(os, value.second);

      os << " )";

    }

  };

  /// \ingroup item_io

  /// 

  /// \brief The default item writer template class.

  ///

  /// The default item writer template class. If some section writer

  /// needs to write a value to the stream it will give the default way for it.

  ///

  /// \author Balazs Dezso

  template <typename _Value>

  class DefaultWriter {

  public:

    /// The value type.

    typedef _Value Value;

    /// \brief Writes the value to the given stream.

    ///

    /// Writes the value to the given stream.

    void write(std::ostream& os, const Value& value) const {

      os << value;

    }

  };

  template <>

  class DefaultWriter<std::string> {

  public:

    typedef std::string Value;

    void write(std::ostream& os, const Value& value) const {

      if (UnformattedWriter().readable(value)) {

        UnformattedWriter().write(os, value);

      } else {

        QuotedStringWriter().write(os, value);

      }

    }

  };

  template <>

  class DefaultWriter<char> 

    : public QuotedCharWriter {};

  template <>

  class DefaultWriter<bool> {

  public:

    typedef bool Value;

    void write(std::ostream& os, const Value& value) const {

      os << (value ? "1" : "0");

    }

  };

  template <int length>

  class DefaultWriter<char[length]> 

    : public QuotedCharArrayWriter {};

  template <int length>

  class DefaultWriter<const char[length]> 

    : public QuotedCharArrayWriter {};

  template <>

  class DefaultWriter<char*> 

    : public QuotedCharArrayWriter {};

  template <>

  class DefaultWriter<const char*> 

    : public QuotedCharArrayWriter {};

  template <typename Item>

  class DefaultWriter<std::vector<Item> > 

    : public IterableWriter<std::vector<Item> > {};

  template <typename Item>

  class DefaultWriter<std::deque<Item> > 

    : public IterableWriter<std::deque<Item> > {};

  template <typename Item>

  class DefaultWriter<std::list<Item> > 

    : public IterableWriter<std::list<Item> > {};

  template <typename Item>

  class DefaultWriter<std::set<Item> > 

    : public IterableWriter<std::set<Item> > {};

  template <typename Key, typename Value>

  class DefaultWriter<std::map<Key, Value> > 

    : public IterableWriter<std::map<Key, Value> > {};

  template <typename Item>

  class DefaultWriter<std::multiset<Item> > 

    : public IterableWriter<std::multiset<Item> > {};

  template <typename Key, typename Value>

  class DefaultWriter<std::multimap<Key, Value> > 

    : public IterableWriter<std::multimap<Key, Value> > {};

  template <typename First, typename Second>

  class DefaultWriter<std::pair<First, Second> > 

    : public PairWriter<std::pair<First, Second> > {};

  /// \ingroup item_io

  /// \brief Standard WriterTraits for the section writers.

  ///

  /// Standard WriterTraits for the section writers.

  /// It defines standard writing method for all type of value. 

  /// \author Balazs Dezso

  struct DefaultWriterTraits {

    template <typename _Value>

    struct Writer : DefaultWriter<_Value> {

      typedef DefaultWriter<_Value> Parent;

    };

  };

}

#endif