table_handler.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2017 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__table_handler_h
#define dealii__table_handler_h


#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>

#include <map>
#include <vector>
#include <string>
#include <fstream>

#include <ostream>

#include <boost/variant.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/split_member.hpp>


DEAL_II_NAMESPACE_OPEN

class TableHandler;

namespace internal
{
  struct TableEntry
  {
  public:
    TableEntry ();

    template <typename T>
    TableEntry (const T &t);

    template <typename T>
    T get () const;

    double get_numeric_value () const;

    void cache_string(bool scientific, unsigned int precision) const;

    const std::string &get_cached_string() const;


    TableEntry get_default_constructed_copy() const;

    template <class Archive>
    void save (Archive &ar, const unsigned int version) const;

    template <class Archive>
    void load (Archive &ar, const unsigned int version);

    BOOST_SERIALIZATION_SPLIT_MEMBER()

  private:
    typedef boost::variant<int,unsigned int,unsigned long long int,double,std::string> value_type;

    value_type value;

    mutable std::string cached_value;

    friend class ::TableHandler;
  };
}


class TableHandler
{
public:
  enum TextOutputFormat
  {
    table_with_headers,
    table_with_separate_column_description,
    simple_table_with_separate_column_description,
    org_mode_table
  };

  TableHandler ();

  template <typename T>
  void add_value (const std::string &key,
                  const T            value);

  void set_auto_fill_mode (const bool state);

  void add_column_to_supercolumn (const std::string &key,
                                  const std::string &superkey);

  void set_column_order (const std::vector<std::string> &new_order);

  void set_precision (const std::string &key,
                      const unsigned int precision);

  void set_scientific (const std::string &key,
                       const bool         scientific);

  void set_tex_caption (const std::string &key,
                        const std::string &tex_caption);

  void set_tex_table_caption (const std::string &table_caption);

  void set_tex_table_label (const std::string &table_label);

  void set_tex_supercaption (const std::string &superkey,
                             const std::string &tex_supercaption);

  void set_tex_format (const std::string &key,
                       const std::string &format="c");

  void write_text (std::ostream &out,
                   const TextOutputFormat format = table_with_headers) const;

  void write_tex (std::ostream &file, const bool with_header=true) const;

  void clear ();

  void clear_current_row ();

  template <class Archive>
  void serialize(Archive &ar, const unsigned int version);

  DeclException1 (ExcColumnNotExistent,
                  std::string,
                  << "Column <" << arg1 << "> does not exist.");

  DeclException1 (ExcSuperColumnNotExistent,
                  std::string,
                  << "Supercolumn <" << arg1 << "> does not exist.");

  DeclException1 (ExcColumnOrSuperColumnNotExistent,
                  std::string,
                  << "Column or supercolumn <" << arg1 << "> does not exist.");

  DeclException4 (ExcWrongNumberOfDataEntries,
                  std::string, int, std::string, int,
                  << "Column <" << arg1 << "> has " << arg2
                  << " rows, but Column <" << arg3 << "> has " << arg4 << " rows.");

  DeclException1 (ExcUndefinedTexFormat,
                  std::string,
                  << "<" << arg1 << "> is not a tex column format. Use "
                  << "'l', 'c', or 'r' to indicate left, centered, or "
                  << "right aligned text.");
protected:

  struct Column
  {
    Column ();

    Column (const std::string &tex_caption);

    void pad_column_below (const unsigned int length);

    template <class Archive>
    void save(Archive &ar, const unsigned int version) const;
    template<class Archive>
    void load(Archive &ar, const unsigned int version);
    BOOST_SERIALIZATION_SPLIT_MEMBER()


    
    void invalidate_cache();

    std::vector<internal::TableEntry> entries;

    std::string tex_caption;

    std::string tex_format;

    unsigned int precision;

    bool scientific;

    unsigned int flag;

    unsigned int max_length;
  };

  void get_selected_columns (std::vector<std::string> &sel_columns) const;

  unsigned int n_rows() const;

  std::vector<std::string> column_order;

  mutable std::map<std::string,Column> columns;

  std::map<std::string, std::vector<std::string> > supercolumns;

  std::map<std::string, std::string> tex_supercaptions;

  std::string tex_table_caption;
  std::string tex_table_label;

  bool auto_fill_mode;
};


namespace internal
{
  template <typename T>
  TableEntry::TableEntry (const T &t)
    :
    value (t)
  {}


  template <typename T>
  T TableEntry::get () const
  {
    // we don't quite know the data type in 'value', but
    // it must be one of the ones in the type list of the
    // boost::variant. so if T is not in the list, or if
    // the data stored in the TableEntry is not of type
    // T, then we will get an exception that we can
    // catch and produce an error message
    try
      {
        return boost::get<T>(value);
      }
    catch (...)
      {
        Assert(false, ExcMessage ("This TableEntry object does not store a datum of type T"));
        throw;
      }
  }



  template <class Archive>
  void TableEntry::save (Archive &ar,
                         const unsigned int) const
  {
    // write first an identifier for the kind
    // of data stored and then the actual
    // data, in its correct data type
    if (const int *p = boost::get<int>(&value))
      {
        char c = 'i';
        ar &c & *p;
      }
    else if (const unsigned int *p = boost::get<unsigned int>(&value))
      {
        char c = 'u';
        ar &c & *p;
      }
    else if (const double *p = boost::get<double>(&value))
      {
        char c = 'd';
        ar &c & *p;
      }
    else if (const std::string *p = boost::get<std::string>(&value))
      {
        char c = 's';
        ar &c & *p;
      }
    else if (const unsigned long long int *p = boost::get<unsigned long long int>(&value))
      {
        char c = 'l';
        ar &c & *p;
      }
    else
      Assert (false, ExcInternalError());
  }



  template <class Archive>
  void TableEntry::load (Archive &ar,
                         const unsigned int)
  {
    // following what we do in the save()
    // function, first read in the data type
    // as a one-character id, and then read
    // the data
    char c;
    ar &c;

    switch (c)
      {
      case 'i':
      {
        int val;
        ar &val;
        value = val;
        break;
      }

      case 'u':
      {
        unsigned int val;
        ar &val;
        value = val;
        break;
      }

      case 'd':
      {
        double val;
        ar &val;
        value = val;
        break;
      }

      case 's':
      {
        std::string val;
        ar &val;
        value = val;
        break;
      }

      case 'l':
      {
        unsigned long long int val;
        ar &val;
        value = val;
        break;
      }

      default:
        Assert (false, ExcInternalError());
      }
  }
}

template <typename T>
void TableHandler::add_value (const std::string &key,
                              const T            value)
{
  // see if the column already exists
  if (columns.find(key) == columns.end())
    {
      std::pair<std::string, Column> new_column(key, Column(key));
      columns.insert(new_column);
      column_order.push_back(key);
    }

  if (auto_fill_mode == true)
    {
      // follow the algorithm given in the introduction to this class
      // of padding columns as necessary
      unsigned int n = 0;
      for (std::map< std::string, Column >::iterator p = columns.begin(); p != columns.end(); ++p)
        n = (n >= p->second.entries.size() ? n : p->second.entries.size());

      while (columns[key].entries.size()+1 < n)
        {
          columns[key].entries.push_back (internal::TableEntry(T()));
          internal::TableEntry &entry = columns[key].entries.back();
          entry.cache_string(columns[key].scientific, columns[key].precision);
          columns[key].max_length = std::max(columns[key].max_length, static_cast<unsigned int>(entry.get_cached_string().length()));
        }
    }

  // now push the value given to this function
  columns[key].entries.push_back (internal::TableEntry(value));
  internal::TableEntry &entry = columns[key].entries.back();
  entry.cache_string(columns[key].scientific, columns[key].precision);
  columns[key].max_length = std::max(columns[key].max_length, static_cast<unsigned int>(entry.get_cached_string().length()));
}


template <class Archive>
void
TableHandler::Column::save(Archive &ar, const unsigned int /*version*/) const
{
  ar &entries &tex_caption
  & tex_format &precision
  & scientific
  & flag
  & max_length;
}

template<class Archive>
void
TableHandler::Column::load(Archive &ar, const unsigned int /*version*/)
{
  ar &entries &tex_caption
  & tex_format &precision
  & scientific
  & flag
  & max_length;
  invalidate_cache();
}


template <class Archive>
void
TableHandler::serialize(Archive &ar,
                        const unsigned int)
{
  ar &column_order &columns
  & supercolumns &tex_supercaptions
  & tex_table_caption
  & tex_table_label
  & auto_fill_mode;
}


DEAL_II_NAMESPACE_CLOSE

#endif