WriterExt.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/

#ifndef STK_UTIL_DIAG_WRITEREXT_HPP
#define STK_UTIL_DIAG_WRITEREXT_HPP

#include <bitset>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <memory>
#include <stack>
#include <string>
#include <typeinfo>
#include <vector>

#include <stk_util/diag/Writer.hpp>

namespace stk {
namespace diag {


Writer &operator<<(Writer &dout, const std::type_info &t);

template <class T>
Writer &operator<<(Writer &dout, const std::auto_ptr<T> &t) {
  if (t.get())
    dout << " " << typeid(t) << ", " << t.get() << ", " << *t;
  else
    dout << " " << typeid(t) << ", <not created or not owner>";

  return dout;
}

template <class T, class U>
Writer &operator<<(Writer & dout, const std::pair<T, U> &pair) {
//  dout << typeid(pair) << "(" << pair.first << ":" << pair.second << ")";
  dout << "(" << pair.first << ":" << pair.second << ")";

  return dout;
}

template <class T>
Writer &
dump(
  Writer &      dout,
  const std::vector<T> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    if (t.size() <= 10) {
      for (typename std::vector<T>::const_iterator it = t.begin(); it != t.end(); ++it)
        dout << (*it) << " ";
      dout << dendl;
    }
    else {
      int i = 0;
      for (typename std::vector<T>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
        dout << "[" << i << "] " << (*it) << dendl;
    }

    dout << pop;
  }

  return dout;
}

template <class T>
Writer &
dump(
  Writer &      dout,
  const std::vector<T *> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    int i = 0;
    for (typename std::vector<T *>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
      dout << "[" << i << "] " << c_ptr_<T>(*it) << dendl;

    dout << pop;
  }

  return dout;
}

template <class T>
Writer &
dump(
  Writer &      dout,
  const std::list<T> &    t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    int i = 0;
    for (typename std::list<T>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
      dout << "[" << i << "] " << (*it) << dendl;

    dout << pop;
  }

  return dout;
}

template <class T>
Writer &
dump(
  Writer &      dout,
  const std::list<T *> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    int i = 0;
    for (typename std::list<T *>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
      dout << "[" << i << "] " << c_ptr_<T>(*it) << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class T, class L>
Writer &
dump(
  Writer &      dout,
  const std::map<Key, T, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::map<Key, T, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << "[" << (*it).first << "] " << (*it).second << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class T, class L>
Writer &
dump(
  Writer &      dout,
  const std::map<Key, T *, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::map<Key, T *, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << "[" << (*it).first << "] " << c_ptr_<T>((*it)->second) << std::endl;

    dout << pop;
  }

  return dout;
}

template <class Key, class T, class L>
Writer &
dump(
  Writer &      dout,
  const std::multimap<Key, T, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::multimap<Key, T, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << "[" << (*it).first << "] " << (*it).second << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class T, class L>
Writer &
dump(
  Writer &      dout,
  const std::multimap<Key, T *, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::multimap<Key, T *, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << "[" << (*it).first << "] " << c_ptr_<T>((*it)->second) << std::endl;

    dout << pop;
  }

  return dout;
}

template <class Key, class L>
Writer &
dump(
  Writer &      dout,
  const std::set<Key, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::set<Key, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << (*it) << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class L>
Writer &
dump(
  Writer &      dout,
  const std::set<Key *, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::set<Key *, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << c_ptr_<Key>((*it)) << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class L>
Writer &
dump(
  Writer &      dout,
  const std::multiset<Key, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::multiset<Key, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << (*it) << dendl;

    dout << pop;
  }

  return dout;
}

template <class Key, class L>
Writer &
dump(
  Writer &      dout,
  const std::multiset<Key *, L> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;

    for (typename std::multiset<Key *, L>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << c_ptr_<Key>((*it)) << dendl;

    dout << pop;
  }

  return dout;
}

// /**
//  * @brief Template <b>dump</b> prints the object contained within a
//  * hash_map to the diagnostic writer.
//  *
//  * @param dout    a <b>Writer</b> reference to the diagnostic writer to
//  *      write the hash_map to.
//  *
//  * @param t    a <b>hash_map</b> of objects.
//  *
//  * @return    a <b>Writer</b> reference to this object
//  */
// template <class Key, class T>
// Writer &
// dump(
//   Writer &      dout,
//   const hash_map<Key, T> &  t)
// {
//   if (dout.shouldPrint()) {
//     dout << typeid(t) << ", size " << t.size() << push << dendl;

//     for (typename hash_map<Key, T>::const_iterator it = t.begin(); it != t.end(); ++it)
//       dout <<  "[" << (*it).first << "] " << (*it).second << dendl;

//     dout << pop;
//   }

//   return dout;
// }

// /**
//  * @brief Template <b>dump</b> prints the object pointed to that are
//  * contained within a hash_map to the diagnostic writer.
//  *
//  * @param dout    a <b>Writer</b> reference to the diagnostic writer to
//  *      write the hash_map to.
//  *
//  * @param t    a <b>hash_map</b> of objects.
//  *
//  * @return    a <b>Writer</b> reference to this object
//  */
// template <class Key, class T>
// Writer &
// dump(
//   Writer &      dout,

//   const hash_map<Key, T *> &  t)
// {
//   if (dout.shouldPrint()) {
//     dout << typeid(t) << ", size " << t.size() << push << dendl;

//     for (typename hash_map<Key, T *>::const_iterator it = t.begin(); it != t.end(); ++it)
//       dout << "[" << (*it).first << "] " << (*it)->second << dendl;

//     dout << pop;
//   }

//   return dout;
// }


template <size_t n>
Writer &operator<<(Writer &dout, const std::bitset<n> &t) {
  if (dout.shouldPrint())
    dout.getStream() << t;

  return dout;
}


template <class T>
Writer &operator<<(Writer &dout, const std::vector<T> &t) {
  return dump(dout, t);
}

template <class T>
Writer &operator<<(Writer &dout, const std::list<T> &t) {
  return dump(dout, t);
}

template <class Key, class T, class L>
Writer &operator<<(Writer &dout, const std::map<Key, T, L> &t) {
  return dump<Key, T, L>(dout, t);
}

template <class Key, class T, class L>
Writer &operator<<(Writer &dout, const std::multimap<Key, T, L> &t) {
  return dump<Key, T, L>(dout, t);
}

template <class Key, class L>
Writer &operator<<(Writer &dout, const std::set<Key, L> &t) {
  return dump<Key, L>(dout, t);
}

template <class Key, class L>
Writer &operator<<(Writer &dout, const std::multiset<Key, L> &t) {
  return dump<Key, L>(dout, t);
}


} // namespace diag
} // namespace stk

#endif // STK_UTIL_DIAG_WRITEREXT_HPP