sblog.h

sloedgy open sip stack source code

 /**
  ** @name SBlog Interface
  ** @memo SBlog extension interface to the VXIlog interface.
  ** @doc  SBlog defines extensions to the VXIlog interface that support
  ** the tag mechanism and the listener registration 
  */
 typedef struct SBlogInterface
 {
   /** 
    ** Base interface, must appear first
    */
   VXIlogInterface vxilog;
   
   /**
   ** @name RegisterErrorListener
   ** @memo Subscribe the given listener for errors.
   ** @doc  The given listener will be notified for all errors (via
   ** VXIlog::Error or VError calls) as each calls is processed by
   ** SBlog. The call cannot be disabled.
   **
   ** @param alistener   [IN] Subscribing listener 
   ** @param userdata    [IN] User data that will be returned to the 
   **                         listener when notification occurs.
   **                         Note: the same listener may be 
   **                         registered multiple times, as long
   **                         as unique userdata is passed. In this
   **                         case, the listener will be called once
   **                         for each unique userdata.
   ** 
   ** @return    VXIlog_RESULT_SUCCESS:       success
   ** @return    VXIlog_RESULT_SYSTEM_ERROR:  internal error
   **
   */
   VXIlogResult (*RegisterErrorListener)(
     struct SBlogInterface *pThis,
     SBlogErrorListener    *alistener,   /* in */
     void                  *userdata);   /* in */
 
   /**
   ** @name UnregisterErrorListener
   ** @memo Unsubscribes the given listener.
   ** @doc  Unsubscribes the given listener/userdata combination.
   **
   ** @param alistener  [IN] The subscribing listener 
   ** @param userdata   [IN] User data that was passed in during registration.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   */
   VXIlogResult (*UnregisterErrorListener)(
     struct SBlogInterface *pThis,
     SBlogErrorListener    *alistener,  /* in */
     void                  *userdata);  /* in */
 
   /**
   ** @name RegisterDiagonsticListener
   ** @memo Subscribe the given listener for a diagnostic message.
   ** @doc  The given listener will be notified for all diagnostic
   ** messages (via VXIlog::Diagnostic or VDiagnostic calls) as each
   ** calls is processed by SBlog. The set of Diagnostics that are
   ** returned is controlled by ControlDiagnosticTag to either true or
   ** false.  By default all tags are assumed to be false when the
   ** listener is registered, and therefore off. A tag must be
   ** specifically turned to true (enabled) before any callbacks will
   ** be generated.  If a tag is enabled, all callbacks that registered
   ** on a given SBlog interface will be invoked. Generally, only one
   ** callback will be registered on each interface.
   **
   ** @param alistener  [IN] Subscribing listener 
   ** @param userdata   [IN] User data that will be returned to the 
   **                        listener when notification occurs.
   **                        Note: the same listener may be 
   **                        registered multiple times, as long
   **                        as unique userdata is passed. In this
   **                        case, the listener will be called once
   **                        for each unique userdata.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   ** 
   */
   VXIlogResult (*RegisterDiagnosticListener)(
     struct SBlogInterface   *pThis,
     SBlogDiagnosticListener *alistener,  /* in */
     void                    *userdata);  /* in */
 
   /**
   ** @name UnregisterDiagnosticListener
   ** @memo Unsubscribes the given listener.
   ** @doc  Unsubscribes the given listener/userdata combination.
   **
   ** @param alistener  [IN] The subscribing listener 
   ** @param userdata   [IN] User data that was passed in during registration.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   */
   VXIlogResult (*UnregisterDiagnosticListener)(
     struct SBlogInterface    *pThis,
     SBlogDiagnosticListener  *alistener,    /* in */
     void                     *userdata);    /* in */
 
   /**
   ** @name ControlDiagnosticTag
   ** @memo Turn the diagnostic tag on (true) or off (false).
   ** @doc  All diagnostic log tags are assumed to be off unless
   ** specifically enabled.  This must be done by calling this function
   ** and setting the given tag to true.
   **
   ** @param  tagID    [IN] Identifier that classifies a group of logically
   **                  associated diagnostic messages (usually from a single
   **                  software module) that are desirable to enable or
   **                  disable as a single unit. See the top of this file 
   **                  for tagID allocation rules.
   ** @param  state    [IN] Boolean flag to turn the tag on (TRUE) or
   **                  off (FALSE).
   **
   ** @return   VXIlog_RESULT_SUCCESS:      success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR: internal error
   **
   */
   VXIlogResult (*ControlDiagnosticTag)(
     struct SBlogInterface *pThis,
     VXIunsigned            tagID,
     VXIbool                state);
 
   /**
   ** @name RegisterEventListener
   ** @memo Subscribe the given listener for events.
   ** @doc  The given listener will be notified for all events (via
   ** VXIlog::Event or VEvent calls) as each calls is processed by
   ** SBlog. The call cannot be disabled.
   **
   ** @param alistener  [IN] Subscribing listener 
   ** @param userdata   [IN] User data that will be returned to the 
   **                        listener when notification occurs.
   **                        Note: the same listener may be 
   **                        registered multiple times, as long
   **                        as unique userdata is passed. In this
   **                        case, the listener will be called once
   **                        for each unique userdata.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   **
   */
   VXIlogResult (*RegisterEventListener)(
     struct SBlogInterface *pThis,
     SBlogEventListener    *alistener,   /* in */
     void                  *userdata);   /* in */
 
   /**
   ** @name UnregisterEventListener
   ** @memo Unsubscribes the given listener.
   ** @doc  Unsubscribes the given listener/userdata combination.
   **
   ** @param alistener  [IN] The subscribing listener 
   ** @param userdata   [IN] User data that was passed in during registration.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   */
   VXIlogResult (*UnregisterEventListener)(
     struct SBlogInterface  *pThis,
     SBlogEventListener     *alistener,  /* in */
     void                   *userdata);  /* in */
 
   /**
   ** @name RegisterContentListener
   ** @memo Subscribe the given listener for content write requests
   ** @doc  The given listener will be notified for all content write
   ** requests (via VXIlog::ContentOpen( ) calls) as each request is 
   ** processed by SBlog. The call cannot be disabled.
   **
   ** @param alistener  [IN] Subscribing listener 
   ** @param userdata   [IN] User data that will be returned to the 
   **                        listener when notification occurs.
   **                        Note: the same listener may be 
   **                        registered multiple times, as long
   **                        as unique userdata is passed. In this
   **                        case, the listener will be called once
   **                        for each unique userdata.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   **
   */
   VXIlogResult (*RegisterContentListener)(
     struct SBlogInterface *pThis,
     SBlogContentListener  *alistener,   /* in */
     void                  *userdata);   /* in */
 
   /**
   ** @name UnregisterContentListener
   ** @memo Unsubscribes the given listener.
   ** @doc  Unsubscribes the given listener/userdata combination.
   **
   ** @param alistener  [IN] The subscribing listener 
   ** @param userdata   [IN] User data that was passed in during registration.
   ** 
   ** @return   VXIlog_RESULT_SUCCESS:       success
   ** @return   VXIlog_RESULT_SYSTEM_ERROR:  internal error
   */
   VXIlogResult (*UnregisterContentListener)(
     struct SBlogInterface  *pThis,
     SBlogContentListener   *alistener,  /* in */
     void                   *userdata);  /* in */
 
 } SBlogInterface;
 
 
 /**
  * Global platform initialization of SBlog
  *
  * @result VXIlog_RESULT_SUCCESS on success
  */
 SBLOG_API VXIlogResult SBlogInit(void);
 
 /**
  * Global platform shutdown of Log
  *
  * @result VXIlog_RESULT_SUCCESS on success
  */
 SBLOG_API VXIlogResult SBlogShutDown(void);
 
 /**
  * Create a new log service handle
  *
  * @result VXIlog_RESULT_SUCCESS on success 
  */
 SBLOG_API VXIlogResult SBlogCreateResource(VXIlogInterface **log);
 
 /**
  * Destroy the interface and free internal resources
  *
  * @result VXIlog_RESULT_SUCCESS on success 
  */
 SBLOG_API VXIlogResult SBlogDestroyResource(VXIlogInterface **log);
 
 /*@}*/
 
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
 
 #include "vxi/VXIheaderSuffix.h"
 
#endif

 #endif  /* include guard */