---

CdbNTuplePrint.hh

Go to the documentation of this file.

#ifndef CDB_NTUPLE_PRINT_HH
#define CDB_NTUPLE_PRINT_HH

// File and Version Information:
//      $Id: CdbNTuplePrint.hh,v 1.4 2004/08/06 05:54:41 bartoldu Exp $

#include "CdbBase/CdbCPtr.hh"

#include "CdbTable/CdbNTuplePrintDefaultConverter.hh"
#include "CdbTable/CdbNTuplePrintTypes.hh"
#include "CdbTable/CdbNTuplePrintImpl.hh"

#include <iostream>

/// A trivial class used to turn on the default element conversion rules
/**
  * This class is used to turn on default output conversion for n-tuple elements
  * if a client's code chooses so when using the "easy print" fron-end tool
  * defined below.
  *
  * The default converter assumes that there is the "operator<<" operator defined for
  * a type of n-tuple elements.
  *
  * Note, this is an internal class, which is not supposed to be used directly by
  * a client code.
  *
  * @see class CdbNTuplePrintConverter_Default
  */
class CdbNTuplePrintConverter_UseDefault {
};

/// An "easy print" front-end interface to the printing facility
/**
  * This interface would retrieve a configuration of a tuple from its
  * pointer's type, thus eliminating a need to pass them (the configuration
  * parameters).
  */
template < class CONVERTER = CdbNTuplePrintConverter_UseDefault >
class CdbNTuplePrint {

public:

  /// The print method (full control over parameters, Standard Output Stream)

    template < class NTUPLE >
    static CdbStatus print( const CdbCPtr<NTUPLE>&                  thePtr,
                            const unsigned int                      theColumnWidth,
                            const char*                             theIndent,
                            const CdbNTuplePrintTypes::FrameType    theFrameType,
                            const CdbNTuplePrintTypes::FrameBorders theFrameBorders )
    {
        return CdbNTuplePrintImpl< NTUPLE, CONVERTER >::print( std::cout,
                                                               thePtr,
                                                               theColumnWidth,
                                                               theIndent,
                                                               theFrameType,
                                                               theFrameBorders );
    }

  /// The print method (full control over parameters, any output stream)

    template < class NTUPLE >
    static CdbStatus print( std::ostream&                                theOutputStream,
                            const CdbCPtr<NTUPLE>&                  thePtr,
                            const unsigned int                      theColumnWidth,
                            const char*                             theIndent,
                            const CdbNTuplePrintTypes::FrameType    theFrameType,
                            const CdbNTuplePrintTypes::FrameBorders theFrameBorders )
    {
        return CdbNTuplePrintImpl< NTUPLE, CONVERTER >::print( theOutputStream,
                                                               thePtr,
                                                               theColumnWidth,
                                                               theIndent,
                                                               theFrameType,
                                                               theFrameBorders );
    }

  /// A simple method of printing #1 (preselected set of parameters, Standard Output Stream)

    template < class NTUPLE >
    static CdbStatus print1( const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return print( thePtr,
                      theColumnWidth,
                      "  ",
                      CdbNTuplePrintTypes::ClosedFrame,
                      CdbNTuplePrintTypes::DoubleHashes );
    }

  /// A simple method of printing #1 (preselected set of parameters, any output stream)

    template < class NTUPLE >
    static CdbStatus print1( std::ostream&               theOutputStream,
                             const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return print( theOutputStream,
                      thePtr,
                      theColumnWidth,
                      "  ",
                      CdbNTuplePrintTypes::ClosedFrame,
                      CdbNTuplePrintTypes::DoubleHashes );
    }

  /// A simple method of printing #2 (preselected set of parameters, Standard Output Stream)

    template < class NTUPLE >
    static CdbStatus print2( const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return print( thePtr,
                      theColumnWidth,
                      "  ",
                      CdbNTuplePrintTypes::OpenFrame,
                      CdbNTuplePrintTypes::SingleXes );
    }

  /// A simple method of printing #2 (preselected set of parameters, any output stream)

    template < class NTUPLE >
    static CdbStatus print2( std::ostream&               theOutputStream,
                             const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return print( theOutputStream,
                      thePtr,
                      theColumnWidth,
                      "  ",
                      CdbNTuplePrintTypes::OpenFrame,
                      CdbNTuplePrintTypes::SingleXes );
    }
};

/// The full specialization for the "easy print" fron-end defined above
/**
  * Unlike its generic couterpart, this specialized version of the class would
  * rely on the default conversion rules for n-tuple elements.
  *
  * @see class CdbNTuplePrintDefaultConverter
  */
template < >
class CdbNTuplePrint< CdbNTuplePrintConverter_UseDefault > {

public:

    template < class NTUPLE >
    static CdbStatus print( const CdbCPtr<NTUPLE>&                  thePtr,
                            const unsigned int                      theColumnWidth,
                            const char*                             theIndent,
                            const CdbNTuplePrintTypes::FrameType    theFrameType,
                            const CdbNTuplePrintTypes::FrameBorders theFrameBorders )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print( std::cout,
                                                                                                         thePtr,
                                                                                                         theColumnWidth,
                                                                                                         theIndent,
                                                                                                         theFrameType,
                                                                                                         theFrameBorders );
    }

    template < class NTUPLE >
    static CdbStatus print( std::ostream&                                theOutputStream,
                            const CdbCPtr<NTUPLE>&                  thePtr,
                            const unsigned int                      theColumnWidth,
                            const char*                             theIndent,
                            const CdbNTuplePrintTypes::FrameType    theFrameType,
                            const CdbNTuplePrintTypes::FrameBorders theFrameBorders )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print( theOutputStream,
                                                                                                         thePtr,
                                                                                                         theColumnWidth,
                                                                                                         theIndent,
                                                                                                         theFrameType,
                                                                                                         theFrameBorders );
    }

    template < class NTUPLE >
    static CdbStatus print1( const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print1( thePtr,
                                                                                                          theColumnWidth );
    }

    template < class NTUPLE >
    static CdbStatus print1( std::ostream&               theOutputStream,
                             const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print1( theOutputStream,
                                                                                                          thePtr,
                                                                                                          theColumnWidth );
    }

    template < class NTUPLE >
    static CdbStatus print2( const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print2( thePtr,
                                                                                                          theColumnWidth );
    }

    template < class NTUPLE >
    static CdbStatus print2( std::ostream&               theOutputStream,
                             const CdbCPtr<NTUPLE>& thePtr,
                             const unsigned int     theColumnWidth = 12 )
    {
        return CdbNTuplePrint< CdbNTuplePrintDefaultConverter< typename NTUPLE::element_type > >::print2( theOutputStream,
                                                                                                          thePtr,
                                                                                                          theColumnWidth );
    }
};

#endif // CDB_NTUPLE_PRINT_HH

---