loggingevent.h

/*
 * 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_SPI_LOGGING_EVENT_H
#define _LOG4CXX_SPI_LOGGING_EVENT_H

#if defined(_MSC_VER)
    #pragma warning (push)
    #pragma warning ( disable: 4231 4251 4275 4786 )
#endif



#include <log4cxx/helpers/objectptr.h>
#include <log4cxx/logstring.h>
#include <time.h>
#include <log4cxx/logger.h>
#include <log4cxx/mdc.h>
#include <log4cxx/spi/location/locationinfo.h>
#include <vector>


namespace log4cxx
{
namespace helpers
{
class ObjectOutputStream;
}

namespace spi
{
LOG4CXX_LIST_DEF(KeySet, LogString);

class LOG4CXX_EXPORT LoggingEvent :
    public virtual helpers::ObjectImpl
{
    public:
        DECLARE_LOG4CXX_OBJECT(LoggingEvent)
        BEGIN_LOG4CXX_CAST_MAP()
        LOG4CXX_CAST_ENTRY(LoggingEvent)
        END_LOG4CXX_CAST_MAP()

        typedef spi::KeySet KeySet;

        LoggingEvent();

        LoggingEvent(const LogString& logger,
            const LevelPtr& level,   const LogString& message,
            const log4cxx::spi::LocationInfo& location);

        ~LoggingEvent();

        inline const LevelPtr& getLevel() const
        {
            return level;
        }

        inline const LogString& getLoggerName() const
        {
            return logger;
        }

        inline const LogString& getMessage() const
        {
            return message;
        }

        inline const LogString& getRenderedMessage() const
        {
            return message;
        }

        static log4cxx_time_t getStartTime();

        inline const LogString& getThreadName() const
        {
            return threadName;
        }

        inline log4cxx_time_t getTimeStamp() const
        {
            return timeStamp;
        }

        /* Return the file where this log statement was written. */
        inline const log4cxx::spi::LocationInfo& getLocationInformation() const
        {
            return locationInfo;
        }

        bool getNDC(LogString& dest) const;

        void write(helpers::ObjectOutputStream& os, helpers::Pool& p) const;

        bool getMDC(const LogString& key, LogString& dest) const;

        KeySet getMDCKeySet() const;

        void getMDCCopy() const;

        bool getProperty(const LogString& key, LogString& dest) const;
        KeySet getPropertyKeySet() const;

        void setProperty(const LogString& key, const LogString& value);

    private:
        LogString logger;

        LevelPtr level;

        mutable LogString* ndc;

        mutable MDC::Map* mdcCopy;

        std::map<LogString, LogString>* properties;

        mutable bool ndcLookupRequired;

        mutable bool mdcCopyLookupRequired;

        LogString message;


        log4cxx_time_t timeStamp;

        const log4cxx::spi::LocationInfo locationInfo;


        const LogString threadName;

        //
        //   prevent copy and assignment
        //
        LoggingEvent(const LoggingEvent&);
        LoggingEvent& operator=(const LoggingEvent&);
        static const LogString getCurrentThreadName();

        static void writeProlog(log4cxx::helpers::ObjectOutputStream& os, log4cxx::helpers::Pool& p);

};

LOG4CXX_PTR_DEF(LoggingEvent);
LOG4CXX_LIST_DEF(LoggingEventList, LoggingEventPtr);
}
}

#if defined(_MSC_VER)
    #pragma warning (pop)
#endif


#endif //_LOG4CXX_SPI_LOGGING_EVENT_H