stream.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef _LOG4CXX_STREAM_H
#define _LOG4CXX_STREAM_H

#include <log4cxx/logger.h>
#include <sstream>
#include <log4cxx/spi/location/locationinfo.h>

namespace log4cxx
{

class LOG4CXX_EXPORT logstream_base
{
    public:
        logstream_base(const log4cxx::LoggerPtr& logger,
            const log4cxx::LevelPtr& level);
        virtual ~logstream_base();
        void insert(std::ios_base & (*manip)(std::ios_base&));

        int precision();
        int width();
        int precision(int newval);
        int width(int newval);
        int fill();
        int fill(int newval);

        std::ios_base::fmtflags flags(std::ios_base::fmtflags newflags);
        std::ios_base::fmtflags setf(std::ios_base::fmtflags newflags, std::ios_base::fmtflags mask);
        std::ios_base::fmtflags setf(std::ios_base::fmtflags newflags);


        static logstream_base& endmsg(logstream_base&);

        static logstream_base& nop(logstream_base&);

        void end_message();



        void setLevel(const LevelPtr& level);
        inline bool isEnabled() const
        {
            return enabled;
        }

        bool isEnabledFor(const LevelPtr& level) const;

        void setLocation(const log4cxx::spi::LocationInfo& location);

        bool set_stream_state(std::ios_base& os, int& fillchar);

    protected:
        virtual void log(LoggerPtr& logger,
            const LevelPtr& level,
            const log4cxx::spi::LocationInfo& location) = 0;
        virtual void erase() = 0;
        virtual void get_stream_state(std::ios_base& base,
            std::ios_base& mask,
            int& fill,
            bool& fillSet) const = 0;
        virtual void refresh_stream_state() = 0;

    private:
        logstream_base(logstream_base&);
        logstream_base& operator=(logstream_base&);
        class LOG4CXX_EXPORT logstream_ios_base : public std::ios_base
        {
            public:
                logstream_ios_base(std::ios_base::fmtflags initval,
                    int initsize);
        } initset, initclear;
        int fillchar;
        bool fillset;
        bool enabled;
        log4cxx::LoggerPtr logger;
        log4cxx::LevelPtr level;
        log4cxx::spi::LocationInfo location;
};

typedef logstream_base& (*logstream_manipulator)(logstream_base&);

class LOG4CXX_EXPORT logstream : public logstream_base
{
        typedef char Ch;
    public:
        logstream(const log4cxx::LoggerPtr& logger,
            const log4cxx::LevelPtr& level);

        logstream(const Ch* loggerName,
            const log4cxx::LevelPtr& level);

        logstream(const std::basic_string<Ch>& loggerName,
            const log4cxx::LevelPtr& level);

        ~logstream();

        logstream& operator<<(std::ios_base & (*manip)(std::ios_base&));

        logstream& operator<<(logstream_manipulator manip);

        logstream& operator<<(const log4cxx::LevelPtr& level);
        logstream& operator<<(const log4cxx::spi::LocationInfo& location);

        logstream& operator>>(const log4cxx::spi::LocationInfo& location);

        operator std::basic_ostream<Ch>& ();

#if !(LOG4CXX_USE_GLOBAL_SCOPE_TEMPLATE)

        template <class V>
        inline log4cxx::logstream& operator<<(const V& val)
        {
            if (LOG4CXX_UNLIKELY(isEnabled()))
            {
                ((std::basic_ostream<char>&) *this) << val;
            }

            return *this;
        }
#endif


    protected:
        virtual void log(LoggerPtr& logger,
            const LevelPtr& level,
            const log4cxx::spi::LocationInfo& location);

        virtual void erase();

        virtual void get_stream_state(std::ios_base& base,
            std::ios_base& mask,
            int& fill,
            bool& fillSet) const;
        virtual void refresh_stream_state();


    private:
        logstream(const logstream&);
        logstream& operator=(const logstream&);
        std::basic_stringstream<Ch>* stream;

};

#if LOG4CXX_WCHAR_T_API

class LOG4CXX_EXPORT wlogstream : public logstream_base
{
        typedef wchar_t Ch;
    public:
        wlogstream(const log4cxx::LoggerPtr& logger,
            const log4cxx::LevelPtr& level);

        wlogstream(const Ch* loggerName,
            const log4cxx::LevelPtr& level);

        wlogstream(const std::basic_string<Ch>& loggerName,
            const log4cxx::LevelPtr& level);

        ~wlogstream();

        wlogstream& operator<<(std::ios_base & (*manip)(std::ios_base&));

        wlogstream& operator<<(logstream_manipulator manip);

