ToStream.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/HashMap.h>
#include <GaudiKernel/Map.h>
#include <GaudiKernel/SerializeSTL.h>
#include <GaudiKernel/VectorMap.h>
#include <array>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <unordered_set>
#include <vector>

namespace Gaudi {
  namespace Utils {
    template <class TYPE>
    std::ostream& toStream( const TYPE& obj, std::ostream& s );
    template <class ITERATOR>
    inline std::ostream& toStream( ITERATOR           first,   // begin of the sequence
                                   ITERATOR           last,    //   end of the sequence
                                   std::ostream&      s,       //            the stream
                                   const std::string& open,    //               opening
                                   const std::string& close,   //               closing
                                   const std::string& delim ); //             delimiter
    inline std::ostream& toStream( const std::string& obj, std::ostream& s ) { return s << std::quoted( obj, '\'' ); }
    inline std::ostream& toStream( const bool obj, std::ostream& s ) { return s << ( obj ? "True" : "False" ); }
    inline std::ostream& toStream( const float obj, std::ostream& s, const int prec = 6 ) {
      const int p = static_cast<int>( s.precision() );
      return s << std::setprecision( prec ) << obj << std::setprecision( p );
    }

    inline std::ostream& toStream( const double obj, std::ostream& s, const int prec = 8 ) {
      const int p = static_cast<int>( s.precision() );
      return s << std::setprecision( prec ) << obj << std::setprecision( p );
    }

    inline std::ostream& toStream( const long double obj, std::ostream& s, const int prec = 10 ) {
      const int p = static_cast<int>( s.precision() );
      return s << std::setprecision( prec ) << obj << std::setprecision( p );
    }

    template <class KTYPE, class VTYPE>
    inline std::ostream& toStream( const std::pair<KTYPE, VTYPE>& obj, std::ostream& s ) {
      return toStream( obj.second, toStream( obj.first, s << "( " ) << " , " ) << " )";
    }
 
    template <typename... Args>
    inline std::ostream& toStream( const std::tuple<Args...>& tuple, std::ostream& s );

    template <class TYPE, class ALLOCATOR>
    inline std::ostream& toStream( const std::vector<TYPE, ALLOCATOR>& obj, std::ostream& s ) {
      return toStream( obj.begin(), obj.end(), s, "[ ", " ]", " , " );
    }

    template <class TYPE, class ALLOCATOR>
    inline std::ostream& toStream( const std::list<TYPE, ALLOCATOR>& obj, std::ostream& s ) {
      return toStream( obj.begin(), obj.end(), s, "[ ", " ]", " , " );
    }

    template <class TYPE, class CMP, class ALLOCATOR>
    inline std::ostream& toStream( const std::set<TYPE, CMP, ALLOCATOR>& obj, std::ostream& s ) {
      return toStream( obj.begin(), obj.end(), s, "[ ", " ]", " , " );
    }

    template <class TYPE, class HASH, class CMP, class ALLOCATOR>
    inline std::ostream& toStream( const std::unordered_set<TYPE, HASH, CMP, ALLOCATOR>& obj, std::ostream& s ) {
      auto ordered = std::set( obj.begin(), obj.end() ); // ensure reproducible printout
      return obj.empty() ? s << "set()" : toStream( ordered.begin(), ordered.end(), s, "{ ", " }", " , " );
    }

    template <class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
    inline std::ostream& toStream( const std::map<KTYPE, VTYPE, CMP, ALLOCATOR>& obj, std::ostream& s ) {
      using GaudiUtils::details::ostream_joiner;
      return ostream_joiner( s << "{ ", obj, " , ",
                             []( std::ostream& os, const std::pair<const KTYPE, VTYPE>& i ) -> std::ostream& {
                               return toStream( i.second, toStream( i.first, os ) << " : " );
                             } )
             << " }";
    }

    template <class KTYPE, class VTYPE, class CMP, class ALLOCATOR>
    inline std::ostream& toStream( const GaudiUtils::VectorMap<KTYPE, VTYPE, CMP, ALLOCATOR>& obj, std::ostream& s ) {
      using GaudiUtils::details::ostream_joiner;
      return ostream_joiner( s << "{ ", obj, " , ",
                             []( std::ostream& os, const std::pair<const KTYPE, VTYPE>& i ) -> std::ostream& {
                               return toStream( i.second, toStream( i.first, os ) << " : " );
                             } )
             << " }";
    }

