LogRecord.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_LOGRECORD_H_
#define _DECAF_UTIL_LOGGING_LOGRECORD_H_

#include <decaf/lang/Throwable.h>
#include <decaf/util/logging/LoggerCommon.h>
#include <decaf/util/logging/Level.h>
#include <decaf/util/Config.h>

#include <memory>
#include <string>

namespace decaf{
namespace util{
namespace logging{

    class DECAF_API LogRecord {
    private:

        // Level of this Record
        Level level;

        // Name of the source Logger
        std::string loggerName;

        // Name of the File that originated the Log
        std::string sourceFile;

        // Line in the source file where log occurred
        unsigned int sourceLine;

        // The message to Log.
        std::string message;

        // The function Name where the log occured
        std::string functionName;

        // Time in Mills since UTC that this Record was logged
        long long timeStamp;

        // Thread Id of the Thread that logged this Record
        long long threadId;

        // A Throwable that is associated with this record
        std::auto_ptr<decaf::lang::Throwable> thrown;

    public:

        LogRecord();

        virtual ~LogRecord();

        Level getLevel() const {
            return level;
        };

        void setLevel( Level value ) {
            level = value;
        };

        const std::string& getLoggerName() const {
            return loggerName;
        };

        void setLoggerName( const std::string& loggerName ) {
            this->loggerName = loggerName;
        };

        const std::string& getSourceFile() const {
            return sourceFile;
        };

        void setSourceFile( const std::string& sourceFile ) {
            this->sourceFile = sourceFile;
        };

        unsigned int getSourceLine() const {
            return sourceLine;
        };

        void setSourceLine( unsigned int sourceLine ) {
            this->sourceLine = sourceLine;
        };

        const std::string& getMessage() const {
            return message;
        };

        void setMessage( const std::string& message ) {
            this->message = message;
        };

        const std::string& getSourceFunction() const {
            return functionName;
         };

        void setSourceFunction( const std::string& functionName ) {
            this->functionName = functionName;
        };

        long long getTimestamp() const { return timeStamp; };

        void setTimestamp( long long timeStamp ) {
            this->timeStamp = timeStamp;
        };

        long long getTreadId() const {
            return threadId;
        };

        void setTreadId( long long threadId ) {
            this->threadId = threadId;
        };

        decaf::lang::Throwable* getThrown() const {
            return this->thrown.get();
        }

        void setThrown( decaf::lang::Throwable* thrown ) {
            this->thrown.reset( thrown );
        }

    };

}}}

#endif /*_DECAF_UTIL_LOGGING_LOGRECORD_H_*/