开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SBlog.cpp
资源名称：openvxi-3.4.zip　[点击查看]
上传用户：xqtpzdz
上传日期：2022-05-21
资源大小：1764k
文件大小：44k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SBlog.cpp：源码内容
  2. /****************License************************************************
  3.  * Vocalocity OpenVXI
  4.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  5.  * This program is free software; you can redistribute it and/or
  6.  * modify it under the terms of the GNU General Public License
  7.  * as published by the Free Software Foundation; either version 2
  8.  * of the License, or (at your option) any later version.
  9.  *  
  10.  * This program is distributed in the hope that it will be useful,
  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  * GNU General Public License for more details.
  14.  *
  15.  * You should have received a copy of the GNU General Public License
  16.  * along with this program; if not, write to the Free Software
  17.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  19.  * registered trademarks of Vocalocity, Inc. 
  20.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  21.  * by Vocalocity.
  22.  ***********************************************************************/
  24. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  26. #include "SBlogInternal.h"
  27. #include <cstring>                  // For memset()
  28. #include <ctime>                    // For time_t
  29. #include <vector>                   // For STL vector template class
  31. #define SBLOG_EXPORTS
  32. #include "SBlog.h"                  // Header for these functions
  33. #include "SBlogOSUtils.h"           // for SBlogGetTime(), SBlogVswprintf()
  35. #ifdef __THREADED
  36. #include "VXItrd.h"                 // for VXItrdMutex
  37. #endif
  39. static const VXIunsigned MAX_LOG_BUFFER  = 4096 * 2;
  40. static const VXIunsigned TAG_ARRAY_SIZE = (((SBLOG_MAX_TAG) + 1) / 8 + 1);
  42. #define SBLOG_ERR_OUT_OF_MEMORY 100, L"SBlog: Out of memory", NULL
  43. #define SBLOG_ERR_ALREADY_INITIALIZED 104, L"SBlog: Already initialized", NULL
  44. #define SBLOG_ERR_NOT_INITIALIZED 105, L"SBlog: Not initialized", NULL
  46. #ifndef MODULE_PREFIX
  47. #define MODULE_PREFIX  COMPANY_DOMAIN L"."
  48. #endif
  49. #define MODULE_NAME MODULE_PREFIX L"SBlog"
  51. // Global variable to track whether this is initialized
  52. static bool gblInitialized = false;
  55. struct myAPI {
  56.   SBlogInterface intf;
  57.   void *impl_;
  58. };
  61. struct SBlogErrorCallbackData {
  62.   SBlogErrorListener *callback;
  63.   void *userdata;
  64.   bool operator==(struct SBlogErrorCallbackData &other)
  65.   { return (callback == other.callback && userdata == other.userdata); }  
  66.   bool operator!=(struct SBlogErrorCallbackData &other)
  67.   { return !operator==(other); }
  68. };
  71. struct SBlogDiagCallbackData {
  72.   SBlogDiagnosticListener *callback;
  73.   void *userdata;
  74.   bool operator==(struct SBlogDiagCallbackData &other)
  75.   { return (callback == other.callback && userdata == other.userdata); }
  76.   bool operator!=(struct SBlogDiagCallbackData &other)
  77.   { return !operator==(other); }
  78. };
  81. struct SBlogEventCallbackData{
  82.   SBlogEventListener *callback;
  83.   void *userdata;
  84.   bool operator==(struct SBlogEventCallbackData &other)
  85.   { return (callback == other.callback && userdata == other.userdata); }
  86.   bool operator!=(struct SBlogEventCallbackData &other)
  87.   { return !operator==(other); }
  88. };
  91. struct SBlogContentCallbackData{
  92.   SBlogContentListener *callback;
  93.   void *userdata;
  94.   bool operator==(struct SBlogContentCallbackData &other)
  95.   { return (callback == other.callback && userdata == other.userdata); }
  96.   bool operator!=(struct SBlogContentCallbackData &other)
  97.   { return !operator==(other); }
  98. };
  101. // Our definition of the opaque VXIlogStream
  102. extern "C" {
  103. struct VXIlogStream {
  104.   // Linked list of underlying SBlogListener content streams
  105.   typedef std::vector<SBlogStream *> STREAMS;
  106.   STREAMS streams;
  107. };
  108. }
  111. class SBlog {
  112. public:
  113.   SBlog(SBlogInterface *pThis);
  114.   virtual ~SBlog();
  115.   
  116.   bool DiagnosticIsEnabled(VXIunsigned tagID);
  118.   VXIlogResult DiagnosticLog(VXIunsigned    tagID,
  119.                              const VXIchar* subtag,
  120.                              const VXIchar* format,
  121.                              va_list arguments) const;
  122.   
  123.   VXIlogResult EventLog(VXIunsigned            eventID,
  124.                         const VXIchar*         format,
  125.                         va_list arguments) const;
  127.   VXIlogResult EventLog(VXIunsigned            eventID,
  128.                         const VXIVector*       keys,
  129. const VXIVector*       values) const;
  131.   VXIlogResult ErrorLog(const VXIchar*         moduleName,
  132.                         VXIunsigned            errorID,
  133.                         const VXIchar*         format,
  134.                         va_list arguments) const;  
  136.   VXIlogResult ContentOpen(const VXIchar*      moduleName,
  137.    const VXIchar*      contentType,
  138.    VXIString**         logKey,
  139.    VXIString**         logValue,
  140.    VXIlogStream**      stream) const;
  142.   VXIlogResult ContentClose(VXIlogStream**     stream) const;
  144.   VXIlogResult ContentWrite(const VXIbyte*     buffer,
  145.     VXIulong           buflen,
  146.     VXIulong*          nwritten,
  147.     VXIlogStream*      stream) const;
  148.   
  149.   VXIlogResult ControlDiagnosticTag(VXIunsigned tagID,
  150.                                     VXIbool     state);
  152.   // ----- Register/Unregister callback functions
  153.   VXIlogResult RegisterErrorListener(SBlogErrorCallbackData *info);
  155.   SBlogErrorCallbackData*
  156.     UnregisterErrorListener(SBlogErrorCallbackData *info);
  157.   
  158.   VXIlogResult RegisterDiagnosticListener(SBlogDiagCallbackData *info);
  160.   SBlogDiagCallbackData*
  161.     UnregisterDiagnosticListener(SBlogDiagCallbackData *info);
  163.   VXIlogResult RegisterEventListener(SBlogEventCallbackData *info);
  165.   SBlogEventCallbackData*
  166.     UnregisterEventListener(SBlogEventCallbackData *info);  
  168.   VXIlogResult RegisterContentListener(SBlogContentCallbackData *info);
  170.   SBlogContentCallbackData*
  171.     UnregisterContentListener(SBlogContentCallbackData *info);  
  173.   // ----- Internal error logging functions
  174.   VXIlogResult Error(VXIunsigned errorID, const VXIchar *errorIDText,
  175.      const VXIchar *format, ...) const;
  176.   static VXIlogResult GlobalError(VXIunsigned errorID, 
  177.   const VXIchar *errorIDText,
  178.   const VXIchar *format, ...);
  180. private:
  181.   // Internal methods
  182.   static unsigned testbit(unsigned char num, int bitpos);
  183.   static void setbit(unsigned char *num, int bitpos);
  184.   static void clearbit(unsigned char *num, int bitpos);
  186.   bool Convert2Index(VXIunsigned tagID,
  187.      VXIunsigned *index, 
  188.      VXIunsigned *bit_pos) const;
  190.   VXIlogResult ParseKeyValue(const VXIchar *format,
  191.      va_list args,
  192.      VXIVector *keys,
  193.      VXIVector *values) const;
  194.   
  195. #ifdef __THREADED
  196.   inline bool Lock( ) const { 
  197.     bool rc = (VXItrdMutexLock(_callbackLock) == VXItrd_RESULT_SUCCESS); 
  198.     if (! rc) Error(102, L"SBlog: Mutex lock failed", NULL);
  199.     return rc;
  200.   }
  201.   inline bool Unlock( ) const {
  202.     bool rc = (VXItrdMutexUnlock(_callbackLock) == VXItrd_RESULT_SUCCESS); 
  203.     if (! rc) Error(103, L"SBlog: Mutex unlock failed", NULL);
  204.     return rc;
  205.   }
  206.   inline VXIthreadID GetThreadID( ) const {
  207.     return VXItrdThreadGetID();
  208.   }
  209. #else
  210.   inline bool Lock( ) const { return true; }
  211.   inline bool Unlock( ) const { return true; }
  212.   inline VXIthreadID GetThreadID( ) const { return (VXIthreadID) 1; }
  213. #endif
  215. private:
  216.   typedef std::vector<SBlogDiagCallbackData *> DIAGCALLBACKS;
  217.   DIAGCALLBACKS diagCallbacks;
  219.   typedef std::vector<SBlogErrorCallbackData *> ERRORCALLBACKS;
  220.   ERRORCALLBACKS errorCallbacks;
  222.   typedef std::vector<SBlogEventCallbackData *> EVENTCALLBACKS;
  223.   EVENTCALLBACKS eventCallbacks;
  225.   typedef std::vector<SBlogContentCallbackData *> CONTENTCALLBACKS;
  226.   CONTENTCALLBACKS contentCallbacks;
  228. #ifdef __THREADED
  229.   VXItrdMutex *_callbackLock;
  230.   VXItrdMutex *_internalErrorLoggingLock;
  231. #endif
  233.   SBlogInterface *_pThis;
  234.   VXIthreadID _internalErrorLoggingThread;
  235.   unsigned char _tagIDs[TAG_ARRAY_SIZE];
  236. };
  239. SBlog::SBlog(SBlogInterface *pThis) : 
  240. #ifdef __THREADED
  241.   _callbackLock(NULL), 
  242.   _internalErrorLoggingLock(NULL), 
  243. #endif
  244.   _pThis(pThis),
  245.   _internalErrorLoggingThread((VXIthreadID) -1)
  246. {
  247.   // reset TAG ID range
  248.   memset(_tagIDs, 0, TAG_ARRAY_SIZE);
  250. #ifdef __THREADED
  251.   // Create the mutexes
  252.   if ((VXItrdMutexCreate(&_callbackLock) != VXItrd_RESULT_SUCCESS) ||
  253.       (VXItrdMutexCreate(&_internalErrorLoggingLock) != VXItrd_RESULT_SUCCESS))
  254.     Error(101, L"OSBlog: Mutex create failed", NULL);
  255. #endif
  256. }
  259. SBlog::~SBlog() 
  260. {
  261. #ifdef __THREADED
  262.   // Destroy the mutexes
  263.   VXItrdMutexDestroy(&_callbackLock);
  264.   VXItrdMutexDestroy(&_internalErrorLoggingLock);
  265. #endif
  266. }
  268. /**
  269.  * testbit
  270.  * testbit returns the value of the given bit
  271.  * 1 is set, 0 is clear
  272.  */
  273. unsigned SBlog::testbit(unsigned char num, int bitpos)
  274. { 
  275.   return (num >> bitpos) & ~(~0 << 1); 
  276. }
  278. /**
  279.  * setbit sets a given bit
  280.  */
  281. void SBlog::setbit(unsigned char *num, int bitpos)
  282. {
  283.   *num |= (1 << bitpos);
  284. }
  286. /**
  287.  * clearbit clears a given bit
  288.  */
  289. void SBlog::clearbit(unsigned char *num, int bitpos)
  290. {
  291.   *num &= ~(1 << bitpos);
  292. }
  295. bool SBlog::Convert2Index(VXIunsigned tagID,
  296.   VXIunsigned *index, 
  297.   VXIunsigned *bit_pos) const
  298. {
  299.   // check for overflow TAG ID
  300.   if (tagID > SBLOG_MAX_TAG) {
  301.     Error(300, L"SBlog: Tag ID is too large", L"%s%u", L"tagID", tagID);
  302.     return false;
  303.   }
  305.   // retrieving index for char array
  306.   *index = tagID/8;  // 8 bits per char
  308.   // retrieving bit position (bit range from 0-7)
  309.   *bit_pos = tagID%8;
  311.   return true;  // done
  312. }
  315. VXIlogResult SBlog::ControlDiagnosticTag(VXIunsigned tagID,
  316.                                          VXIbool state)
  317. {
  318.   VXIunsigned bindex, bpos;
  319.   if(!Convert2Index(tagID, &bindex, &bpos))
  320.     return VXIlog_RESULT_INVALID_ARGUMENT;
  322.   if(state)
  323.     setbit(&_tagIDs[bindex], bpos);
  324.   else
  325.     clearbit(&_tagIDs[bindex], bpos);
  326.     
  327.   return VXIlog_RESULT_SUCCESS;
  328. }
  331. VXIlogResult SBlog::RegisterErrorListener(SBlogErrorCallbackData *info)
  332. {
  333.    if (info == NULL) {
  334.      Error(200, L"SBlog: Internal error in RegisterErrorListener(), NULL "
  335.    L"callback data", NULL);
  336.      return VXIlog_RESULT_INVALID_ARGUMENT;
  337.    }
  339.    if (! Lock( )) {
  340.      return VXIlog_RESULT_SYSTEM_ERROR;
  341.    } else {
  342.      errorCallbacks.push_back(info);
  344.      if (! Unlock( ))
  345.        return VXIlog_RESULT_SYSTEM_ERROR;
  346.    }
  348.    return VXIlog_RESULT_SUCCESS;  
  349. }
  352. SBlogErrorCallbackData*
  353. SBlog::UnregisterErrorListener(SBlogErrorCallbackData *info)
  354. {
  355.   if (info == NULL) {
  356.     Error(201, L"SBlog: Internal error in UnregisterErrorListener(), NULL "
  357.   L"callback data", NULL);
  358.     return NULL;
  359.   }
  361.   SBlogErrorCallbackData *status = NULL;
  362.   if (! Lock( )) {
  363.     return NULL;
  364.   } else {
  365.     for (ERRORCALLBACKS::iterator i = errorCallbacks.begin();
  366.  i != errorCallbacks.end(); ++i)
  367.       {
  368. if (*info != *(*i)) continue;
  369. status = *i;
  370. errorCallbacks.erase(i);
  371. break;
  372.       }
  374.     if (! Unlock( ))
  375.       return NULL;
  376.   }
  378.   return status; 
  379. }
  382. VXIlogResult SBlog::RegisterDiagnosticListener(SBlogDiagCallbackData *info)
  383. {
  384.    if (info == NULL) {
  385.      Error(202, L"SBlog: Internal error in RegisterDiagnosticListener(), NULL "
  386.    L"callback data", NULL);
  387.      return VXIlog_RESULT_INVALID_ARGUMENT;
  388.    }
  390.    if (! Lock( )) {
  391.      return VXIlog_RESULT_SYSTEM_ERROR;
  392.    } else {
  393.      diagCallbacks.push_back(info);
  395.      if (! Unlock( ))
  396.        return VXIlog_RESULT_SYSTEM_ERROR;
  397.    }
  399.    return VXIlog_RESULT_SUCCESS;  
  400. }
  403. SBlogDiagCallbackData*
  404. SBlog::UnregisterDiagnosticListener(SBlogDiagCallbackData *info)
  405. {
  406.   if (info == NULL) {
  407.     Error(203, L"SBlog: Internal error in UnregisterDiagnosticListener(), "
  408.   L"NULL callback data", NULL);
  409.     return NULL;
  410.   }
  412.   SBlogDiagCallbackData *status = NULL;
  413.   if (! Lock( )) {
  414.     return NULL;
  415.   } else {
  416.     for (DIAGCALLBACKS::iterator i = diagCallbacks.begin();
  417.  i != diagCallbacks.end(); ++i)
  418.       {
  419. if (*info != *(*i)) continue;
  420. status = *i;
  421. diagCallbacks.erase(i);
  422. break;
  423.       }
  425.     if (! Unlock( ))
  426.       return NULL;
  427.   }
  429.   return status; 
  430. }
  433. VXIlogResult SBlog::RegisterEventListener(SBlogEventCallbackData *info)
  434. {
  435.    if (info == NULL) {
  436.      Error(204, L"SBlog: Internal error in RegisterEventListener(), NULL "
  437.    L"callback data", NULL);
  438.      return VXIlog_RESULT_INVALID_ARGUMENT;
  439.    }
  441.    if (! Lock( )) {
  442.      return VXIlog_RESULT_SYSTEM_ERROR;
  443.    } else {
  444.      eventCallbacks.push_back(info);
  446.      if (! Unlock( ))
  447.        return VXIlog_RESULT_SYSTEM_ERROR;
  448.    }
  450.    return VXIlog_RESULT_SUCCESS;  
  451. }
  454. SBlogEventCallbackData*
  455. SBlog::UnregisterEventListener(SBlogEventCallbackData *info)
  456. {
  457.   if (info == NULL) {
  458.     Error(205, L"SBlog: Internal error in UnregisterEventListener(), NULL "
  459.   L"callback data", NULL);
  460.     return NULL;
  461.   }
  463.   SBlogEventCallbackData *status = NULL;
  464.   if (! Lock( )) {
  465.     return NULL;
  466.   } else {
  467.     for (EVENTCALLBACKS::iterator i = eventCallbacks.begin();
  468.  i != eventCallbacks.end(); ++i)
  469.       {
  470. if (*info != *(*i)) continue;
  471. status = *i;
  472. eventCallbacks.erase(i);
  473. break;
  474.       }
  475.     
  476.     if (! Unlock( ))
  477.       return NULL;
  478.   }
  480.   return status; 
  481. }
  484. VXIlogResult SBlog::RegisterContentListener(SBlogContentCallbackData *info)
  485. {
  486.    if (info == NULL) {
  487.      Error(206, L"SBlog: Internal error in RegisterContentListener(), NULL "
  488.   L"callback data", NULL);
  489.      return VXIlog_RESULT_INVALID_ARGUMENT;
  490.    }
  492.    if (! Lock( )) {
  493.      return VXIlog_RESULT_SYSTEM_ERROR;
  494.    } else {
  495.      contentCallbacks.push_back(info);
  497.      if (! Unlock( ))
  498.        return VXIlog_RESULT_SYSTEM_ERROR;
  499.    }
  501.    return VXIlog_RESULT_SUCCESS;  
  502. }
  505. SBlogContentCallbackData*
  506. SBlog::UnregisterContentListener(SBlogContentCallbackData *info)
  507. {
  508.   if (info == NULL) {
  509.     Error(207, L"SBlog: Internal error in RegisterContentListener(), NULL "
  510.   L"callback data", NULL);
  511.     return NULL;
  512.   }
  514.   SBlogContentCallbackData *status = NULL;
  515.   if (! Lock( )) {
  516.     return NULL;
  517.   } else {
  518.     for (CONTENTCALLBACKS::iterator i = contentCallbacks.begin();
  519.  i != contentCallbacks.end(); ++i)
  520.       {
  521. if (*info != *(*i)) continue;
  522. status = *i;
  523. contentCallbacks.erase(i);
  524. break;
  525.       }
  526.     
  527.     if (! Unlock( ))
  528.       return NULL;
  529.   }
  531.   return status; 
  532. }
  535. VXIlogResult SBlog::ParseKeyValue(const VXIchar *format,
  536.                                   va_list args,
  537.                                   VXIVector *keys,
  538.                                   VXIVector *values) const
  539. {
  540.   const VXIchar SEP[] = L"{*}";
  541.   const int SEP_LEN = 3;  
  542.   if (( format == NULL ) || ( keys == NULL ) || ( values == NULL )) {
  543.     Error(208, L"SBlog: Internal error in ParseKeyValue(), invalid argument",
  544.   NULL);
  545.     return VXIlog_RESULT_INVALID_ARGUMENT;
  546.   }
  548.   // Insert delimiters into a revised format string, this does
  549.   // validation as well as letting us split it into key/values later
  550.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  551.   bool hadFreeformText = false;
  552.   int replacementStart = -1, fieldCount = 0;
  553.   size_t resultFormatLen = 0;
  554.   VXIchar resultFormat[MAX_LOG_BUFFER];
  555.   resultFormat[0] = L'';
  557.   for (int i = 0; (format[i] != L'') && (rc == VXIlog_RESULT_SUCCESS); i++) {
  558.     if (format[i] == '%') {
  559.       if (replacementStart > -1)
  560. replacementStart = -1; // double %%
  561.       else
  562. replacementStart = i;
  563.     } else if ((replacementStart > -1) && (SBlogIsAlpha(format[i])) &&
  564.        (format[i] != L'l') && (format[i] != L'L') && 
  565.        (format[i] != L'h')) {
  566.       if ((fieldCount % 2 == 0) && (format[i] != L's') && 
  567.   (format[i] != L'S')) {
  568. // Keys must be a %s or %S, truncate from here
  569. Error(301, L"SBlog: Invalid format string for VXIlog API call, "
  570.       L"replacements for key names must be %s", L"%s%s", L"format",
  571.       format);
  572. rc = VXIlog_RESULT_NON_FATAL_ERROR;
  573.       } else {
  574. // Insert the replacement expression and the seperator
  575. size_t index = resultFormatLen;
  576. resultFormatLen += (i - replacementStart) + 1 + SEP_LEN;
  577. if (resultFormatLen < MAX_LOG_BUFFER) {
  578.   wcsncpy(&resultFormat[index], &format[replacementStart],
  579.   (i - replacementStart) + 1);
  580.   index += (i - replacementStart) + 1;
  581.   wcscpy(&resultFormat[index], SEP);
  582. } else {
  583.   // Overflow, truncate the format string from here
  584.   rc = VXIlog_RESULT_NON_FATAL_ERROR;
  585. }
  587. replacementStart = -1;
  588. fieldCount++;
  589.       }
  590.     } else if (replacementStart == -1) {
  591.       // Shouldn't have free-form text, skip it. Proceeding allows us
  592.       // to gracefully handle things like "%s0x%p".
  593.       hadFreeformText = true;
  594.     }
  595.   }
  597.   // if key/value is not even truncate the field and return an error,
  598.   // but proceed with the other fields. If there was free form text,
  599.   // we skipped it and return an error, but proceed with logging.
  600.   if (fieldCount % 2 != 0) {
  601.     Error(302, L"SBlog: Invalid format string for VXIlog API call, "
  602.   L"missing value for a key", L"%s%s", L"format", format);
  603.     rc = VXIlog_RESULT_NON_FATAL_ERROR;
  604.     fieldCount--;
  605.   } else if (hadFreeformText) {
  606.     Error(303, L"SBlog: Invalid format string for VXIlog API call, "
  607.   L"must be a list of format strings for key/value pairs", 
  608.   L"%s%s", L"format", format);
  609.     rc = VXIlog_RESULT_NON_FATAL_ERROR;
  610.   }
  612.   // get the values
  613.   VXIchar result[MAX_LOG_BUFFER];
  614.   result[0] = L'';
  615.   SBlogVswprintf(result, MAX_LOG_BUFFER-1, resultFormat, args);
  617.   // parse the key/value based on the inserted separators
  618.   long fieldNum = 0;
  619.   const VXIchar *start = result, *end;
  620.   while ((fieldNum < fieldCount) && ((end = wcsstr(start, SEP)) != NULL)) {
  621.     // Insert into key/value vector
  622.     fieldNum++;
  623.     if (fieldNum % 2) // odd is key
  624.       VXIVectorAddElement(keys,(VXIValue*)VXIStringCreateN(start,end-start));
  625.     else
  626.       VXIVectorAddElement(values,(VXIValue*)VXIStringCreateN(start,end-start));
  628.     // Advance
  629.     start = &end[SEP_LEN];
  630.   }
  632.   if (fieldNum != fieldCount) {
  633.     // parse error
  634.     Error(304, L"SBlog: Internal error, parse failure after key/value "
  635.   L"insertions", L"%s%s%s%s", L"format", format, L"result", result);
  636.     rc = VXIlog_RESULT_NON_FATAL_ERROR;
  637.   }
  639.   return rc;
  640. }
  643. VXIlogResult SBlog::Error(VXIunsigned errorID, const VXIchar *errorIDText,
  644.   const VXIchar *format, ...) const
  645. {
  646.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  648.   // Avoid recursively reporting logging errors
  649.   if (_internalErrorLoggingThread == GetThreadID())
  650.     return VXIlog_RESULT_FAILURE;
  652.   if (VXItrdMutexLock(_internalErrorLoggingLock) != VXItrd_RESULT_SUCCESS) {
  653.     return VXIlog_RESULT_SYSTEM_ERROR;
  654.   } else {
  655.     VXIthreadID *loggingThread = 
  656.       const_cast<VXIthreadID *>(&_internalErrorLoggingThread);
  657.     *loggingThread = GetThreadID();
  659.     va_list args;
  660.     va_start(args, format);
  661.     rc = ErrorLog(MODULE_NAME, errorID, format, args);
  662.     if ( rc != VXIlog_RESULT_SUCCESS )
  663.       SBlogVLogErrorToConsole(MODULE_NAME, errorID, errorIDText, format, args);
  664.     va_end(args);
  666.     *loggingThread = (VXIthreadID) -1;
  668.     if (VXItrdMutexUnlock(_internalErrorLoggingLock) != VXItrd_RESULT_SUCCESS)
  669.       return VXIlog_RESULT_SYSTEM_ERROR;
  670.   }
  672.   return rc;
  673. }
  676. VXIlogResult SBlog::GlobalError(VXIunsigned errorID, 
  677. const VXIchar *errorIDText,
  678. const VXIchar *format, ...)
  679. {
  680.   va_list args;
  681.   va_start(args, format);
  682.   VXIlogResult rc = SBlogVLogErrorToConsole(MODULE_NAME, errorID, errorIDText,
  683.     format, args);
  684.   va_end(args);
  685.   return rc;
  686. }
  689. bool SBlog::DiagnosticIsEnabled(VXIunsigned tagID)
  690. {
  691.   VXIunsigned bindex, bpos;
  692.   if (!Convert2Index(tagID, &bindex, &bpos))
  693.     return false;
  695.   // if this tag is not turned on, just return
  696.   if (!testbit(_tagIDs[bindex],bpos))
  697.     return false;
  699.   return true;
  700. }
  703. VXIlogResult SBlog::DiagnosticLog(VXIunsigned     tagID,
  704.                                   const VXIchar*  subtag,
  705.                                   const VXIchar*  format,
  706.                                   va_list arguments) const
  707. {
  708.   VXIunsigned bindex, bpos;
  709.   if (!Convert2Index(tagID, &bindex, &bpos))
  710.     return VXIlog_RESULT_INVALID_ARGUMENT;
  712.   // if this tag is not turned on, just return
  713.   if (!testbit(_tagIDs[bindex],bpos))
  714.     return VXIlog_RESULT_SUCCESS;
  716.   time_t timestamp;
  717.   VXIunsigned timestampMsec;
  718.   SBlogGetTime (&timestamp, &timestampMsec);
  720.   wchar_t printmsg[MAX_LOG_BUFFER];
  721.   printmsg[0] = L'';
  722.   if (format != NULL)
  723.     SBlogVswprintf(printmsg, MAX_LOG_BUFFER-1, format, arguments);
  724.   
  725.   if (subtag == NULL)
  726.     subtag = L"";
  727.   
  728.   // Get a temporary callback vector copy to traverse, allows
  729.   // listeners to unregister from within the listener, also increases
  730.   // parallelism by allowing multiple threads to be calling the
  731.   // callbacks at once
  732.   VXIlogResult rc = VXIlog_RESULT_FAILURE;
  733.   if (! Lock( )) {
  734.     return VXIlog_RESULT_SYSTEM_ERROR;
  735.   } else {
  736.     DIAGCALLBACKS tempDiag = diagCallbacks;
  738.     if (! Unlock( ))
  739.       return VXIlog_RESULT_SYSTEM_ERROR;
  740.     
  741.     for (DIAGCALLBACKS::iterator i = tempDiag.begin(); i != tempDiag.end();++i)
  742.       {
  743. (*i)->callback(_pThis, tagID, subtag, timestamp, timestampMsec, 
  744.        printmsg, (*i)->userdata);
  745. rc = VXIlog_RESULT_SUCCESS;
  746.       }
  747.   }
  748.   
  749.   return rc;
  750. }
  753. VXIlogResult SBlog::EventLog(VXIunsigned     eventID,
  754.                              const VXIchar*  format,
  755.                              va_list args) const
  756. {
  757.   time_t timestamp;
  758.   VXIunsigned timestampMsec;
  759.   SBlogGetTime (&timestamp, &timestampMsec);
  761.   // Create key/value pairs
  762.   VXIVector *keys = VXIVectorCreate();
  763.   VXIVector *values = VXIVectorCreate();
  764.   if ((! keys) || (! values)) {
  765.     Error(SBLOG_ERR_OUT_OF_MEMORY);
  766.     return VXIlog_RESULT_OUT_OF_MEMORY;
  767.   }
  768.   
  769.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  770.   if (format) {
  771.     rc = ParseKeyValue(format, args, keys, values);
  772.     if (rc < VXIlog_RESULT_SUCCESS) {
  773.       VXIVectorDestroy(&keys);
  774.       VXIVectorDestroy(&values);
  775.       return rc;
  776.     }
  777.   }
  778.   
  779.   // Get a temporary callback vector copy to traverse, allows
  780.   // listeners to unregister from within the listener, also increases
  781.   // parallelism by allowing multiple threads to be calling the
  782.   // callbacks at once
  783.   if (rc == VXIlog_RESULT_SUCCESS)
  784.     rc = VXIlog_RESULT_FAILURE;
  785.   if (! Lock( )) {
  786.     return VXIlog_RESULT_SYSTEM_ERROR;
  787.   } else {
  788.     EVENTCALLBACKS tempEvent = eventCallbacks;
  790.     if (! Unlock( ))
  791.       return VXIlog_RESULT_SYSTEM_ERROR;
  792.   
  793.     for (EVENTCALLBACKS::iterator i = tempEvent.begin();
  794.  i != tempEvent.end(); ++i)
  795.       {
  796. (*i)->callback(_pThis, eventID, timestamp, timestampMsec, keys, values,
  797.        (*i)->userdata);
  798. if (rc == VXIlog_RESULT_FAILURE)
  799.   rc = VXIlog_RESULT_SUCCESS;
  800.       }
  801.   }
  802.   
  803.   VXIVectorDestroy(&keys);
  804.   VXIVectorDestroy(&values);
  806.   return rc;
  807. }
  810. VXIlogResult SBlog::EventLog(VXIunsigned      eventID,
  811.      const VXIVector* keys,
  812.      const VXIVector* values) const
  813. {
  814.   time_t timestamp;
  815.   VXIunsigned timestampMsec;
  816.   SBlogGetTime (&timestamp, &timestampMsec);
  818.   // Get a temporary callback vector copy to traverse, allows
  819.   // listeners to unregister from within the listener, also increases
  820.   // parallelism by allowing multiple threads to be calling the
  821.   // callbacks at once
  822.   VXIlogResult rc = VXIlog_RESULT_FAILURE;
  823.   if (! Lock( )) {
  824.     return VXIlog_RESULT_SYSTEM_ERROR;
  825.   } else {
  826.     EVENTCALLBACKS tempEvent = eventCallbacks;
  828.     if (! Unlock( ))
  829.       return VXIlog_RESULT_SYSTEM_ERROR;
  830.   
  831.     for (EVENTCALLBACKS::iterator i = tempEvent.begin();
  832.  i != tempEvent.end(); ++i)
  833.       {
  834. (*i)->callback(_pThis, eventID, timestamp, timestampMsec, keys, values,
  835.        (*i)->userdata);
  836. rc = VXIlog_RESULT_SUCCESS;
  837.       }
  838.   }
  840.   return rc;
  841. }
  844. VXIlogResult SBlog::ErrorLog(const VXIchar*   moduleName,
  845.                              VXIunsigned      errorID,
  846.                              const VXIchar*   format,
  847.                              va_list          args) const
  848. {
  849.   time_t  timestamp;
  850.   VXIunsigned timestampMsec;
  851.   SBlogGetTime (&timestamp, &timestampMsec);
  853.   // Create key/value pairs
  854.   VXIVector *keys = VXIVectorCreate();
  855.   VXIVector *values = VXIVectorCreate();
  856.   if ((! keys) || (! values)) {
  857.     Error(SBLOG_ERR_OUT_OF_MEMORY);
  858.     return VXIlog_RESULT_OUT_OF_MEMORY;
  859.   }
  860.   
  861.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  862.   if (format) {
  863.     rc = ParseKeyValue(format, args, keys, values);
  864.     if (rc < VXIlog_RESULT_SUCCESS) {
  865.       VXIVectorDestroy(&keys);
  866.       VXIVectorDestroy(&values);
  867.       return rc;
  868.     }
  869.   }
  870.   
  871.   // Get a temporary callback vector copy to traverse, allows
  872.   // listeners to unregister from within the listener, also increases
  873.   // parallelism by allowing multiple threads to be calling the
  874.   // callbacks at once
  875.   if (rc == VXIlog_RESULT_SUCCESS)
  876.     rc = VXIlog_RESULT_FAILURE;
  877.   if (! Lock( )) {
  878.     return VXIlog_RESULT_SYSTEM_ERROR;
  879.   } else {
  880.     ERRORCALLBACKS tempError = errorCallbacks;
  882.     if (! Unlock( ))
  883.       return VXIlog_RESULT_SYSTEM_ERROR; 
  885.     for (ERRORCALLBACKS::iterator i = tempError.begin();
  886.  i != tempError.end(); ++i)
  887.       {
  888. (*i)->callback(_pThis, 
  889.        (moduleName && moduleName[0] ? moduleName : L"UNKNOWN"),
  890.        errorID, timestamp, timestampMsec, keys, values, 
  891.        (*i)->userdata);
  892. if (rc == VXIlog_RESULT_FAILURE)
  893.   rc = VXIlog_RESULT_SUCCESS;
  894.       }
  895.   }
  896.   
  897.   VXIVectorDestroy(&keys);
  898.   VXIVectorDestroy(&values); 
  900.   // Want to warn the caller that NULL moduleName really isn't OK, but
  901.   // logged it anyway
  902.   if ((! moduleName) || (! moduleName[0])) {
  903.     Error(305, L"SBlog: Empty module name passed to VXIlog API call", NULL);
  904.     rc = VXIlog_RESULT_INVALID_ARGUMENT;
  905.   }
  906.   
  907.   return rc;
  908. }
  911. VXIlogResult SBlog::ContentOpen(const VXIchar*      moduleName,
  912. const VXIchar*      contentType,
  913. VXIString**         logKey,
  914. VXIString**         logValue,
  915. VXIlogStream**      stream) const
  916. {
  917.   if ((! contentType) || (! contentType[0]) || (! logKey) || (! logValue) ||
  918.       (! stream)) {
  919.     Error(306, L"SBlog: Invalid argument to VXIlog::ContentOpen()", NULL);
  920.     return VXIlog_RESULT_INVALID_ARGUMENT;
  921.   }
  923.   *logKey = *logValue = NULL;
  924.   *stream = NULL;
  926.   const VXIchar *finalModuleName = L"UNKNOWN";
  927.   if ((! moduleName) || (! moduleName[0])) {
  928.     Error(305, L"SBlog: Empty module name passed to VXIlog API call", NULL);
  929.   } else {
  930.     finalModuleName = moduleName;
  931.   }
  933.   VXIlogResult rc = VXIlog_RESULT_FAILURE;
  935.   // Get a temporary callback vector copy to traverse, allows
  936.   // listeners to unregister from within the listener, also increases
  937.   // parallelism by allowing multiple threads to be calling the
  938.   // callbacks at once
  939.   if (! Lock( )) {
  940.     return VXIlog_RESULT_SYSTEM_ERROR;
  941.   } else {
  942.     CONTENTCALLBACKS tempContent = contentCallbacks;
  944.     if (! Unlock( ))
  945.       return VXIlog_RESULT_SYSTEM_ERROR; 
  947.     VXIlogStream *finalStream = NULL;
  949.     for (CONTENTCALLBACKS::iterator i = tempContent.begin();
  950.         i != tempContent.end(); ++i)
  951.     {
  952.       VXIString *logKey_    = NULL;
  953.       VXIString *logValue_  = NULL;
  954.       SBlogStream *stream_  = NULL;
  956.       VXIlogResult rc2 = (*i)->callback(_pThis, 
  957. finalModuleName,
  958. contentType, 
  959. (*i)->userdata,
  960. &logKey_,
  961. &logValue_,
  962. &stream_);
  963.       if ((rc2 == VXIlog_RESULT_SUCCESS) && (stream_)) {
  964. // Return the key and value of only the first listener
  965. if ( rc != VXIlog_RESULT_SUCCESS ) {
  966.   finalStream = new VXIlogStream;
  967.   if (! finalStream) {
  968.     VXIStringDestroy(&logKey_);       
  969.     VXIStringDestroy(&logValue_);
  970.     stream_->Close(&stream_);
  971.     Error(SBLOG_ERR_OUT_OF_MEMORY);
  972.     return VXIlog_RESULT_OUT_OF_MEMORY;
  973.   }
  975.   rc = VXIlog_RESULT_SUCCESS;
  976.   *logKey = logKey_;
  977.   *logValue = logValue_;
  978.   *stream = (VXIlogStream *) finalStream;
  979. } else {
  980.   VXIStringDestroy(&logKey_);       
  981.   VXIStringDestroy(&logValue_);
  982. }
  984. // Store the stream
  985. finalStream->streams.push_back(stream_);
  986.       } else if ((rc != VXIlog_RESULT_SUCCESS) &&
  987.  (((rc < 0) && (rc2 < rc)) ||
  988.   ((rc > 0) && (rc2 > rc)))) {
  989. // Return success if any listener returns success but keep the
  990. // worst error otherwise
  991. rc = rc2;
  992.       }
  993.     }
  994.   }
  996.   return rc;
  997. }
  1000. VXIlogResult SBlog::ContentClose(VXIlogStream**     stream) const
  1001. {
  1002.   if ((! stream) || (! *stream)) {
  1003.     Error(307, L"SBlog: Invalid argument to VXIlog::ContentClose()", NULL);
  1004.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1005.   }
  1006.   
  1007.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  1009.   // Close each of the underlying listener streams
  1010.   for (VXIlogStream::STREAMS::iterator vi = (*stream)->streams.begin( );
  1011.        vi != (*stream)->streams.end( ); vi++) {
  1012.     SBlogStream *s = *vi;
  1013.     VXIlogResult rc2 = s->Close (&s);
  1014.     if ((rc == VXIlog_RESULT_SUCCESS) || ((rc < 0) && (rc2 < rc)) ||
  1015. ((rc > 0) && (rc2 > rc)))
  1016.       rc = rc2;
  1017.   }
  1019.   delete *stream;
  1020.   *stream = NULL; 
  1021.   return rc;
  1022. }
  1025. VXIlogResult SBlog::ContentWrite(const VXIbyte*     buffer,
  1026.  VXIulong           buflen,
  1027.  VXIulong*          nwritten,
  1028.  VXIlogStream*      stream) const
  1029. {
  1030.   if ((! buffer) || (buflen < 1) || (! nwritten) || (! stream)) {
  1031.     Error(308, L"SBlog: Invalid argument to VXIlog::ContentWrite()", NULL);
  1032.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1033.   }
  1034.   
  1035.   VXIlogResult rc = VXIlog_RESULT_SUCCESS;
  1036.   *nwritten = 0;
  1038.   // Write to each of the underlying listener streams
  1039.   for (VXIlogStream::STREAMS::iterator vi = stream->streams.begin( );
  1040.        vi != stream->streams.end( ); vi++) {
  1041.     SBlogStream *s = *vi;
  1042.     VXIulong nw = 0;
  1043.     VXIlogResult rc2 = s->Write (s, buffer, buflen, &nw);
  1044.     if (rc == VXIlog_RESULT_SUCCESS) {
  1045.       if (nw > *nwritten)
  1046. *nwritten = nw;
  1047.     } else if ((rc == VXIlog_RESULT_SUCCESS) || ((rc < 0) && (rc2 < rc)) ||
  1048.        ((rc > 0) && (rc2 > rc))) {
  1049.       rc = rc2;
  1050.     }
  1051.   }
  1053.   return rc;
  1054. }
  1056.   
  1057. /***********************************************************************/
  1059. VXIlogResult SBlogControlDiagnosticTag(SBlogInterface *pThis,
  1060.                                        VXIunsigned tagID,
  1061.                                        VXIbool     state)
  1062. {
  1063.   if (pThis == NULL)
  1064.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1065.   myAPI *temp = (myAPI *) pThis; 
  1066.   SBlog *me = (SBlog *)temp->impl_;
  1067.   return (me->ControlDiagnosticTag(tagID, state));
  1068. }
  1071. VXIlogResult SBlogRegisterErrorListener(SBlogInterface *pThis,
  1072.                                         SBlogErrorListener* alistener,
  1073.                                         void* userdata)
  1074. {
  1075.   if ((pThis == NULL) || (alistener == NULL))
  1076.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1077.   myAPI *temp = (myAPI *) pThis; 
  1078.   SBlog *me = (SBlog *)temp->impl_;
  1079.   SBlogErrorCallbackData *info = new SBlogErrorCallbackData;
  1080.   if (info == NULL) {
  1081.     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
  1082.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1083.   }
  1084.  
  1085.   info->callback = alistener;
  1086.   info->userdata = userdata;
  1087.   return ( me->RegisterErrorListener(info));
  1088. } 
  1091. VXIlogResult SBlogUnregisterErrorListener(SBlogInterface *pThis,
  1092.                                           SBlogErrorListener* alistener,
  1093.                                           void* userdata)
  1094. {
  1095.   if ((pThis == NULL) || (alistener == NULL))
  1096.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1097.   myAPI *temp = (myAPI *) pThis; 
  1098.   SBlog *me = (SBlog *)temp->impl_;
  1099.   SBlogErrorCallbackData info = { alistener, userdata };
  1100.   SBlogErrorCallbackData *p = me->UnregisterErrorListener(&info);
  1101.   if (p) delete p;
  1102.   return VXIlog_RESULT_SUCCESS;
  1103. } 
  1106. VXIlogResult SBlogRegisterDiagnosticListener(SBlogInterface *pThis,
  1107.                                              SBlogDiagnosticListener*alistener,
  1108.                                              void* userdata)
  1109. {
  1110.   if ((pThis == NULL) || (alistener == NULL))
  1111.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1112.   myAPI *temp = (myAPI *) pThis; 
  1113.   SBlog *me = (SBlog *)temp->impl_;
  1114.   SBlogDiagCallbackData *info = new SBlogDiagCallbackData;
  1115.   if (info == NULL) {
  1116.     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
  1117.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1118.   }
  1119.  
  1120.   info->callback = alistener;
  1121.   info->userdata = userdata;
  1122.   return ( me->RegisterDiagnosticListener(info));
  1123. } 
  1125. VXIlogResult SBlogUnregisterDiagnosticListener(
  1126.                                      SBlogInterface *pThis,
  1127.                                      SBlogDiagnosticListener* alistener,
  1128.                                      void* userdata)
  1129. {
  1130.   if ((pThis == NULL) || (alistener == NULL))
  1131.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1133.   myAPI *temp = (myAPI *) pThis; 
  1134.   SBlog *me = (SBlog *)temp->impl_;
  1135.   SBlogDiagCallbackData info = { alistener, userdata };
  1136.   SBlogDiagCallbackData *p = me->UnregisterDiagnosticListener(&info);
  1137.   if (p) delete p;
  1139.   return VXIlog_RESULT_SUCCESS;
  1140. } 
  1143. VXIlogResult SBlogRegisterEventListener(SBlogInterface *pThis,
  1144.                                         SBlogEventListener* alistener,
  1145.                                         void* userdata)
  1146. {
  1147.   if ((pThis == NULL) || (alistener == NULL))
  1148.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1149.   
  1150.   myAPI *temp = (myAPI *) pThis; 
  1151.   SBlog *me = (SBlog *)temp->impl_;
  1152.   SBlogEventCallbackData *info = new SBlogEventCallbackData;
  1153.   if (info == NULL) {
  1154.     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
  1155.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1156.   }
  1157.  
  1158.   info->callback = alistener;
  1159.   info->userdata = userdata;
  1160.   return ( me->RegisterEventListener(info));
  1161. } 
  1164. VXIlogResult SBlogUnregisterEventListener(SBlogInterface *pThis,
  1165.                                           SBlogEventListener* alistener,
  1166.                                           void*  userdata)
  1167. {
  1168.   if ((pThis == NULL) || (alistener == NULL))
  1169.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1171.   myAPI *temp = (myAPI *) pThis; 
  1172.   SBlog *me = (SBlog *)temp->impl_;
  1173.   SBlogEventCallbackData info = { alistener, userdata };
  1174.   SBlogEventCallbackData *p = me->UnregisterEventListener(&info);
  1175.   if (p) delete p;
  1177.   return VXIlog_RESULT_SUCCESS;
  1178. } 
  1181. VXIlogResult SBlogRegisterContentListener(SBlogInterface *pThis,
  1182.   SBlogContentListener* alistener,
  1183.   void* userdata)
  1184. {
  1185.   if ((pThis == NULL) || (alistener == NULL))
  1186.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1187.   
  1188.   myAPI *temp = (myAPI *) pThis; 
  1189.   SBlog *me = (SBlog *)temp->impl_;
  1190.   SBlogContentCallbackData *info = new SBlogContentCallbackData;
  1191.   if (info == NULL) {
  1192.     me->Error(SBLOG_ERR_OUT_OF_MEMORY);
  1193.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1194.   }
  1195.  
  1196.   info->callback = alistener;
  1197.   info->userdata = userdata;
  1198.   return ( me->RegisterContentListener(info));
  1199. } 
  1202. VXIlogResult SBlogUnregisterContentListener(SBlogInterface *pThis,
  1203.     SBlogContentListener* alistener,
  1204.     void*  userdata)
  1205. {
  1206.   if ((pThis == NULL) || (alistener == NULL))
  1207.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1209.   myAPI *temp = (myAPI *) pThis; 
  1210.   SBlog *me = (SBlog *)temp->impl_;
  1211.   SBlogContentCallbackData info = { alistener, userdata };
  1212.   SBlogContentCallbackData *p = me->UnregisterContentListener(&info);
  1213.   if (p) delete p;
  1215.   return VXIlog_RESULT_SUCCESS;
  1216. } 
  1218. /**********************************************************************
  1219. */
  1221. SBLOG_API VXIint32 SBlogGetVersion(void)
  1222. {
  1223.   return VXI_CURRENT_VERSION;
  1224. }
  1227. SBLOG_API const VXIchar* SBlogGetImplementationName(void)
  1228. {
  1229.   static const VXIchar IMPLEMENTATION_NAME[] = COMPANY_DOMAIN L".SBlog";
  1230.   return IMPLEMENTATION_NAME;
  1231. }
  1234. SBLOG_API VXIbool SBlogDiagnosticIsEnabled(VXIlogInterface * pThis,
  1235.                                            VXIunsigned tagID)
  1236. {
  1237.   if (pThis == NULL)
  1238.     return FALSE;
  1240.   myAPI *temp = (myAPI *) pThis;
  1241.   SBlog *me = (SBlog *) temp->impl_;
  1243.   if (!me->DiagnosticIsEnabled(tagID)) return FALSE;
  1244.   return TRUE;
  1245. }
  1248. SBLOG_API VXIlogResult SBlogDiagnostic(VXIlogInterface*        pThis,
  1249.                                        VXIunsigned             tagID,
  1250.                                        const VXIchar*          subtag,
  1251.                                        const VXIchar*          format,
  1252.                                        ...)
  1253. {
  1254.   if (pThis == NULL)
  1255.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1257.   myAPI *temp = (myAPI *) pThis;
  1258.   SBlog *me = (SBlog *) temp->impl_;
  1259.   va_list args;
  1260.   va_start(args, format);
  1262.   VXIlogResult ret = me->DiagnosticLog(tagID, subtag, format, args);
  1263.   va_end(args);
  1265.   return ret;
  1266. }
  1268. SBLOG_API VXIlogResult SBlogVDiagnostic(VXIlogInterface*        pThis,
  1269.                                         VXIunsigned             tagID,
  1270.                                         const VXIchar*          subtag,
  1271.                                         const VXIchar*          format,
  1272.                                         va_list                 vargs)
  1273. {
  1274.   if (pThis == NULL)
  1275.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1277.   myAPI *temp = (myAPI *)pThis;
  1278.   SBlog *me = (SBlog *)temp->impl_;
  1279.   VXIlogResult ret = me->DiagnosticLog(tagID, subtag, format, vargs);
  1281.   return ret;
  1282. }
  1285. SBLOG_API VXIlogResult SBlogEvent(VXIlogInterface*        pThis,
  1286.                                   VXIunsigned             eventID,
  1287.                                   const VXIchar*          format,
  1288.                                   ...)
  1289. {
  1290.   if (pThis == NULL)
  1291.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1293.   myAPI *temp = (myAPI*)pThis;
  1294.   SBlog *me = (SBlog *)temp->impl_;
  1295.   va_list args;
  1296.   va_start(args, format);
  1297.   VXIlogResult ret = me->EventLog(eventID, format, args);
  1298.   va_end(args);
  1300.   return ret;
  1301. }
  1304. SBLOG_API VXIlogResult SBlogVEvent(VXIlogInterface*        pThis,
  1305.                                    VXIunsigned             eventID,
  1306.                                    const VXIchar*          format,
  1307.                                    va_list                 vargs)
  1308. {
  1309.   if (pThis == NULL)
  1310.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1312.   myAPI *temp = (myAPI*)pThis;
  1313.   SBlog *me = (SBlog *)temp->impl_;
  1314.   VXIlogResult ret = me->EventLog(eventID, format, vargs);
  1316.   return ret;
  1317. }
  1320. SBLOG_API VXIlogResult SBlogEventVector(VXIlogInterface*        pThis,
  1321. VXIunsigned             eventID,
  1322. const VXIVector*        keys,
  1323. const VXIVector*        values)
  1324. {
  1325.   if (pThis == NULL)
  1326.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1328.   myAPI *temp = (myAPI*)pThis;
  1329.   SBlog *me = (SBlog *)temp->impl_;
  1330.   VXIlogResult ret = me->EventLog(eventID, keys, values);
  1332.   return ret;
  1333. }
  1336. SBLOG_API VXIlogResult SBlogError(VXIlogInterface*        pThis,
  1337.                                   const VXIchar*          moduleName,
  1338.                                   VXIunsigned             errorID,
  1339.                                   const VXIchar*          format,
  1340.                                   ...)
  1341. {
  1342.   if (pThis == NULL)
  1343.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1345.   myAPI *temp = (myAPI*)pThis;
  1346.   SBlog *me = (SBlog *)temp->impl_;
  1347.   va_list args;
  1348.   va_start(args, format);
  1349.   VXIlogResult ret = me->ErrorLog(moduleName, errorID, format, args);
  1350.   va_end(args);
  1352.   return ret;
  1353. }
  1356. SBLOG_API VXIlogResult SBlogVError(VXIlogInterface*        pThis,
  1357.                                    const VXIchar*          moduleName,
  1358.                                    VXIunsigned             errorID,
  1359.                                    const VXIchar*          format,
  1360.                                    va_list                 vargs)
  1361. {
  1362.   if (pThis == NULL)
  1363.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1365.   myAPI *temp = (myAPI*)pThis;
  1366.   SBlog *me = (SBlog *)temp->impl_;
  1367.   VXIlogResult ret = me->ErrorLog(moduleName, errorID, format, vargs);
  1369.   return ret;
  1370. }
  1373. SBLOG_API VXIlogResult SBlogContentOpen(VXIlogInterface*  pThis,
  1374. const VXIchar*    moduleName,
  1375. const VXIchar*    contentType,
  1376. VXIString**       logKey,
  1377. VXIString**       logValue,
  1378. VXIlogStream**    stream)
  1379. {
  1380.   if (pThis == NULL)
  1381.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1383.   myAPI *temp = (myAPI*)pThis;
  1384.   SBlog *me = (SBlog *)temp->impl_;
  1385.   VXIlogResult ret = me->ContentOpen(moduleName, contentType,
  1386.      logKey, logValue, stream);
  1388.   return ret;
  1389. }
  1392. SBLOG_API VXIlogResult SBlogContentClose(VXIlogInterface* pThis,
  1393.  VXIlogStream**   stream)
  1394. {
  1395.   if (pThis == NULL)
  1396.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1398.   myAPI *temp = (myAPI*)pThis;
  1399.   SBlog *me = (SBlog *)temp->impl_;
  1400.   VXIlogResult ret = me->ContentClose(stream);
  1402.   return ret;
  1403. }
  1406. SBLOG_API VXIlogResult SBlogContentWrite(VXIlogInterface* pThis,
  1407.  const VXIbyte*   buffer,
  1408.  VXIulong         buflen,
  1409.  VXIulong*        nwritten,
  1410.  VXIlogStream*    stream)
  1411. {
  1412.   if (pThis == NULL)
  1413.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1415.   myAPI *temp = (myAPI*)pThis;
  1416.   SBlog *me = (SBlog *)temp->impl_;
  1417.   VXIlogResult ret = me->ContentWrite(buffer, buflen, nwritten, stream);
  1419.   return ret;
  1420. }
  1423. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  1425. /**
  1426.  * Global platform initialization of SBlog
  1427.  *
  1428.  * @result VXIlogResult 0 on success
  1429.  */
  1430. SBLOG_API VXIlogResult SBlogInit(void)
  1431. {
  1432.   if (gblInitialized == true) {
  1433.     SBlog::GlobalError(SBLOG_ERR_ALREADY_INITIALIZED);
  1434.     return VXIlog_RESULT_FATAL_ERROR;
  1435.   }
  1437.   gblInitialized = true;
  1438.   return VXIlog_RESULT_SUCCESS;
  1439. }
  1442. /**
  1443.  * Global platform shutdown of Log
  1444.  *
  1445.  * @result VXIlogResult 0 on success
  1446.  */
  1447. SBLOG_API VXIlogResult SBlogShutDown(void)
  1448. {
  1449.   if (gblInitialized == false) {
  1450.     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
  1451.     return VXIlog_RESULT_FATAL_ERROR;
  1452.   }
  1454.   gblInitialized = false;
  1455.   return VXIlog_RESULT_SUCCESS;
  1456. }
  1459. /**
  1460.  * Create a new log service handle
  1461.  *
  1462.  * @result VXIlogResult 0 on success 
  1463.  */
  1464. SBLOG_API VXIlogResult SBlogCreateResource(VXIlogInterface **log)
  1465. {
  1466.   if (gblInitialized == false) {
  1467.     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
  1468.     return VXIlog_RESULT_FATAL_ERROR;
  1469.   }
  1471.   if (log == NULL) {
  1472.     SBlog::GlobalError(309, L"SBlog: SBlogCreateResource() requires a "
  1473.        L"non-NULL log interface pointer", NULL);
  1474.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1475.   }
  1477.   myAPI *temp = new myAPI;
  1478.   if (temp == NULL) {
  1479.     SBlog::GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
  1480.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1481.   }
  1482.   memset (temp, 0, sizeof (myAPI));
  1483.   
  1484.   SBlog *me = new SBlog(&temp->intf);
  1485.   if (me == NULL) {
  1486.     delete temp;
  1487.     SBlog::GlobalError(SBLOG_ERR_OUT_OF_MEMORY);
  1488.     return VXIlog_RESULT_OUT_OF_MEMORY;
  1489.   }
  1490.   
  1491.   // Initialize the VXIlogInterface function pointers
  1492.   temp->intf.vxilog.GetVersion            = SBlogGetVersion;
  1493.   temp->intf.vxilog.GetImplementationName = SBlogGetImplementationName;
  1494.   temp->intf.vxilog.Error                 = SBlogError;
  1495.   temp->intf.vxilog.VError                = SBlogVError;
  1496.   temp->intf.vxilog.Diagnostic            = SBlogDiagnostic;
  1497.   temp->intf.vxilog.VDiagnostic           = SBlogVDiagnostic;
  1498.   temp->intf.vxilog.DiagnosticIsEnabled   = SBlogDiagnosticIsEnabled;
  1499.   temp->intf.vxilog.Event                 = SBlogEvent;
  1500.   temp->intf.vxilog.VEvent                = SBlogVEvent;
  1501.   temp->intf.vxilog.EventVector           = SBlogEventVector;
  1502.   temp->intf.vxilog.ContentOpen           = SBlogContentOpen;
  1503.   temp->intf.vxilog.ContentClose          = SBlogContentClose;
  1504.   temp->intf.vxilog.ContentWrite          = SBlogContentWrite;
  1505.   
  1506.   // Initialize the SBlogInterface functions
  1507.   temp->intf.RegisterErrorListener = SBlogRegisterErrorListener;
  1508.   temp->intf.UnregisterErrorListener = SBlogUnregisterErrorListener;
  1509.   temp->intf.RegisterDiagnosticListener = SBlogRegisterDiagnosticListener;
  1510.   temp->intf.UnregisterDiagnosticListener = SBlogUnregisterDiagnosticListener;
  1511.   temp->intf.RegisterEventListener = SBlogRegisterEventListener;
  1512.   temp->intf.UnregisterEventListener = SBlogUnregisterEventListener;
  1513.   temp->intf.RegisterContentListener = SBlogRegisterContentListener;
  1514.   temp->intf.UnregisterContentListener = SBlogUnregisterContentListener;
  1515.   temp->intf.ControlDiagnosticTag = SBlogControlDiagnosticTag;
  1516.   temp->impl_ = (void*)me;
  1518.   // Return the object
  1519.   *log = &temp->intf.vxilog;
  1520.   return VXIlog_RESULT_SUCCESS;
  1521. }
  1524. /**
  1525.  * Destroy the interface and free internal resources
  1526.  *
  1527.  * @result VXIlogResult 0 on success 
  1528.  */
  1529. SBLOG_API VXIlogResult SBlogDestroyResource(VXIlogInterface **log)
  1530. {
  1531.   if (gblInitialized == false) {
  1532.     SBlog::GlobalError(SBLOG_ERR_NOT_INITIALIZED);
  1533.     return VXIlog_RESULT_FATAL_ERROR;
  1534.   }
  1536.   if ((log == NULL) || (*log == NULL)) {
  1537.     SBlog::GlobalError(310, L"SBlog: SBlogDestroyResource() requires a "
  1538.        L"non-NULL log interface pointer", NULL);
  1539.     return VXIlog_RESULT_INVALID_ARGUMENT;
  1540.   }
  1542.   // Delete the object
  1543.   myAPI *temp = (myAPI *) *log;
  1544.   SBlog *me = (SBlog *)temp->impl_;
  1545.   if (me) delete me;
  1546.   if (temp) delete temp;
  1547.   *log = NULL;
  1549.   return VXIlog_RESULT_SUCCESS;
  1550. }