Logger.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 _DECAF_UTIL_LOGGING_LOGGER_H_
#define _DECAF_UTIL_LOGGING_LOGGER_H_

#include <decaf/util/logging/LoggerCommon.h>
#include <decaf/util/logging/LogRecord.h>
#include <decaf/util/logging/LogManager.h>
#include <decaf/util/logging/Handler.h>
#include <decaf/util/concurrent/Mutex.h>
#include <decaf/util/Config.h>

#include <decaf/lang/exceptions/IllegalArgumentException.h>
#include <decaf/lang/exceptions/NullPointerException.h>

#include <list>
#include <string>
#include <stdarg.h>

namespace decaf{
namespace util{
namespace logging{

    class Filter;

    class DECAF_API Logger {
    private:

        // The name of this Logger
        std::string name;

        // The Parent of this Logger
        Logger* parent;

        // list of Handlers owned by this logger
        std::list<Handler*> handlers;

        // Filter used by this Logger
        Filter* filter;

        // The Log Level of this Logger
        Level level;

        // Using Parent Handlers?
        bool useParentHandlers;

    private:

        Logger( const Logger& );
        Logger& operator= ( const Logger& );

    protected:

        Logger( const std::string& name );

    public:

        virtual ~Logger();

        const std::string& getName() const {
            return name;
        }

        Logger* getParent() const {
            return this->parent;
        }

        void setParent( Logger* parent ) {
            this->parent = parent;
        }

        void addHandler( Handler* handler );

        void removeHandler( Handler* handler );

        const std::list<Handler*>& getHandlers() const;

        void setFilter( Filter* filter );

        const Filter* getFilter() const {
            return filter;
        }

        Level getLevel() const {
            return level;
        }

        void setLevel( const Level& level ) {
            this->level = level;
        }

        bool getUseParentHandlers() const {
            return useParentHandlers;
        }

        void setUseParentHandlers( bool value ) {
            this->useParentHandlers = value;
        }

    public:   // Logging Methods.

        virtual void entering( const std::string& blockName,
                               const std::string& file,
                               const int line );

        virtual void exiting( const std::string& blockName,
                              const std::string& file,
                              const int line );

        virtual void severe( const std::string& file,
                             const int line,
                             const std::string functionName,
                             const std::string& message );

        virtual void warning( const std::string& file,
                              const int line,
                              const std::string functionName,
                              const std::string& message );

        virtual void info( const std::string& file,
                           const int line,
                           const std::string functionName,
                           const std::string& message );

        virtual void debug( const std::string& file,
                            const int line,
                            const std::string functionName,
                            const std::string& message );

        virtual void config( const std::string& file,
                             const int line,
                             const std::string functionName,
                             const std::string& message );

        virtual void fine( const std::string& file,
                           const int line,
                           const std::string functionName,
                           const std::string& message );

        virtual void finer( const std::string& file,
                            const int line,
                            const std::string functionName,
                            const std::string& message );

        virtual void finest( const std::string& file,
                             const int line,
                             const std::string functionName,
                             const std::string& message );

        virtual void throwing( const std::string& file,
                               const int line,
                               const std::string functionName,
                               const decaf::lang::Throwable& thrown );

        virtual bool isLoggable( const Level& level ) const;

        virtual void log( LogRecord& record );

        virtual void log( const Level& level, const std::string& message );

        virtual void log( const Level& levels,
                          const std::string& file,
                          const int line,
                          const std::string& message, ... );

        virtual void log( const Level& level,
                          const std::string& file,
                          const int line,
                          const std::string& message,
                          lang::Exception& ex );

    public:

        static Logger* getAnonymousLogger();

        static Logger* getLogger( const std::string& name );

    };

}}}

#endif /*_DECAF_UTIL_LOGGING_LOGGER_H_*/