FlatOutput.H

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
  =========                 |
  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   \\    /   O peration     |
    \\  /    A nd           | www.openfoam.com
     \\/     M anipulation  |
-------------------------------------------------------------------------------
    Copyright (C) 2017-2020 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
    This file is part of OpenFOAM.

    OpenFOAM 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.

    OpenFOAM 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 OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.

Namespace
    Foam::FlatOutput

Description
    Various output adaptors, principally to output a list of items
    on a single line.

\*---------------------------------------------------------------------------*/

#ifndef FlatOutput_H
#define FlatOutput_H

#include "Ostream.H"

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{
namespace FlatOutput
{

// Forward Declarations
template<class Container, class Delimiters> class OutputAdaptor;

} // End namespace FlatOutput


// Forward Declarations
template<class Container, class Delimiters>
inline Ostream& operator<<
(
    Ostream& os,
    const FlatOutput::OutputAdaptor<Container, Delimiters>& adaptor
);


namespace FlatOutput
{

/*---------------------------------------------------------------------------*\
                         Class Decorators Declaration
\*---------------------------------------------------------------------------*/

//- List decorators with \c open, \c close and \c separator characters
template<char OpenChar, char CloseChar, char SepChar>
struct Decorators
{
    static constexpr char open  = OpenChar;
    static constexpr char close = CloseChar;
    static constexpr char separator = SepChar;
};


#undef  makeDecorator
#define makeDecorator(Name, Open, Close, Sep)                                  \
      \
    struct Name : public Decorators<Open, Close, Sep> {};

makeDecorator(BareComma, '\0','\0', ',');
makeDecorator(BareSpace, '\0','\0', ' ');

makeDecorator(BraceComma, '{','}', ',');
makeDecorator(BraceSpace, '{','}', ' ');

makeDecorator(ParenComma, '(',')', ',');
makeDecorator(ParenSpace, '(',')', ' ');  // Normal default

makeDecorator(PointyComma, '<','>', ',');
makeDecorator(PointySpace, '<','>', ' ');

makeDecorator(SquareComma,'[',']', ',');
makeDecorator(SquareSpace,'[',']', ' ');

#undef makeDecorator


/*---------------------------------------------------------------------------*\
                        Class OutputAdaptor Declaration
\*---------------------------------------------------------------------------*/

//- An output adaptor with a write method and an Ostream operator.
//
//  Generate single line (flat) output using the characters specified by
//  the templated Delimiters.
//  Normally called with the global flatOutput() function.
//  For example,
//  \code
//
//  /* With default parenthesis/space delimiters */
//  Info<< "Names: " << flatOutput(names) << nl;
//
//  /* Other delimiters */
//  Info<< flatOutput(names, FlatOutput::SquareComma{}) << nl;
//
//  /* User-specified delimiters */
//  Info<< flatOutput(names, FlatOutput::Decorators<'[',')',':'>{}) << nl;
//
//  \endcode
//
template<class Container, class Delimiters>
class OutputAdaptor
{
    // Private Data

        //- The container of values for output
        const Container& values;

public:

    // Constructors

        //- Construct from component
        explicit OutputAdaptor(const Container& obj)
        :
            values(obj)
        {}


    // Member Functions

        //- Write list using \c open, \c close and \c separator characters
        //- specified by Delimiters template, which generally results in
        //- a single line without line breaks.
        //
        //  \note Suppresses nul char output.
        //        No special handling for newline separators.
        inline Ostream& write(Ostream& os) const
        {
            bool started = false;

            // In c++17, can use constexpr if

            if (Delimiters::open)
            {
                os  << Delimiters::open;
            }
            for (const auto& item : values)
            {
                if (started)
                {
                    if (Delimiters::separator)
                    {
                        os  << Delimiters::separator;
                    }
                }
                else
                {
                    started = true;
                }
                os  << item;
            }
            if (Delimiters::close)
            {
                os << Delimiters::close;
            }

            return os;
        }


    // Operators

        //- Ostream Operator
        friend Ostream& operator<<
        (
            Ostream& os,
            const OutputAdaptor<Container, Delimiters>& adaptor
        )
        {
            return adaptor.write(os);
        }
};


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace FlatOutput
} // End namespace Foam


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

namespace Foam
{

//- Global flatOutput() function with specified output delimiters
template<class Container, class Delimiters>
inline FlatOutput::OutputAdaptor<Container, Delimiters>
flatOutput
(
    const Container& obj,
    Delimiters delim
)
{
    return FlatOutput::OutputAdaptor<Container, Delimiters>(obj);
}


//- Global flatOutput() function with default (parenthesis/space) delimiters
template<class Container>
inline FlatOutput::OutputAdaptor<Container, FlatOutput::ParenSpace>
flatOutput
(
    const Container& obj
)
{
    return FlatOutput::OutputAdaptor<Container, FlatOutput::ParenSpace>(obj);
}


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //