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/stk_config.h>
#include <stk_util/util/VecMap.hpp>
#include <stk_util/util/VecSet.hpp>
 
#include <stk_util/diag/Writer.hpp>
 
 
#include <stk_util/diag/String.hpp>
#include <stk_util/diag/StringUtil.hpp>
 
#include <stk_util/util/FeatureTest.hpp>
#include <stk_util/util/Array.hpp>
#include <stk_util/util/FArrayPrint.hpp>
#include <stk_util/parallel/MPI.hpp>
#include <stk_util/diag/Mapv.hpp>
#include <stk_util/diag/Option.hpp>
 
 
namespace stk_classic {
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(dout, t);
}
 
template <class Key, class T, class L>
Writer &operator<<(Writer &dout, const std::multimap<Key, T, L> &t) {
  return dump(dout, t);
}
 
template <class Key, class L>
Writer &operator<<(Writer &dout, const std::set<Key, L> &t) {
  return dump(dout, t);
}
 
template <class Key, class L>
Writer &operator<<(Writer &dout, const std::multiset<Key, L> &t) {
  return dump(dout, t);
}
 
 
Writer &operator<<(Writer &dout, const sierra::String &s);
 
Writer &operator<<(Writer &dout, const sierra::Identifier &s);
 
#if defined( STK_HAS_MPI )
 
Writer &operator<<(Writer &dout, const sierra::MPI::Loc<int> &loc);
 
Writer &operator<<(Writer &dout, const sierra::MPI::Loc<double> &loc);
 
Writer &operator<<(Writer &dout, const sierra::MPI::Loc<float> &loc);
 
Writer &operator<<(Writer &dout, const sierra::MPI::TempLoc &loc);
 
#endif // if defined( STK_HAS_MPI )
 
template <class T>
c_ptr_func_<T, const sierra::String &> c_ptr_name(const T *t) {
  return c_ptr_func_<T, const sierra::String &>(t, &T::name);
}
 
template< class ElementType,
    class Tag0,
    class Tag1,
    class Tag2,
    class Tag3,
    class Tag4,
    class Tag5,
    class Tag6,
    class Tag7 >
Writer &
operator<<(Writer &dout, const sierra::Array<ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &array)
{
  typedef sierra::Array<ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > X;
 
  if (dout.shouldPrint()) {
    std::string type = sierra::demangle(typeid(X).name());
    dout << type.substr(0, type.find(", sierra::TypeListEnd")) << ">" << push << dendl;
    dout.getStream() << array; // ArrayVerbosePrint<X::NumDim>::dump(dout, array.dimension(), array.ptr(), array.stride());
    dout << pop << dendl;
  }
  return dout;
}
 
 
template< class ElementType,
    class Tag0,
    class Tag1,
    class Tag2,
    class Tag3,
    class Tag4,
    class Tag5,
    class Tag6,
    class Tag7 >
Writer &
operator<<(Writer &dout, const sierra::ArrayContainer<ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &array)
{
  typedef sierra::ArrayContainer<ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > X;
 
  if (dout.shouldPrint()) {
    std::string type = sierra::demangle(typeid(X).name());
    dout << type.substr(0, type.find(", sierra::TypeListEnd")) << ">" << push << dendl;
    dout.getStream() << array; // ArrayVerbosePrint<X::NumDim>::dump(dout, array.dimension(), array.ptr(), array.stride());
    dout << pop << dendl;
  }
  return dout;
}
 
 
template< class ElementType, int Dimension>
Writer &
operator<<(Writer &dout, const sierra::FArray<ElementType, Dimension> &array)
{
  typedef sierra::FArray<ElementType, Dimension> X;
 
  if (dout.shouldPrint()) {
    dout << sierra::demangle(typeid(X).name()) << push << dendl;
    dout.getStream() << array; // ArrayVerbosePrint<X::NumDim>::dump(dout, array.dimension(), array.ptr(), array.stride());
    dout << pop << dendl;
  }
  return dout;
}
 
