This file is indexed.

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

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
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
// Module:  Log4CPLUS
// File:    Layout.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.

/** @file */

#ifndef _LOG4CPLUS_LAYOUT_HEADER_
#define _LOG4CPLUS_LAYOUT_HEADER_

#include "dcmtk/oflog/config.h"
#include "dcmtk/oflog/loglevel.h"
#include "dcmtk/oflog/streams.h"
#include "dcmtk/oflog/tstring.h"
#include "dcmtk/oflog/helpers/lloguser.h"
#include "dcmtk/oflog/helpers/property.h"
#include "dcmtk/oflog/helpers/timehelp.h"
#include "dcmtk/oflog/spi/logevent.h"

//#include <vector>


namespace log4cplus {

    // Forward Declarations
    namespace pattern {
        class PatternConverter;
    }


    /**
     * This class is used to layout strings sent to an {@link
     * log4cplus::Appender}.
     */
    class LOG4CPLUS_EXPORT Layout : protected :: log4cplus::helpers::LogLogUser {
    public:
        Layout() : llmCache(getLogLevelManager()) {}
        Layout(const log4cplus::helpers::Properties&)
          : llmCache(getLogLevelManager())  {}
        virtual ~Layout() {}

        virtual void formatAndAppend(log4cplus::tostream& output,
                                     const log4cplus::spi::InternalLoggingEvent& event) = 0;
    protected:
        LogLevelManager& llmCache;

    private:
      // Disable copy
        Layout(const Layout&);
        Layout& operator=(Layout&);
    };



    /**
     * SimpleLayout consists of the LogLevel of the log statement,
     * followed by " - " and then the log message itself. For example,
     *
     * <pre>
     *         DEBUG - Hello world
     * </pre>
     *
     * {@link PatternLayout} offers a much more powerful alternative.
     */
    class LOG4CPLUS_EXPORT SimpleLayout : public Layout {
    public:
        SimpleLayout() {}
        SimpleLayout(const log4cplus::helpers::Properties& properties, log4cplus::tstring&) : Layout(properties) {}

        virtual void formatAndAppend(log4cplus::tostream& output,
                                     const log4cplus::spi::InternalLoggingEvent& event);

    private:
      // Disallow copying of instances of this class
        SimpleLayout(const SimpleLayout&);
        SimpleLayout& operator=(const SimpleLayout&);
    };



    /**
     * TTCC layout format consists of time, thread, Logger and nested
     * diagnostic context information, hence the name.
     *
     * The time format depends on the <code>DateFormat</code> used.  Use the
     * <code>Use_gmtime</code> to specify whether messages should be logged using
     * <code>localtime</code> or <code>gmtime</code>.
     *
     * Here is an example TTCCLayout output:
     *
     * <pre>
     * 176 [main] INFO  org.apache.log4j.examples.Sort - Populating an array of 2 elements in reverse order.
     * 225 [main] INFO  org.apache.log4j.examples.SortAlgo - Entered the sort method.
     * 262 [main] DEBUG org.apache.log4j.examples.SortAlgo.OUTER i=1 - Outer loop.
     * 276 [main] DEBUG org.apache.log4j.examples.SortAlgo.SWAP i=1 j=0 - Swapping intArray[0] = 1 and intArray[1] = 0
     * 290 [main] DEBUG org.apache.log4j.examples.SortAlgo.OUTER i=0 - Outer loop.
     * 304 [main] INFO  org.apache.log4j.examples.SortAlgo.DUMP - Dump of interger array:
     * 317 [main] INFO  org.apache.log4j.examples.SortAlgo.DUMP - Element [0] = 0
     * 331 [main] INFO  org.apache.log4j.examples.SortAlgo.DUMP - Element [1] = 1
     * 343 [main] INFO  org.apache.log4j.examples.Sort - The next log statement should be an error message.
     * 346 [main] ERROR org.apache.log4j.examples.SortAlgo.DUMP - Tried to dump an uninitialized array.
     * 467 [main] INFO  org.apache.log4j.examples.Sort - Exiting main method.
     * </pre>
     *
     *  The first field is the number of milliseconds elapsed since the
     *  start of the program. The second field is the thread outputting the
     *  log statement. The third field is the LogLevel, the fourth field is
     *  the logger to which the statement belongs.
     *
     *  The fifth field (just before the '-') is the nested diagnostic
     *  context.  Note the nested diagnostic context may be empty as in the
     *  first two statements. The text after the '-' is the message of the
     *  statement.
     *
     *  PatternLayout offers a much more flexible alternative.
     */
    class LOG4CPLUS_EXPORT TTCCLayout : public Layout {
    public:
      // Ctor and dtor
        TTCCLayout(bool use_gmtime = false);
        TTCCLayout(const log4cplus::helpers::Properties& properties, log4cplus::tstring& error);
        virtual ~TTCCLayout();