        wlogstream& operator<<(const log4cxx::LevelPtr& level);
        wlogstream& operator<<(const log4cxx::spi::LocationInfo& location);

        wlogstream& operator>>(const log4cxx::spi::LocationInfo& location);


        operator std::basic_ostream<Ch>& ();

#if !(LOG4CXX_USE_GLOBAL_SCOPE_TEMPLATE)

        template <class V>
        inline log4cxx::wlogstream& operator<<(const V& val)
        {
            if (LOG4CXX_UNLIKELY(isEnabled()))
            {
                ((std::basic_ostream<wchar_t>&) *this) << val;
            }

            return *this;
        }
#endif

    protected:
        virtual void log(LoggerPtr& logger,
            const LevelPtr& level,
            const log4cxx::spi::LocationInfo& location);

        virtual void erase();

        virtual void get_stream_state(std::ios_base& base,
            std::ios_base& mask,
            int& fill,
            bool& fillSet) const;
        virtual void refresh_stream_state();


    private:
        wlogstream(const wlogstream&);
        wlogstream& operator=(const wlogstream&);
        std::basic_stringstream<Ch>* stream;

};
#endif

#if LOG4CXX_UNICHAR_API || LOG4CXX_CFSTRING_API

class LOG4CXX_EXPORT ulogstream : public logstream_base
{
        typedef UniChar Ch;
    public:
        ulogstream(const log4cxx::LoggerPtr& logger,
            const log4cxx::LevelPtr& level);

#if LOG4CXX_UNICHAR_API

        ulogstream(const Ch* loggerName,
            const log4cxx::LevelPtr& level);

        ulogstream(const std::basic_string<Ch>& loggerName,
            const log4cxx::LevelPtr& level);
#endif

#if LOG4CXX_CFSTRING_API
        ulogstream(const CFStringRef& loggerName,
            const log4cxx::LevelPtr& level);
#endif

        ~ulogstream();

        ulogstream& operator<<(std::ios_base & (*manip)(std::ios_base&));

        ulogstream& operator<<(logstream_manipulator manip);

        ulogstream& operator<<(const log4cxx::LevelPtr& level);
        ulogstream& operator<<(const log4cxx::spi::LocationInfo& location);

        ulogstream& operator>>(const log4cxx::spi::LocationInfo& location);


        operator std::basic_ostream<Ch>& ();

#if !(LOG4CXX_USE_GLOBAL_SCOPE_TEMPLATE)

        template <class V>
        inline ulogstream& operator<<(const V& val)
        {
            if (LOG4CXX_UNLIKELY(isEnabled()))
            {
                ((std::basic_ostream<Ch>&) *this) << val;
            }

            return *this;
        }
#endif

    protected:
        virtual void log(LoggerPtr& logger,
            const LevelPtr& level,
            const log4cxx::spi::LocationInfo& location);

        virtual void erase();

        virtual void get_stream_state(std::ios_base& base,
            std::ios_base& mask,
            int& fill,
            bool& fillSet) const;
        virtual void refresh_stream_state();


    private:
        ulogstream(const ulogstream&);
        ulogstream& operator=(const ulogstream&);
        std::basic_stringstream<Ch>* stream;

};
#endif


}  // namespace log4cxx


#if LOG4CXX_USE_GLOBAL_SCOPE_TEMPLATE
//
//  VC6 will fail to compile if class-scope templates
//     are used to handle arbitrary insertion operations.
//     However, using global namespace insertion operations
//     run into LOGCXX-150.

template <class V>
inline log4cxx::logstream& operator<<(log4cxx::logstream& os, const V& val)
{
    if (LOG4CXX_UNLIKELY(os.isEnabled()))
    {
        ((std::basic_ostream<char>&) os) << val;
    }

    return os;
}

#if LOG4CXX_WCHAR_T_API

template <class V>
inline log4cxx::wlogstream& operator<<(log4cxx::wlogstream& os, const V& val)
{
    if (LOG4CXX_UNLIKELY(os.isEnabled()))
    {
        ((std::basic_ostream<wchar_t>&) os) << val;
    }

    return os;
}
#endif
#endif

#if !defined(LOG4CXX_ENDMSG)
    #if LOG4CXX_LOGSTREAM_ADD_NOP
        #define LOG4CXX_ENDMSG (log4cxx::logstream_manipulator) log4cxx::logstream_base::nop >> LOG4CXX_LOCATION << (log4cxx::logstream_manipulator) log4cxx::logstream_base::endmsg
    #else
        #define LOG4CXX_ENDMSG LOG4CXX_LOCATION << (log4cxx::logstream_manipulator) log4cxx::logstream_base::endmsg
    #endif
#endif


#endif //_LOG4CXX_STREAM_H