template< class ElementType, int Dimension>
Writer &
operator<<(Writer &dout, const sierra::FArrayContainer<ElementType, Dimension> &array)
{
  typedef sierra::FArrayContainer<ElementType, Dimension> X;
 
  if (dout.shouldPrint()) {
    dout << sierra::demangle(typeid(X).name()) << push << dendl;
    dout.getStream() << array; // ArrayVerbosePrint<X::NumDim>::dump(dout, array.dimension(), array.ptr(), array.stride());
    dout << pop << dendl;
  }
  return dout;
}
 
template <class T>
Writer &
dump(
  Writer &      dout,
  const sierra::Mapv_no_delete<T> & t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    for (typename sierra::Mapv_no_delete<T>::const_iterator it = t.begin(); it != t.end(); ++it) {
      dout << "[" << (*it).mapv_key() << "] " << (*it) << dendl;
    }
 
    dout << pop;
  }
 
  return dout;
}
 
template <class Key, class T, class U>
Writer &
dump(
  Writer &      dout,
  const sierra::vecmap<Key, T, U> & t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    for (typename sierra::vecmap<Key, T, U>::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 U>
Writer &
dump(
  Writer &      dout,
  const sierra::vecmap<Key, T *, U> & t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    for (typename sierra::vecmap<Key, T *, U>::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 U>
Writer &
dump(
  Writer &        dout,
  const sierra::vecmap<Key *, T *, U> & t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    for (typename sierra::vecmap<Key *, T *, U>::const_iterator it = t.begin(); it != t.end(); ++it)
      dout << "[" << (*it).first << "] " << *(*it).second << dendl;
 
    dout << pop;
  }
 
  return dout;
}
 
template <class T, class U>
Writer &
dump(
  Writer &    dout,
  const sierra::vecset<T, U> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    int i = 0;
    for (typename sierra::vecset<T, U>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
      dout << "[" << i << "] " << (*it) << dendl;
 
    dout << pop;
  }
 
  return dout;
}
 
template <class T, class U>
Writer &
dump(
  Writer &      dout,
  const sierra::vecset<T *, U> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    int i = 0;
    for (typename sierra:: vecset<T *, U>::const_iterator it = t.begin(); it != t.end(); ++it, ++i)
      dout << "[" << i << "] " << *(*it) << dendl;
 
    dout << pop;
  }
 
  return dout;
}
 
template <class T, class U>
Writer &
dump(
  Writer &      dout,
  const sierra::MapvNode<T, U> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", " << t.mapv_key();
  }
 
  return dout;
}
 
template <class T, class U>
Writer &
dump(
  Writer &    dout,
  const sierra::Mapv<T, U> &  t)
{
  if (dout.shouldPrint()) {
    dout << typeid(t) << ", size " << t.size() << push << dendl;
 
    for (typename sierra::Mapv<T, U>::const_iterator it = t.begin(); it != t.end(); ++it) {
      dout << "[" << (*it).mapv_key() << "] " << (*it) << dendl;
    }
 
    dout << pop;
  }
 
  return dout;
}
 
template <class T, class U>
Writer &operator<<(Writer &dout, const sierra::vecset<T, U> &t) {
  return dump(dout, t);
}
 
template <class Key, class T, class U>
Writer &operator<<(Writer &dout, const sierra::vecmap<Key, T, U> &t) {
  return dump(dout, t);
}
 
template <class T, class U>
Writer &operator<<(Writer &dout, const sierra::vecset<T *, U> &t) {
  return dump(dout, t);
}
 
template <class Key, class T, class U>
Writer &operator<<(Writer &dout, const sierra::vecmap<Key *, T *, U> &t) {
  return dump(dout, t);
}
 
template <class T>
Writer &operator<<(Writer &dout, const sierra::Mapv_no_delete<T> &t) {
  return dump(dout, t);
}
 
template <class T, class U>
Writer &operator<<(Writer &dout, const sierra::Mapv<T, U> &t) {
  return dump(dout, t);
}
 
template <class T, class U>
Writer &operator<<(Writer &dout, const sierra::MapvNode<T, U> &t) {
  return dump(dout, t);
}
 
template <class Key, class T, class U>
Writer &operator<<(Writer &dout, const sierra::vecmap<Key, T *, U> &t) {
  return dump(dout, t);
}
 
 
 
} // namespace diag
} // namespace stk_classic
 
#endif // STK_UTIL_DIAG_WRITEREXT_HPP