        virtual void formatAndAppend(log4cplus::tostream& output,
                                     const log4cplus::spi::InternalLoggingEvent& event);

    protected:
       log4cplus::tstring dateFormat;
       bool use_gmtime;

    private:
      // Disallow copying of instances of this class
        TTCCLayout(const TTCCLayout&);
        TTCCLayout& operator=(const TTCCLayout&);
    };




    /**
     * A flexible layout configurable with pattern string.
     *
     * The goal of this class is to format a InternalLoggingEvent and return
     * the results as a string. The results depend on the <em>conversion
     * pattern</em>.
     *
     * The conversion pattern is closely related to the conversion
     * pattern of the printf function in C. A conversion pattern is
     * composed of literal text and format control expressions called
     * <em>conversion specifiers</em>.
     *
     * <i>You are free to insert any literal text within the conversion
     * pattern.</i>
     *
     * Each conversion specifier starts with a percent sign (%%) and is
     * followed by optional <em>format modifiers</em> and a <em>conversion
     * character</em>. The conversion character specifies the type of
     * data, e.g. Logger, LogLevel, date, thread name. The format
     * modifiers control such things as field width, padding, left and
     * right justification. The following is a simple example.
     *
     * Let the conversion pattern be <b>"%-5p [%t]: %m%n"</b> and assume
     * that the log4cplus environment was set to use a PatternLayout. Then the
     * statements
     * <pre>
     * Logger root = Logger.getRoot();
     * LOG4CPLUS_DEBUG(root, "Message 1");
     * LOG4CPLUS_WARN(root, "Message 2");
     * </pre>
     * would yield the output
     * <pre>
     * DEBUG [main]: Message 1
     * WARN  [main]: Message 2
     * </pre>
     *
     * Note that there is no explicit separator between text and
     * conversion specifiers. The pattern parser knows when it has reached
     * the end of a conversion specifier when it reads a conversion
     * character. In the example above the conversion specifier
     * <b>"%-5p"</b> means the LogLevel of the logging event should be left
     * justified to a width of five characters.
     *
     * The recognized conversion characters are
     *
     *
     * <table border="1" CELLPADDING="8">
     * <tr>
     * <td>Conversion Character</td>
     * <td>Effect</td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>c</b></td>
     *
     *   <td>Used to output the logger of the logging event. The
     *   logger conversion specifier can be optionally followed by
     *   <em>precision specifier</em>, that is a decimal constant in
     *   brackets.
     *
     *   If a precision specifier is given, then only the corresponding
     *   number of right most components of the logger name will be
     *   printed. By default the logger name is printed in full.
     *
     *   For example, for the logger name "a.b.c" the pattern
     *   <b>%c{2}</b> will output "b.c".
     *
     * </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>d</b></td>
     *
     *   <td>Used to output the date of the logging event in <b>UTC</b>.
     *
     *   The date conversion specifier may be followed by a <em>date format
     *   specifier</em> enclosed between braces. For example, <b>%%d{%%H:%%M:%%s}</b>
     *   or <b>%%d{%%d&nbsp;%%b&nbsp;%%Y&nbsp;%%H:%%M:%%s}</b>.  If no date format
     *   specifier is given then <b>%%d{%%d&nbsp;%%m&nbsp;%%Y&nbsp;%%H:%%M:%%s}</b>
     *   is assumed.
     *
     *   The Following format options are possible:
     *   <ul>
     *   <li>%%a -- Abbreviated weekday name</li>
     *   <li>%%A -- Full weekday name</li>
     *   <li>%%b -- Abbreviated month name</li>
     *   <li>%%B -- Full month name</li>
     *   <li>%%c -- Standard date and time string</li>
     *   <li>%%d -- Day of month as a decimal(1-31)</li>
     *   <li>%%H -- Hour(0-23)</li>
     *   <li>%%I -- Hour(1-12)</li>
     *   <li>%%j -- Day of year as a decimal(1-366)</li>
     *   <li>%%m -- Month as decimal(1-12)</li>
     *   <li>%%M -- Minute as decimal(0-59)</li>
     *   <li>%%p -- Locale's equivalent of AM or PM</li>
     *   <li>%%q -- milliseconds as decimal(0-999) -- <b>Log4CPLUS specific</b>
     *   <li>%%Q -- fractional milliseconds as decimal(0-999.999) -- <b>Log4CPLUS specific</b>
     *   <li>%%S -- Second as decimal(0-59)</li>
     *   <li>%%U -- Week of year, Sunday being first day(0-53)</li>
     *   <li>%%w -- Weekday as a decimal(0-6, Sunday being 0)</li>
     *   <li>%%W -- Week of year, Monday being first day(0-53)</li>
     *   <li>%%x -- Standard date string</li>
     *   <li>%%X -- Standard time string</li>
     *   <li>%%y -- Year in decimal without century(0-99)</li>
     *   <li>%%Y -- Year including century as decimal</li>
     *   <li>%%Z -- Time zone name</li>
     *   <li>%% -- The percent sign</li>
     *   </ul>
     *
     *   Lookup the documentation for the <code>strftime()</code> function
     *   found in the <code>&lt;ctime&gt;</code> header for more information.
     * </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>D</b></td>
     *
     *   <td>Used to output the date of the logging event in <b>local</b> time.
     *
     *   All of the above information applies.
     * </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>f</b></td>
     *
     *   <td>Used to output the function name where the logging request was
     *   issued.
     *
     * </tr>
     *
     * <tr>
     *   <td align=center><b>F</b></td>
     *
     *   <td>Used to output the file name where the logging request was
     *   issued.
     *
     *   <b>NOTE</b> Unlike log4j, there is no performance penalty for
     *   calling this method.
     *
     * </tr>
     *
     * <tr>
     *   <td align=center><b>h</b></td>
     *
     *   <td>Used to output the hostname of this system (as returned
     *   by gethostname(2)).
     *
     *   <b>NOTE</b> The hostname is only retrieved once at
     *   initialization.
     *
     * </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>H</b></td>
     *
     *   <td>Used to output the fully-qualified domain name of this
     *   system (as returned by gethostbyname(2) for the hostname
     *   returned by gethostname(2)).
     *
     *   <b>NOTE</b> The hostname is only retrieved once at
     *   initialization.
     *
     * </td>
     * </tr>
     *
     * <tr>
     * <td align=center><b>l</b></td>
     *
     *   <td>Equivalent to using "%F:%L"
     *
     *   <b>NOTE:</b> Unlike log4j, there is no performance penalty for
     *   calling this method.
     *
     * </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>L</b></td>
     *
     *   <td>Used to output the line number from where the logging request
     *   was issued.
     *
     *   <b>NOTE:</b> Unlike log4j, there is no performance penalty for
     *   calling this method.
     *
     * </tr>
     *
     *
     * <tr>
     *   <td align=center><b>m</b></td>
     *   <td>Used to output the application supplied message associated with
     *   the logging event.</td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>n</b></td>
     *
     *   <td>Outputs the platform dependent line separator character or
     *   characters.
     * </tr>
     *
     * <tr>
     *   <td align=center><b>p</b></td>
     *   <td>Used to output the LogLevel of the logging event.</td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>P</b></td>
     *
     *   <td>Used to output the first character of the LogLevel only.
     *      <b>NOTE:</b> This pattern has been added to log4cplus.
     *    </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>t</b></td>
     *
     *   <td>Used to output the name of the thread that generated the
     *   logging event.</td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>i</b></td>
     *
     *   <td>Used to output the process ID of the process that generated the
     *   logging event.</td>
     * </tr>
     *
     * <tr>
     *
     *   <td align=center><b>x</b></td>
     *
     *   <td>Used to output the NDC (nested diagnostic context) associated
     *   with the thread that generated the logging event.
     *   </td>
     * </tr>
     *
     * <tr>
     *   <td align=center><b>"%%"</b></td>
     *   <td>The sequence "%%" outputs a single percent sign.
     *   </td>
     * </tr>
     *
     * </table>
     *
     * By default the relevant information is output as is. However,
     * with the aid of format modifiers it is possible to change the
     * minimum field width, the maximum field width and justification.
     *
     * The optional format modifier is placed between the percent sign
     * and the conversion character.
     *
     * The first optional format modifier is the <em>left justification
     * flag</em> which is just the minus (-) character. Then comes the
     * optional <em>minimum field width</em> modifier. This is a decimal
     * constant that represents the minimum number of characters to
     * output. If the data item requires fewer characters, it is padded on
     * either the left or the right until the minimum width is
     * reached. The default is to pad on the left (right justify) but you
     * can specify right padding with the left justification flag. The
     * padding character is space. If the data item is larger than the
     * minimum field width, the field is expanded to accommodate the
     * data. The value is never truncated.
     *
     * This behavior can be changed using the <em>maximum field
     * width</em> modifier which is designated by a period followed by a
     * decimal constant. If the data item is longer than the maximum
     * field, then the extra characters are removed from the
     * <em>beginning</em> of the data item and not from the end. For
     * example, it the maximum field width is eight and the data item is
     * ten characters long, then the first two characters of the data item
     * are dropped. This behavior deviates from the printf function in C
     * where truncation is done from the end.
     *
     * Below are various format modifier examples for the logger
     * conversion specifier.
     *
     *
     * <TABLE BORDER=1 CELLPADDING=8>
     * <tr>
     * <td>Format modifier</td>
     * <td>left justify</td>
     * <td>minimum width</td>
     * <td>maximum width</td>
     * <td>comment</td>
     * </tr>
     *
     * <tr>
     * <td align=center>%20c</td>
     * <td align=center>false</td>
     * <td align=center>20</td>
     * <td align=center>none</td>
     *
     * <td>Left pad with spaces if the logger name is less than 20
     * characters long.
     * </tr>
     *
     * <tr> <td align=center>%-20c</td> <td align=center>true</td> <td
     * align=center>20</td> <td align=center>none</td> <td>Right pad with
     * spaces if the logger name is less than 20 characters long.
     * </tr>
     *
     * <tr>
     * <td align=center>%.30c</td>
     * <td align=center>NA</td>
     * <td align=center>none</td>
     * <td align=center>30</td>
     *
     * <td>Truncate from the beginning if the logger name is longer than 30
     * characters.
     * </tr>
     *
     * <tr>
     * <td align=center>%20.30c</td>
     * <td align=center>false</td>
     * <td align=center>20</td>
     * <td align=center>30</td>
     *
     * <td>Left pad with spaces if the logger name is shorter than 20
     * characters. However, if logger name is longer than 30 characters,
     * then truncate from the beginning.
     * </tr>
     *
     * <tr>
     * <td align=center>%-20.30c</td>
     * <td align=center>true</td>
     * <td align=center>20</td>
     * <td align=center>30</td>
     *
     * <td>Right pad with spaces if the logger name is shorter than 20
     * characters. However, if logger name is longer than 30 characters,
     * then truncate from the beginning.
     * </tr>
     *
     * </table>
     *
     * Below are some examples of conversion patterns.
     *
     * <dl>
     *
     * <dt><b>"%r [%t] %-5p %c %x - %m%n"</b>
     * <dd>This is essentially the TTCC layout.
     *
     * <dt><b>"%-6r [%15.15t] %-5p %30.30c %x - %m%n"</b>
     *
     * <dd>Similar to the TTCC layout except that the relative time is
     * right padded if less than 6 digits, thread name is right padded if
     * less than 15 characters and truncated if longer and the logger
     * name is left padded if shorter than 30 characters and truncated if
     * longer.
     *
     * </dl>
     *
     * The above text is largely inspired from Peter A. Darnell and
     * Philip E. Margolis' highly recommended book "C -- a Software
     * Engineering Approach", ISBN 0-387-97389-3.
     */
    class LOG4CPLUS_EXPORT PatternLayout : public Layout {
    public:
      // Ctors and dtor
        PatternLayout(const log4cplus::tstring& pattern, bool formatEachLine = true);
        PatternLayout(const log4cplus::helpers::Properties& properties, log4cplus::tstring& error);
        virtual ~PatternLayout();

        virtual void formatAndAppend(log4cplus::tostream& output,
                                     const log4cplus::spi::InternalLoggingEvent& event);

    protected:
        void init(const log4cplus::tstring& pattern, bool formatEachLine);

      // Data
        log4cplus::tstring pattern;
        bool formatEachLine;
        OFauto_ptr<OFList<pattern::PatternConverter*> > parsedPattern;

    private:
      // Disallow copying of instances of this class
        PatternLayout(const PatternLayout&);
        PatternLayout& operator=(const PatternLayout&);
    };



} // end namespace log4cplus

#endif // _LOG4CPLUS_LAYOUT_HEADER_