pout.hpp

Go to the documentation of this file.

/** \file pout.hpp
 * \author Jared R. Males
 * \brief Declaration and definition of a simple formatted output function.
 * \ingroup utils_files
 */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef ioutils_pout_hpp
#define ioutils_pout_hpp
 
#include <iostream>
 
#include "../mxlib.hpp"
 
namespace mx
{
namespace ioutils
{
 
template <char space, bool flush, char eol>
void pout()
{
    if( eol )
        std::cout << eol;
    if( flush )
        std::cout.flush();
 
    return;
}
 
/// A simple formatted output function.
/** This function writes its arguments, of any type and of any number, to stdout.  By default, the
 * arguments are separated by a space, the new line '\\n' is written at the end, and the std::cout
 * stream is flushed.  These behaviors can be altered via template parameters.
 *
 * Example:
 * \code
 * std::string s="output:";
 * double d=2.567;
 * int i=3;
 *
 * pout(s,d,i);
 * \endcode
 * Note that the types of the values do not need to be specified as templated arguments.
 * When run, this code results in
 * \verbatim
 * $ output: 2.567 3
 * $
 * \endverbatim
 *
 * The behavior can be changed with template arguments like
 * \code
 * pout<'\t', false, 0>(s,d,i);
 * \endcode
 * which would use the tab instead of space, and neither flush nor print a newline at the end.
 *
 * \tparam space is the character to place between the values,  by default this is space.
 * \tparam flush controls whether std::cout.flush() is called, by default it is true.
 * \tparam eol is the character to print at end of line, by default it is '\\n'.
 * \tparam valT a type which can be output by std::cout
 * \tparam valTs a variadic list of additional types which can be output by std::cout
 *
 * \ingroup ioutils
 */
template <char space = ' ', bool flush = true, char eol = '\n', typename valT, typename... valTs>
void pout( valT value,            ///<  [in] a value to print.
           const valTs &...values ///< [in] a variadic list of additional values. Any number of values can be specified,
                                  ///< with any type handled by std::cout.
)
{
    static const unsigned short int nargs = sizeof...( valTs );
 
    std::cout << value;
 
    if( nargs > 0 )
        std::cout << space;
 
    pout<space, flush, eol>( values... );
}
 
} // namespace ioutils
} // namespace mx
 
#endif // ioutils_pout_hpp