RTLog.h

/*
 * Licensed Materials - Property of HCL and/or IBM
 * Copyright HCL Technologies Ltd. 2016, 2021. All Rights Reserved.
 * Copyright IBM Corporation 1999, 2016. All Rights Reserved.
 *
 * U.S. Government Users Restricted Rights -  Use, duplication or 
 * disclosure restricted by GSA ADP Schedule.
 */
 
#ifndef __RTLog_h__
#define __RTLog_h__ included
 
#ifdef PRAGMA
#pragma interface
#endif
 
#ifndef __RTProtocol_h__
#include <RTProtocol.h>
#endif
 
#include <iostream>
#include <sstream>
#include <fstream>
 
class  RTDataObject;
class  RTMutex;
struct RTObject_class;
class  RTString;
struct RTTypedValue;
 
struct Log
{
    class Base : public RTProtocol
    {
    private:
        // this will eventually be a file descriptor.
        int             file;
 
    public:
        RTS_INLINE      Base( void );
        RTS_INLINE      Base(std::ostream& stream);
        RTS_INLINE      ~Base( void );
 
        static const RTProtocolDescriptor rt_class;
 
        RTS_INLINE void cr( void );
 
        void            crtab( int = 1 );
 
        // The below functions need not be called
        void            open( const char * );
        void            open( void );
        void            close( void );
 
        void            log( const char * str);
 
        void            log( const RTString & str);
 
        void            show( const char * str);
 
        void            show( const RTString & str);
 
#if OBJECT_ENCODE
        void            log( char );
        void            log( wchar_t );
#if RTUseFloatingPoint
        void            log( double );
        void            log( float );
        void            log( long double );
#endif
        void            log( int );
        void            log( long );
        void            log( long long );
        void            log( short );
        void            log( const RTDataObject & );
 
        void            log( const void * data, const RTObject_class * type);
 
        RTS_INLINE void log( const RTTypedValue & );
 
        void            log( unsigned int );
        void            log( unsigned long );
        void            log( unsigned long long );
        void            log( unsigned short );
        void            log( unsigned char );
 
        void            show( char );
        void            show( wchar_t );
#if RTUseFloatingPoint
        void            show( double );
        void            show( float );
        void            show( long double );
#endif
        void            show( int );
        void            show( long );
        void            show( long long );
        void            show( short );
        void            show( const RTDataObject & );
 
        void            show( const void * data, const RTObject_class * type);
 
        RTS_INLINE void show( const RTTypedValue & );
 
        void            show( unsigned int );
        void            show( unsigned long );
        void            show( unsigned long long );
        void            show( unsigned short );
        void            show( unsigned char );
#endif
        void            space( void );
        void            tab( void );
        void            clear( void );
 
        void            commit( void );
 
        Base&           operator<<( const RTDataObject & obj );
 
        Base&           operator<<( const RTTypedValue & info );
 
        Base&           operator<<( std::ostream& (*manip)(std::ostream&) );
 
        template <typename T>
        Base&           operator<<( const T& value )
        {
            outputStream << value;
            return *this;
        }
 
 
    private:
        // unavailable methods
        Base( const Base & );
        Base & operator=( const Base & );
        bool valueParsingUtil( const void * value, const RTObject_class * type );
        std::ostream& outputStream;
    };
 
    static Base out;
    static Base err;
 
    static std::ostream& endl( std::ostream& os );
 
    static std::ostream& lock( std::ostream& os );
 
    static std::ostream& unlock( std::ostream& os );
 
 
    class Stream
    {
    private:
        std::ofstream ofStream;
        Base* baseStream;
        bool ownsStream;
 
        // unavailable methods
        Stream( const Stream & );
        Stream & operator=( const Stream & );
 
    public:
        Stream( const char * filename, bool overwrite = true );
 
        Stream( std::ostream* stdStreamPtr );
 
        Stream( Base* baseStreamPtr );
        ~Stream();
 
        Stream& operator<<( const RTTypedValue & info );
 
        Stream& operator<<(std::ostream& (*manip)(std::ostream&));
 
        template <typename T>
        Stream& operator<<(const T& value)
        {
            if (baseStream)
            {
                (*baseStream) << value;
            }
            return *this;
        }
    };
};
 
#if RTS_INLINES
#include <RTLog.inl>
#endif
 
#endif // __RTLog_h__