This file is indexed.

/usr/include/dcmtk/oflog/oflog.h is in libdcmtk2-dev 3.6.0-15.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/*
 *
 *  Copyright (C) 2009-2010, OFFIS e.V.
 *  All rights reserved.  See COPYRIGHT file for details.
 *
 *  This software and supporting documentation were developed by
 *
 *    OFFIS e.V.
 *    R&D Division Health
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *
 *  Module:  oflog
 *
 *  Author:  Uli Schlachter
 *
 *  Purpose: Simplify the usage of log4cplus to other modules (Header)
 *
 *  Last Update:      $Author: joergr $
 *  Update Date:      $Date: 2010-10-14 13:20:52 $
 *  CVS/RCS Revision: $Revision: 1.12 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */


#ifndef OFLOG_H
#define OFLOG_H

#include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */

#include "dcmtk/oflog/logger.h"
#include "dcmtk/ofstd/oftypes.h"
#include "dcmtk/ofstd/ofconapp.h"

#define OFLOG_TRACE(logger, msg) LOG4CPLUS_TRACE(logger, msg)
#define OFLOG_DEBUG(logger, msg) LOG4CPLUS_DEBUG(logger, msg)
#define OFLOG_INFO(logger, msg)  LOG4CPLUS_INFO(logger, msg)
#define OFLOG_WARN(logger, msg)  LOG4CPLUS_WARN(logger, msg)
#define OFLOG_ERROR(logger, msg) LOG4CPLUS_ERROR(logger, msg)
#define OFLOG_FATAL(logger, msg) LOG4CPLUS_FATAL(logger, msg)

/** simple wrapper around the "low-level" Logger object to make it easier to
 *  switch to a different system
 */
class OFLogger : private log4cplus::Logger
{
public:
    /** copy constructor
     *  @param base object to be copied
     */
    OFLogger(const log4cplus::Logger &base);

    /// these are the log levels that you can feed to isEnabledFor()
    enum LogLevel {
        /// trace: output more details on the internal application state, a kind of "verbose debug"
        TRACE_LOG_LEVEL = log4cplus::TRACE_LOG_LEVEL,
        /// debug: fine-grained informational events that are most useful to debug an application
        DEBUG_LOG_LEVEL = log4cplus::DEBUG_LOG_LEVEL,
        /// info: informational messages that highlight the progress of the application at coarse-grained level
        INFO_LOG_LEVEL  = log4cplus::INFO_LOG_LEVEL,
        /// warn: potentially harmful situations
        WARN_LOG_LEVEL  = log4cplus::WARN_LOG_LEVEL,
        /// error: events that might still allow the application to continue running
        ERROR_LOG_LEVEL = log4cplus::ERROR_LOG_LEVEL,
        /// fatal: very severe error events that will presumably lead the application to abort
        FATAL_LOG_LEVEL = log4cplus::FATAL_LOG_LEVEL
    };

    /** check if the given log level was activated.
     *  This can be used to check if a given log level is activated before
     *  spending cpu time on generating a log message. The OFLOG_* macros use
     *  this automatically, so you should never do something like:
     *     if (myLogger.isEnabledFor(INFO_LOG_LEVEL))
     *         OFLOG_INFO("Doing it like this is pointless);
     *  @param ll the log level to check for
     *  @return true if messages on this level won't be discarded
     */
    bool isEnabledFor(log4cplus::LogLevel ll) const {
        return Logger::isEnabledFor(ll);
    }

    /// this function is only used internally by OFLOG_FATAL and friends
    void forcedLog(log4cplus::LogLevel ll, const log4cplus::tstring& message,
                   const char* file=NULL, int line=-1, const char* function=NULL) const {
        Logger::forcedLog(ll, message, file, line, function);
    }

    /** Get the logger's log level.
     *  One of the checks that isEnabledFor() does looks like this:
     *    if (getChainedLogLevel() < level)
     *        return false;
     *  @return the log level to which this logger is set.
     */
    LogLevel getChainedLogLevel() const {
        return OFstatic_cast(LogLevel, Logger::getChainedLogLevel());
    }
};

/** functions for initializing the logging system
 */
class OFLog
{
 private:

    /** private constructor, don't create instances of this class
     */
    OFLog() { }

    /** set up the logging and enable it
     *  @param level the verbosity that you want
     */
    static void configureLogger(log4cplus::LogLevel level);

 public:

    /** create a new Logger object
     *  @param name the name of the logger
     */
    static OFLogger getLogger(const char *name);

    /** set up the logging and enable it
     *  @param level the verbosity that you want
     */
    static void configure(OFLogger::LogLevel level = OFLogger::WARN_LOG_LEVEL);

    /** handle the command line options used for logging
     *  @param cmd the command line whose options are handled
     *  @param app the console application which is used for console output and error checking
     */
    static void configureFromCommandLine(OFCommandLine &cmd, OFConsoleApplication &app);

    /** add the command line options which configureFromCommandLine() checks for
     *  @param cmd the command line to which these options should be added
     */
    static void addOptions(OFCommandLine &cmd);

    /** if there was a config file loaded in configureFromCommandLine(), the
     *  in-memory copy will be parsed again, but all variables will be updated
     *  first (current time, process id, ....)
     *  @param cmd command line from which the application name will be retrieved
     */
    static void reconfigure(OFCommandLine *cmd = NULL);

 private:

    /// If we loaded a config file in configureFromCommandLine(), this is it
    static OFauto_ptr<log4cplus::helpers::Properties> configProperties_;
};

#endif


/*
 *
 * CVS/RCS Log:
 * $Log: oflog.h,v $
 * Revision 1.12  2010-10-14 13:20:52  joergr
 * Updated copyright header. Added reference to COPYRIGHT file.
 *
 * Revision 1.11  2010-08-05 08:38:11  uli
 * Fixed some warnings from -Wold-style-cast.
 *
 * Revision 1.10  2010-05-14 12:29:55  uli
 * Added new function OFLog::reconfigure() which reinterprets the logger config
 * file. This can e.g. be useful for logging to a different file after fork().
 *
 * Revision 1.9  2010-04-26 12:22:30  uli
 * Fixed a some minor doxygen warnings.
 *
 * Revision 1.8  2010-04-23 11:04:46  uli
 * Updated oflog to log4cplus revision 1200 from PRODUCTION_1_0_x branch.
 *
 * Revision 1.7  2010-03-08 10:50:40  uli
 * Don't use "using" to fix compilation with MSVC6.
 *
 * Revision 1.6  2009-11-17 14:26:21  uli
 * Make OFLogger::getChainedLogLevel() accessible.
 *
 * Revision 1.5  2009-11-06 09:41:22  joergr
 * Changed documentation on log level "trace".
 *
 * Revision 1.4  2009-09-16 10:04:26  joergr
 * Changed OFLogger's copy constructor: use "const &" for the parameter.
 * Added missing documentation on parameters.
 *
 * Revision 1.3  2009-09-14 10:51:05  joergr
 * Removed (now) unused helper function toLogMode().
 *
 * Revision 1.2  2009-08-20 12:08:02  joergr
 * Added documentation on log level values.
 *
 * Revision 1.1  2009-08-19 11:54:00  joergr
 * Added new module "oflog" which is based on log4cplus.
 *
 *
 */