    template <class KTYPE, class VTYPE, class MAP>
    inline std::ostream& toStream( const GaudiUtils::Map<KTYPE, VTYPE, MAP>& obj, std::ostream& s ) {
      using GaudiUtils::details::ostream_joiner;
      return ostream_joiner( s << "{ ", obj, " , ",
                             []( std::ostream& os, const std::pair<const KTYPE, VTYPE>& i ) -> std::ostream& {
                               return toStream( i.second, toStream( i.first, os ) << " : " );
                             } )
             << " }";
    }

    template <class KTYPE, class VTYPE, class HASH, class MAP>
    inline std::ostream& toStream( const GaudiUtils::HashMap<KTYPE, VTYPE, HASH, MAP>& obj, std::ostream& s ) {
      // Copy the hash map into a map to have it ordered by key.
      return toStream( GaudiUtils::Map<KTYPE, VTYPE>{ obj.begin(), obj.end() }, s );
    }

    template <class TYPE, unsigned int N>
    std::ostream& toStream( const TYPE ( &obj )[N], std::ostream& s ) {
      if constexpr ( N == 1 ) {
        return toStream( obj[0], s << "( " ) << " , )";
      } else {
        return toStream( obj, obj + N, s, "( ", " )", " , " );
      }
    }

    template <class TYPE, std::size_t N>
    std::ostream& toStream( const std::array<TYPE, N>& obj, std::ostream& s ) {
      if constexpr ( N == 1 ) {
        return toStream( obj[0], s << "( " ) << " , )";
      } else {
        return toStream( begin( obj ), end( obj ), s, "( ", " )", " , " );
      }
    }

    template <unsigned int N>
    std::ostream& toStream( const char ( &obj )[N], std::ostream& s ) {
      return toStream( std::string( obj, obj + N ), s );
    }

    inline std::ostream& toStream( const char* obj, std::ostream& s ) { return toStream( std::string( obj ), s ); }
    template <class TYPE>
    inline std::ostream& toStream( const TYPE& obj, std::ostream& s ) {
      return s << obj;
    }
    // helper function to print a tuple of any size
    template <class Tuple, std::size_t N>
    struct TuplePrinter {
      static std::ostream& toStream( const Tuple& t, std::ostream& s ) {
        TuplePrinter<Tuple, N - 1>::toStream( t, s ) << " , ";
        return Gaudi::Utils::toStream( std::get<N - 1>( t ), s );
      }
    };
 
    template <class Tuple>
    struct TuplePrinter<Tuple, 1> {
      static std::ostream& toStream( const Tuple& t, std::ostream& s ) {
        return Gaudi::Utils::toStream( std::get<0>( t ), s );
      }
    };

    template <typename... Args>
    inline std::ostream& toStream( const std::tuple<Args...>& tuple, std::ostream& s ) {
      auto& out = TuplePrinter<decltype( tuple ), sizeof...( Args )>::toStream( tuple, s << " ( " );
      if constexpr ( std::tuple_size_v<std::tuple<Args...>> == 1 ) { // this is a special case in Python
        out << " ,";
      }
      return out << " ) ";
    }

    template <class ITERATOR>
    inline std::ostream& toStream( ITERATOR           first,  // begin of the sequence
                                   ITERATOR           last,   //   end of the sequence
                                   std::ostream&      s,      //            the stream
                                   const std::string& open,   //               opening
                                   const std::string& close,  //               closing
                                   const std::string& delim ) //             delimiter
    {
      using ref_t = typename std::iterator_traits<ITERATOR>::reference;
      using GaudiUtils::details::ostream_joiner;
      return ostream_joiner( s << open, first, last, delim,
                             []( std::ostream& os, ref_t i ) -> std::ostream& { return toStream( i, os ); } )
             << close;
    }

    template <class TYPE>
    inline std::string toString( const TYPE& obj ) {
      std::ostringstream s;
      std::ios::fmtflags orig_flags = s.flags();
      s.setf( std::ios::showpoint ); // to display correctly floats
      toStream( obj, s );
      s.flags( orig_flags );
      return s.str();
    }
  } // namespace Utils
} // namespace Gaudi