sblog.cpp

OSB-PIK-OpenVXI-3.0.0源代码 “中国XML论坛 - 专业的XML技术讨论区--XML在语音技术中的应用”

   // Write to each of the underlying listener streams
   for (VXIlogStream::STREAMS::iterator vi = stream->streams.begin( );
        vi != stream->streams.end( ); vi++) {
     SBlogStream *s = *vi;
     VXIulong nw = 0;
     VXIlogResult rc2 = s->Write (s, buffer, buflen, &nw);
     if (rc == VXIlog_RESULT_SUCCESS) {
       if (nw > *nwritten)
 	*nwritten = nw;
     } else if ((rc == VXIlog_RESULT_SUCCESS) || ((rc < 0) && (rc2 < rc)) ||
 	       ((rc > 0) && (rc2 > rc))) {
       rc = rc2;
     }
   }
 
   return rc;
 }
 
   
 /***********************************************************************/
 
 VXIlogResult SBlogControlDiagnosticTag(SBlogInterface *pThis,
                                        VXIunsigned tagID,
                                        VXIbool     state)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   return (me->ControlDiagnosticTag(tagID, state));
 }
 
 
 VXIlogResult SBlogRegisterErrorListener(SBlogInterface *pThis,
                                         SBlogErrorListener* alistener,
                                         void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogErrorCallbackData *info = new SBlogErrorCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterErrorListener(info));
 } 
 
 
 VXIlogResult SBlogUnregisterErrorListener(SBlogInterface *pThis,
                                           SBlogErrorListener* alistener,
                                           void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogErrorCallbackData info = { alistener, userdata };
   SBlogErrorCallbackData *p = me->UnregisterErrorListener(&info);
   if (p) delete p;
   return VXIlog_RESULT_SUCCESS;
 } 
 
 
 VXIlogResult SBlogRegisterDiagnosticListener(SBlogInterface *pThis,
                                              SBlogDiagnosticListener*alistener,
                                              void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogDiagCallbackData *info = new SBlogDiagCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterDiagnosticListener(info));
 } 
 
 VXIlogResult SBlogUnregisterDiagnosticListener(
                                      SBlogInterface *pThis,
                                      SBlogDiagnosticListener* alistener,
                                      void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogDiagCallbackData info = { alistener, userdata };
   SBlogDiagCallbackData *p = me->UnregisterDiagnosticListener(&info);
   if (p) delete p;
 
   return VXIlog_RESULT_SUCCESS;
 } 
 
 
 VXIlogResult SBlogRegisterEventListener(SBlogInterface *pThis,
                                         SBlogEventListener* alistener,
                                         void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogEventCallbackData *info = new SBlogEventCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterEventListener(info));
 } 
 
 
 VXIlogResult SBlogUnregisterEventListener(SBlogInterface *pThis,
                                           SBlogEventListener* alistener,
                                           void*  userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogEventCallbackData info = { alistener, userdata };
   SBlogEventCallbackData *p = me->UnregisterEventListener(&info);
   if (p) delete p;
 
   return VXIlog_RESULT_SUCCESS;
 } 
 
 
 VXIlogResult SBlogRegisterContentListener(SBlogInterface *pThis,
 					  SBlogContentListener* alistener,
 					  void* userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
   
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogContentCallbackData *info = new SBlogContentCallbackData;
   if (info == NULL) {
     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
  
   info->callback = alistener;
   info->userdata = userdata;
   return ( me->RegisterContentListener(info));
 } 
 
 
 VXIlogResult SBlogUnregisterContentListener(SBlogInterface *pThis,
 					    SBlogContentListener* alistener,
 					    void*  userdata)
 {
   if ((pThis == NULL) || (alistener == NULL))
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *) pThis; 
   SBlog *me = (SBlog *)temp->impl_;
   SBlogContentCallbackData info = { alistener, userdata };
   SBlogContentCallbackData *p = me->UnregisterContentListener(&info);
   if (p) delete p;
 
   return VXIlog_RESULT_SUCCESS;
 } 
 
 /**********************************************************************
 */
 
 SBLOG_API VXIint32 SBlogGetVersion(void)
 {
   return VXI_CURRENT_VERSION;
 }
 
 
 SBLOG_API const VXIchar* SBlogGetImplementationName(void)
 {
   static const VXIchar IMPLEMENTATION_NAME[] = COMPANY_DOMAIN L".SBlog";
   return IMPLEMENTATION_NAME;
 }
 
 
 SBLOG_API VXIbool SBlogDiagnosticIsEnabled(VXIlogInterface * pThis,
                                            VXIunsigned tagID)
 {
   if (pThis == NULL)
     return FALSE;
 
   myAPI *temp = (myAPI *) pThis;
   SBlog *me = (SBlog *) temp->impl_;
 
   if (!me->DiagnosticIsEnabled(tagID)) return FALSE;
   return TRUE;
 }
 
 
 SBLOG_API VXIlogResult SBlogDiagnostic(VXIlogInterface*        pThis,
                                        VXIunsigned             tagID,
                                        const VXIchar*          subtag,
                                        const VXIchar*          format,
                                        ...)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *) pThis;
   SBlog *me = (SBlog *) temp->impl_;
   va_list args;
   va_start(args, format);
 
   VXIlogResult ret = me->DiagnosticLog(tagID, subtag, format, args);
   va_end(args);
 
   return ret;
 }
 
 SBLOG_API VXIlogResult SBlogVDiagnostic(VXIlogInterface*        pThis,
                                         VXIunsigned             tagID,
                                         const VXIchar*          subtag,
                                         const VXIchar*          format,
                                         va_list                 vargs)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI *)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->DiagnosticLog(tagID, subtag, format, vargs);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogEvent(VXIlogInterface*        pThis,
                                   VXIunsigned             eventID,
                                   const VXIchar*          format,
                                   ...)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   va_list args;
   va_start(args, format);
   VXIlogResult ret = me->EventLog(eventID, format, args);
   va_end(args);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogVEvent(VXIlogInterface*        pThis,
                                    VXIunsigned             eventID,
                                    const VXIchar*          format,
                                    va_list                 vargs)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->EventLog(eventID, format, vargs);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogEventVector(VXIlogInterface*        pThis,
 					VXIunsigned             eventID,
 					const VXIVector*        keys,
 					const VXIVector*        values)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->EventLog(eventID, keys, values);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogError(VXIlogInterface*        pThis,
                                   const VXIchar*          moduleName,
                                   VXIunsigned             errorID,
                                   const VXIchar*          format,
                                   ...)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   va_list args;
   va_start(args, format);
   VXIlogResult ret = me->ErrorLog(moduleName, errorID, format, args);
   va_end(args);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogVError(VXIlogInterface*        pThis,
                                    const VXIchar*          moduleName,
                                    VXIunsigned             errorID,
                                    const VXIchar*          format,
                                    va_list                 vargs)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->ErrorLog(moduleName, errorID, format, vargs);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogContentOpen(VXIlogInterface*  pThis,
 					const VXIchar*    moduleName,
 					const VXIchar*    contentType,
 					VXIString**       logKey,
 					VXIString**       logValue,
 					VXIlogStream**    stream)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->ContentOpen(moduleName, contentType,
 				     logKey, logValue, stream);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogContentClose(VXIlogInterface* pThis,
 					 VXIlogStream**   stream)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->ContentClose(stream);
 
   return ret;
 }
 
 
 SBLOG_API VXIlogResult SBlogContentWrite(VXIlogInterface* pThis,
 					 const VXIbyte*   buffer,
 					 VXIulong         buflen,
 					 VXIulong*        nwritten,
 					 VXIlogStream*    stream)
 {
   if (pThis == NULL)
     return VXIlog_RESULT_INVALID_ARGUMENT;
 
   myAPI *temp = (myAPI*)pThis;
   SBlog *me = (SBlog *)temp->impl_;
   VXIlogResult ret = me->ContentWrite(buffer, buflen, nwritten, stream);
 
   return ret;
 }
 
 
 // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
 
 /**
  * Global platform initialization of SBlog
  *
  * @result VXIlogResult 0 on success
  */
 SBLOG_API VXIlogResult SBlogInit(void)
 {
   if (gblInitialized == true) {
     SBlog::GlobalError(SBLOG_ERR_ALREADY_INITIALIZED);
     return VXIlog_RESULT_FATAL_ERROR;
   }
 
   gblInitialized = true;
   return VXIlog_RESULT_SUCCESS;
 }
 
 
 /**
  * Global platform shutdown of Log
  *
  * @result VXIlogResult 0 on success
  */
 SBLOG_API VXIlogResult SBlogShutDown(void)
 {
   if (gblInitialized == false) {
     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
     return VXIlog_RESULT_FATAL_ERROR;
   }
 
   gblInitialized = false;
   return VXIlog_RESULT_SUCCESS;
 }
 
 
 /**
  * Create a new log service handle
  *
  * @result VXIlogResult 0 on success 
  */
 SBLOG_API VXIlogResult SBlogCreateResource(VXIlogInterface **log)
 {
   if (gblInitialized == false) {
     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
     return VXIlog_RESULT_FATAL_ERROR;
   }
 
   if (log == NULL) {
     SBlog::GlobalError(309, L"SBlog: SBlogCreateResource() requires a "
 		       L"non-NULL log interface pointer", NULL);
     return VXIlog_RESULT_INVALID_ARGUMENT;
   }
 
   myAPI *temp = new myAPI;
   if (temp == NULL) {
     SBlog::GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
   memset (temp, 0, sizeof (myAPI));
   
   SBlog *me = new SBlog(&temp->intf);
   if (me == NULL) {
     delete temp;
     SBlog::GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
     return VXIlog_RESULT_OUT_OF_MEMORY;
   }
   
   // Initialize the VXIlogInterface function pointers
   temp->intf.vxilog.GetVersion            = SBlogGetVersion;
   temp->intf.vxilog.GetImplementationName = SBlogGetImplementationName;
   temp->intf.vxilog.Error                 = SBlogError;
   temp->intf.vxilog.VError                = SBlogVError;
   temp->intf.vxilog.Diagnostic            = SBlogDiagnostic;
   temp->intf.vxilog.VDiagnostic           = SBlogVDiagnostic;
   temp->intf.vxilog.DiagnosticIsEnabled   = SBlogDiagnosticIsEnabled;
   temp->intf.vxilog.Event                 = SBlogEvent;
   temp->intf.vxilog.VEvent                = SBlogVEvent;
   temp->intf.vxilog.EventVector           = SBlogEventVector;
   temp->intf.vxilog.ContentOpen           = SBlogContentOpen;
   temp->intf.vxilog.ContentClose          = SBlogContentClose;
   temp->intf.vxilog.ContentWrite          = SBlogContentWrite;
   
   // Initialize the SBlogInterface functions
   temp->intf.RegisterErrorListener = SBlogRegisterErrorListener;
   temp->intf.UnregisterErrorListener = SBlogUnregisterErrorListener;
   temp->intf.RegisterDiagnosticListener = SBlogRegisterDiagnosticListener;
   temp->intf.UnregisterDiagnosticListener = SBlogUnregisterDiagnosticListener;
   temp->intf.RegisterEventListener = SBlogRegisterEventListener;
   temp->intf.UnregisterEventListener = SBlogUnregisterEventListener;
   temp->intf.RegisterContentListener = SBlogRegisterContentListener;
   temp->intf.UnregisterContentListener = SBlogUnregisterContentListener;
   temp->intf.ControlDiagnosticTag = SBlogControlDiagnosticTag;
   temp->impl_ = (void*)me;
 
   // Return the object
   *log = &temp->intf.vxilog;
   return VXIlog_RESULT_SUCCESS;
 }
 
 
 /**
  * Destroy the interface and free internal resources
  *
  * @result VXIlogResult 0 on success 
  */
 SBLOG_API VXIlogResult SBlogDestroyResource(VXIlogInterface **log)
 {
   if (gblInitialized == false) {
     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
     return VXIlog_RESULT_FATAL_ERROR;
   }
 
   if ((log == NULL) || (*log == NULL)) {
     SBlog::GlobalError(310, L"SBlog: SBlogDestroyResource() requires a "
 		       L"non-NULL log interface pointer", NULL);
     return VXIlog_RESULT_INVALID_ARGUMENT;
   }
 
   // Delete the object
   myAPI *temp = (myAPI *) *log;
   SBlog *me = (SBlog *)temp->impl_;
   if (me) delete me;
   if (temp) delete temp;
   *log = NULL;
 
   return VXIlog_RESULT_SUCCESS;
 }