rollingpolicy.h - Log4c rolling policy interface. Defines the interface for managing and providing

       Generated automatically by Doxygen for log4c from the source code.

log4c                                             Version 1.2.4                               rollingpolicy.h(3)

       Log4c rolling policy interface. Defines the interface for managing and providing rolling policies.

       A rolling policy is used to confogure a rollingfile appender to tell it when to trigger a rolover event.

intlog4c_rollingpolicy_fini(log4c_rollingpolicy_t*policyp)
       Call  the  un  initialization code of a rolling policy. This will call the fini routine of the particular
       rollingpolicy type to allow it to free up resources. If the call to fini in the rollingpolicy type  fails
       then the rollingpolicy is not uninitialized. Try again later model...
       Parameterspolicyp pointer to the rolling policy
       Returns
           zero if successful, non-zero otherwise.
   log4c_rollingpolicy_t*log4c_rollingpolicy_get(constchar*policy_name)
       Get a new rolling policy
       Parameterspolicy_name a name for the policy
       Returns
           a new rolling policy, otherwise NULL.
   rollingfile_udata_t*log4c_rollingpolicy_get_rfudata(constlog4c_rollingpolicy_t*policyp)
       Get the rollingfile appender associated with this policy.
       Parameterspolicyp pointer to the rolling policy
       Returns
           pointer to the rolling file appender associated with this policy
   void*log4c_rollingpolicy_get_udata(constlog4c_rollingpolicy_t*policyp)
       Get the rolling policy configuration.
       Parameterspolicyp pointer to the rolling policy
       Returns
           pointer to the rolling policy configuration.
   intlog4c_rollingpolicy_init(log4c_rollingpolicy_t*policyp,rollingfile_udata_t*rfup)
       Call the initialization code of a rolling policy.
       Parameterspolicyp pointer to the rolling policy
           rfup the rolling appender user data this policy is used with
       Returns
           zero if successful, non-zero otherwise.
   intlog4c_rollingpolicy_is_triggering_event(log4c_rollingpolicy_t*policyp,constlog4c_logging_event_t*evtp,longcurrent_file_size)
       Determine if a logging event should trigger a rollover according to the given policy.
       Parameterspolicyp pointer to the rolling policy
           evtp the logging event pointer.
           current_file_size the size of the current file being logged to.
       Returns
           non-zero if rollover required, zero otherwise.
   constlog4c_rollingpolicy_type_t*log4c_rollingpolicy_set_type(log4c_rollingpolicy_t*a_rollingpolicy,constlog4c_rollingpolicy_type_t*a_type)
       sets the rolling policy type
       Parametersa_rollingpolicy the log4c_rollingpolicy_t object
           a_type the new rollingpolicy type
       Returns
           the previous appender type
   voidlog4c_rollingpolicy_set_udata(log4c_rollingpolicy_t*policyp,void*udatap)
       Configure a rolling policy with a specific policy.
       Parameterspolicyp pointer to the rolling policy
           udatap a specific policy type, for example sizewin.
       Returns
           zero if successful, non-zero otherwise.
   constlog4c_rollingpolicy_type_t*log4c_rollingpolicy_type_get(constchar*a_name)
       Get a pointer to an existing rollingpolicy type.
       Parametersa_name the name of the rollingpolicy type to return.

       Returns
           a pointer to an existing rollingpolicy type, or NULL if no rollingpolicy type with the specified name
           exists.
   constlog4c_rollingpolicy_type_t*log4c_rollingpolicy_type_set(constlog4c_rollingpolicy_type_t*a_type)
       Use  this  function  to register a rollingpolicy type with log4c. Once this is done you may refer to this
       type by name both programmatically and in the log4c configuration file.
       Parametersa_type a pointer to the new rollingpolicy type to register.
       Returns
           a pointer to the previous rollingpolicy type of same name.
       Example code fragment:
       const log4c_rollingpolicy_type_t log4c_rollingpolicy_type_sizewin = {
         "sizewin",
         sizewin_init,
         sizewin_is_triggering_event,
         sizewin_rollover
       };

       log4c_rollingpolicy_type_set(&log4c_rollingpolicy_type_sizewin);

#defineROLLINGPOLICY_ROLLOVER_ERR_CAN_LOG0x05
       Effect a rollover according to policyp on the given file stream.

       Parameterspolicyp pointer to the rolling policy
           fp filestream to rollover.

       Returns
           zero if successful, non-zero otherwise. The policy can return an indication that something went wrong
           but that the rollingfile appender can stull go ahead and log by returning an error code <=
           ROLLINGPOLICY_ROLLOVER_ERR_CAN_LOG. Anything greater than means that the rolling file appender will
           not try to log it's message.

       rollingpolicy.h - Log4c rolling policy interface. Defines the interface for managing and providing
       rolling policies.

       #include <stdio.h>
       #include <log4c/defs.h>
       #include <log4c/layout.h>

   DataStructures
       struct log4c_rollingpolicy_type
           log4c rollingpolicy type. Defines the interface a specific policy must provide to the rollingfile
           appender.

   Macros
       #define ROLLINGPOLICY_ROLLOVER_ERR_CAN_LOG   0x05

   Typedefs
       typedef struct __log4c_rollingpolicy log4c_rollingpolicy_t
       typedef struct log4c_rollingpolicy_typelog4c_rollingpolicy_type_t
           log4c rollingpolicy type. Defines the interface a specific policy must provide to the rollingfile
           appender.

   Functionslog4c_rollingpolicy_t * log4c_rollingpolicy_get (const char *policy_name)
       const log4c_rollingpolicy_type_t * log4c_rollingpolicy_type_set (const log4c_rollingpolicy_type_t
           *a_type)
       void log4c_rollingpolicy_set_udata (log4c_rollingpolicy_t *policyp, void *udatap)
       int log4c_rollingpolicy_init (log4c_rollingpolicy_t *policyp, rollingfile_udata_t *rfup)
       int log4c_rollingpolicy_fini (log4c_rollingpolicy_t *policyp)
       int log4c_rollingpolicy_is_triggering_event (log4c_rollingpolicy_t *policyp, const log4c_logging_event_t
           *evtp, long current_file_size)
       const log4c_rollingpolicy_type_t * log4c_rollingpolicy_set_type (log4c_rollingpolicy_t *a_rollingpolicy,
           const log4c_rollingpolicy_type_t *a_type)
       const log4c_rollingpolicy_type_t * log4c_rollingpolicy_type_get (const char *a_name)
       void * log4c_rollingpolicy_get_udata (const log4c_rollingpolicy_t *policyp)
       rollingfile_udata_t * log4c_rollingpolicy_get_rfudata (const log4c_rollingpolicy_t *policyp)

typedefstruct__log4c_rollingpolicylog4c_rollingpolicy_t
       log4c rollingpolicy type

   typedefstructlog4c_rollingpolicy_typelog4c_rollingpolicy_type_t
       log4c rollingpolicy type. Defines the interface a specific policy must provide to the rollingfile
       appender. Attributes description:

       •
        name rollingpolicy type name
       •
        init() init the rollingpolicy
       •
        is_triggering_event()
       •
        rollover()