letter P at the end of the name.  There are now two macros to help generate
log messages with the contextual information of file, line and function:

CASTOR_DLF_WRITEC
CASTOR_DLF_WRITECP

The first macro logs a message without parameters accept for the three
contextual ones of file, line and function.  The second macro logs a message
with parameters to which the three contextual ones are prepended.

The meaning of the letter C at the end of the CASTOR_DLF_WRITEC is 'C'onextual
log.  The meaning iof the letter P at the end of CASTOR_DLF_WRITECP is with
'P'arameters.

This macro should be used when it is desirable to include the file, line and
function context information in a log.  It is advised to include such
information when logging an error for the developers, but not to use it for
monitoring logs where operators are informed of what is happening and they do
not need or want to know the details of the source code.

The CASTOR_DLF_WRITEPC macro macro generates the file, line and function
context information automatically and passes it on down the DLF logging chain.
This means developers do not need to use the __FILE__, __LINE__,
__PRETTY_FUNCTION__ macros in their application code when logging.  Here is an
example of using this macro:

  try {
    ...
  } catch(castor::exception::Exception &ex) {
    castor::dlf::Param params[] = {
      castor::dlf::Param("volReqId", vdqmJobRequest.tapeRequestId),
      castor::dlf::Param("Message" , ex.getMessage().str()       ),
      castor::dlf::Param("Code"    , ex.code()                   )};
    CASTOR_DLF_WRITEPC(cuuid, DLF_LVL_ERROR, AGGREGATOR_MAIN_SELECT_FAILED,
      params);
  }

function in order to allow developers to call the function without the need to
specify the size of the params array:

    template<int n>
      void dlf_writep (Cuuid_t uuid,
                       int severity,
                       int message_no,
                       castor::dlf::Param (&params)[n],
                       struct Cns_fileid *ns_invariant = 0) throw() {
      dlf_writep(uuid, severity, message_no, n, params, 0);
    }

The template causes the size of the array to be determied at compile time.  A
pointer to castor::dlf::Param will of course not work.  The original
castor::dlf::dlf_writep function can be used as usual in this case.

The following code snippet shows an example of using the new template:

  castor::dlf::Param params[] = {
    castor::dlf::Param("volReqId", vdqmJobRequest.tapeRequestId),
    castor::dlf::Param("vid"     , request.vid                 ),
    castor::dlf::Param("vsn"     , request.vsn                 ),
    castor::dlf::Param("label"   , request.label               ),
    castor::dlf::Param("devtype" , request.devtype             ),
    castor::dlf::Param("density" , request.density             )};
        castor::dlf::dlf_writep(cuuid, DLF_LVL_SYSTEM,
          AGGREGATOR_GAVE_VOLUME_INFO, params);

Use ::dlf_isinitialized instead of our own version so that it works also when DLF is initialized from C

Improved logging into DLF. You can now declare new messages even before DLF was initialized. Very useful for libraries loaded before the main is called \!

C++ interface to DLF. This is supposed to replace the current logging facility without loosing the possibility to give objects to the interface.