oflog/include/dcmtk/oflog/spi/logevent.h

Go to the documentation of this file.

// Module:  Log4CPLUS
// File:    loggingevent.h
// Created: 6/2001
// Author:  Tad E. Smith
//
//
// Copyright 2001-2009 Tad E. Smith
//
// Licensed 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 _LOG4CPLUS_SPI_INTERNAL_LOGGING_EVENT_HEADER_
#define _LOG4CPLUS_SPI_INTERNAL_LOGGING_EVENT_HEADER_

#include "dcmtk/oflog/config.h"
#include "dcmtk/oflog/loglevel.h"
#include "dcmtk/oflog/ndc.h"
#include "dcmtk/oflog/tstring.h"
#include "dcmtk/oflog/helpers/timehelp.h"
#include "dcmtk/oflog/helpers/threads.h"

#include "dcmtk/ofstd/ofaptr.h"

namespace log4cplus {
    namespace spi {
        class LOG4CPLUS_EXPORT InternalLoggingEvent {
        public:
          // Ctors
             InternalLoggingEvent(const log4cplus::tstring& logger,
                                  LogLevel ll_,
                                  const log4cplus::tstring& message_,
                                  const char* filename,
                                  int line_,
                                  const char* function_)
              : message(message_),
                loggerName(logger),
                ll(ll_),
                ndc(),
                thread(),
                timestamp(log4cplus::helpers::Time::gettimeofday()),
                file( (  filename
                       ? LOG4CPLUS_C_STR_TO_TSTRING(filename)
                       : log4cplus::tstring()) ),
                line(line_),
                function( ( function_
                          ? LOG4CPLUS_C_STR_TO_TSTRING(function_)
                          : log4cplus::tstring()) ),
                threadCached(false),
                ndcCached(false)
             {
             }

             InternalLoggingEvent(const log4cplus::tstring& logger,
                                  LogLevel ll_,
                                  const log4cplus::tstring& ndc_,
                                  const log4cplus::tstring& message_,
                                  const log4cplus::tstring& thread_,
                                  log4cplus::helpers::Time time,
                                  const log4cplus::tstring& file_,
                                  int line_,
                                  const log4cplus::tstring& function_)
              : message(message_),
                loggerName(logger),
                ll(ll_),
                ndc(ndc_),
                thread(thread_),
                timestamp(time),
                file(file_),
                line(line_),
                function(function_),
                threadCached(true),
                ndcCached(true)
             {
             }

             InternalLoggingEvent(const log4cplus::spi::InternalLoggingEvent& rhs)
              : message(rhs.getMessage()),
                loggerName(rhs.getLoggerName()),
                ll(rhs.getLogLevel()),
                ndc(rhs.getNDC()),
                thread(rhs.getThread()),
                timestamp(rhs.getTimestamp()),
                file(rhs.getFile()),
                line(rhs.getLine()),
                function(rhs.getFunction()),
                threadCached(true),
                ndcCached(true)
             {
             }

            virtual ~InternalLoggingEvent();


          // public virtual methods
            virtual const log4cplus::tstring& getMessage() const;

            virtual unsigned int getType() const;

            virtual OFauto_ptr<InternalLoggingEvent> clone() const;



          // public methods
            const log4cplus::tstring& getLoggerName() const { return loggerName; }

            LogLevel getLogLevel() const { return ll; }

            const log4cplus::tstring& getNDC() const {
                if(!ndcCached) {
                    ndc = log4cplus::getNDC().get();
                    ndcCached = true;
                }
                return ndc;
            }

            const log4cplus::tstring& getThread() const {
                if(!threadCached) {
                    thread = LOG4CPLUS_GET_CURRENT_THREAD_NAME;
                    threadCached = true;
                }
                return thread;
            }

            const log4cplus::helpers::Time& getTimestamp() const { return timestamp; }

            const log4cplus::tstring& getFile() const { return file; }

            int getLine() const { return line; }

            const log4cplus::tstring& getFunction() const { return function; }

          // public operators
            log4cplus::spi::InternalLoggingEvent&
            operator=(const log4cplus::spi::InternalLoggingEvent& rhs);

          // static methods
            static unsigned int getDefaultType();

        protected:
          // Data
            log4cplus::tstring message;

        private:
            log4cplus::tstring loggerName;
            LogLevel ll;
            mutable log4cplus::tstring ndc;
            mutable log4cplus::tstring thread;
            log4cplus::helpers::Time timestamp;
            log4cplus::tstring file;
            int line;
            log4cplus::tstring function;
            mutable bool threadCached;
            mutable bool ndcCached;
        };

    } // end namespace spi
} // end namespace log4cplus

#endif // _LOG4CPLUS_SPI_INTERNAL_LOGGING_EVENT_HEADER_

---

Generated on 6 Jan 2011 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.5.1