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

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

xml/soap/webservice

开发平台：

Visual C++

VXIobject.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 <string.h>                     // For memset( )
  27. #include <stdio.h>                      // For fopen( ), fclose( ), fwrite( )
  28. #include <errno.h>                      // For errno
  30. #include <VXIlog.h>                     // For VXIlog interface
  31. #include "VXIobjectAPI.h"               // Header for these functions
  32. #include "VXIclient.h"
  34. #ifndef MODULE_PREFIX
  35. #define MODULE_PREFIX  COMPANY_DOMAIN L"."
  36. #endif
  37. static const VXIchar MODULE_VXIOBJECT[]              = MODULE_PREFIX L"VXIobject";
  38. static const VXIchar VXIOBJECT_IMPLEMENTATION_NAME[] = COMPANY_DOMAIN L".VXIobject";
  40. // Global variable to track whether this is initialized
  41. static bool gblInitialized = false;
  43. // Global diagnostic logging base
  44. static VXIunsigned gblDiagLogBase;
  46. // Diagnostic logging tags
  47. static const VXIunsigned LOG_API = 0;
  49. // VXIobject interface, "inherits" from VXIobjectInterface
  50. typedef struct VXIobjectAPI
  51. {
  52.   // Base interface, must be the first member
  53.   VXIobjectInterface  object;
  55.   // Resources for this channel
  56.   VXIobjectResources  *resources;
  58. } VXIobjectAPI;
  60. // Convenience macro
  61. #define GET_VXIOBJECT(pThis, vxiObject, log, rc) 
  62.   VXIobjResult rc = VXIobj_RESULT_SUCCESS; 
  63.   VXIobjectAPI *objectAPI = (VXIobjectAPI *) pThis; 
  64.   if ( ! objectAPI ) { rc = VXIobj_RESULT_INVALID_ARGUMENT; return rc; } 
  65.   VXIlogInterface *log = objectAPI->resources->log;
  68. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  70. /**
  71.  * Internal function for error logging
  72.  */
  73. static VXIlogResult
  74. Error (VXIlogInterface *log, VXIunsigned errorID, const VXIchar *format, ...)
  75. {
  76.   va_list arguments;
  78.   if ( ! log )
  79.     return VXIlog_RESULT_FAILURE;
  80.   
  81.   VXIlogResult rc;
  82.   if ( format ) {
  83.     va_start(arguments, format);
  84.     rc = (*log->VError)(log, MODULE_VXIOBJECT, errorID, format, arguments);
  85.     va_end(arguments);
  86.   } else {
  87.     rc = (*log->Error)(log, MODULE_VXIOBJECT, errorID, NULL);
  88.   }
  90.   return rc;
  91. }
  93. /**
  94.  * Internal function for diagnostic logging
  95.  */
  96. static VXIlogResult
  97. Diag (VXIlogInterface *log, VXIunsigned tag, const VXIchar *subtag,
  98.       const VXIchar *format, ...)
  99. {
  100.   va_list arguments;
  102.   if ( ! log )
  103.     return VXIlog_RESULT_FAILURE;
  104.   
  105.   VXIlogResult rc;
  106.   if ( format ) {
  107.     va_start(arguments, format);
  108.     rc = (*log->VDiagnostic)(log, tag + gblDiagLogBase, subtag, format,
  109.            arguments);
  110.     va_end(arguments);
  111.   } else {
  112.     rc = (*log->Diagnostic)(log, tag + gblDiagLogBase, subtag, NULL);
  113.   }
  115.   return rc;
  116. }
  118. static void ShowPropertyValues(const VXIchar *key,
  119.            const VXIValue *value, VXIunsigned PROP_TAG,
  120.            VXIlogInterface *log)
  121. {
  122.   VXIchar subtag[512] = L"Property";
  123.   if( value == 0 ) return;
  124.   VXIvalueType type = VXIValueGetType(value);
  125.   {
  126.     switch( type )
  127.     {
  128.       case VALUE_INTEGER:
  129.         wcscpy(subtag, L"Property:INT");
  130.         Diag(log, PROP_TAG, subtag, 
  131.              L"%s=%d", key, VXIIntegerValue((const VXIInteger*)value));
  132.         break;
  133.       case VALUE_FLOAT:
  134.         wcscpy(subtag, L"Property:FLT");
  135.         Diag(log, PROP_TAG, subtag, 
  136.              L"%s=%f", key, VXIFloatValue((const VXIFloat*)value));
  137.         break;
  138.       case VALUE_BOOLEAN:     
  139.         wcscpy(subtag, L"Property:BOOL");
  140.         Diag(log, PROP_TAG, subtag, 
  141.              L"%s=%d", key, VXIBooleanValue((const VXIBoolean*)value));
  142.         break;
  143.       case VALUE_STRING:
  144.         wcscpy(subtag, L"Property:STR");
  145.         Diag(log, PROP_TAG, subtag, 
  146.              L"%s=%s", key, VXIStringCStr((const VXIString*)value));
  147.         break;
  148.       case VALUE_PTR:
  149.         wcscpy(subtag, L"Property:PTR");
  150.         Diag(log, PROP_TAG, subtag, 
  151.              L"%s(ptr)=0x%p", key, VXIPtrValue((const VXIPtr*)value));
  152.         break;
  153.       case VALUE_CONTENT:
  154.         wcscpy(subtag, L"Property:CNT");
  155.         Diag(log, PROP_TAG, subtag, 
  156.              L"%s(content)=0x%p", key, value);
  157.         break;
  158.       case VALUE_MAP:
  159.         {
  160.           VXIchar endtag[512];
  161.           const VXIchar *mykey = key ? key : L"NULL";
  162.           wcscpy(subtag, L"Property:MAP:BEG");
  163.           wcscpy(endtag, L"Property:MAP:END");
  164.           Diag(log, PROP_TAG, subtag, L"%s", mykey);
  165.           const VXIchar *key = NULL;
  166.           const VXIValue *gvalue = NULL;
  168.           VXIMapIterator *it = VXIMapGetFirstProperty((const VXIMap*)value, &key, &gvalue);
  169.           int ret = 0;
  170.           while( ret == 0 && key && gvalue )
  171.           {
  172.             ShowPropertyValues(key, gvalue, PROP_TAG, log);
  173.             ret = VXIMapGetNextProperty(it, &key, &gvalue);
  174.           }
  175.           VXIMapIteratorDestroy(&it);         
  176.           Diag(log, PROP_TAG, endtag, L"%s", mykey);
  177.         }   
  178.         break;
  179.       case VALUE_VECTOR:
  180.         {
  181.           VXIunsigned vlen = VXIVectorLength((const VXIVector*)value);
  182.           for(VXIunsigned i = 0; i < vlen; ++i)
  183.           {
  184.             const VXIValue *gvalue = VXIVectorGetElement((const VXIVector*)value, i);
  185.             ShowPropertyValues(L"Vector", gvalue, PROP_TAG, log);
  186.           }
  187.         }
  188.         break;
  189.       default:
  190.         Diag(log, PROP_TAG, subtag, L"%s=%s", key, L"UNKOWN");
  191.     }          
  192.   }
  193.   return;
  194. }
  196. static void ShowPropertyValue(const VXIMap *properties, VXIlogInterface *log)
  197. {
  198.   const VXIchar *key = NULL;
  199.   const VXIValue *gvalue = NULL;
  200.   const VXIunsigned PROP_TAG = 5;
  201.   if( log && log->DiagnosticIsEnabled(log, PROP_TAG+gblDiagLogBase) && properties) {
  202.     VXIMapIterator *it = VXIMapGetFirstProperty(properties, &key, &gvalue);
  203.     int ret = 0;
  204.     while( ret == 0 && key && gvalue )
  205.     {
  206.       ShowPropertyValues(key, gvalue, PROP_TAG, log);
  207.       ret = VXIMapGetNextProperty(it, &key, &gvalue);
  208.     }
  209.     VXIMapIteratorDestroy(&it);     
  210.   }
  211.   return;
  212. }
  215. /**
  216.  * Sample diagnostic logging object
  217.  *
  218.  * @param properties    [IN]  See description in VXIobjectExecute() 
  219.  *                            or VXIobjectValidate()
  220.  * @param parameters    [IN]  See description in VXIobjectExecute() 
  221.  *                            or VXIobjectValidate()
  222.  * @param execute       [IN]  Specifies whether the object should be
  223.  *                            executed (true) or simply validated (false)
  224.  * @param result        [OUT] See description in VXIobjectExecute() 
  225.  *                            or VXIobjectValidate()
  226.  *
  227.  * @result VXIobj_RESULT_SUCCESS on success
  228.  */
  229. static VXIobjResult 
  230. ProcessComSpeechworksDiagObject (struct VXIobjectInterface *pThis,
  231.                                  const VXIMap              *properties,
  232.                                  const VXIMap              *parameters,
  233.                                  VXIbool                    execute,
  234.          VXIValue                 **result)
  235. {
  236.   static const wchar_t func[] = L"ProcessComSpeechworksDiagObject";
  237.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  239.   if((execute) && (result == NULL)) return VXIobj_RESULT_INVALID_ARGUMENT;
  240.   if((! properties) || (! parameters)) return VXIobj_RESULT_INVALID_ARGUMENT;
  242.   // Get the tag ID
  243.   const VXIValue *val = VXIMapGetProperty(parameters, L"tag");
  244.   if(val == NULL) {
  245.     Error(log, 202, L"%s%s", L"parameter", L"tag");
  246.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  247.   } 
  248.   VXIint tag;
  249.   switch (VXIValueGetType(val)) {
  250.   case VALUE_INTEGER:
  251.     tag = VXIIntegerValue((VXIInteger *)val);
  252.     break;
  253.   case VALUE_STRING: {
  254.     wchar_t *ptr;
  255.     tag = ::wcstol(VXIStringCStr((VXIString *)val), &ptr, 10);
  256.     } break;
  257.   default:
  258.     Error(log, 203, L"%s%s%s%d", L"parameter", L"tag", 
  259.     L"type", VXIValueGetType(val));
  260.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  261.   }
  263.   // Get the message string
  264.   val = VXIMapGetProperty(parameters, L"message");
  265.   if(val == NULL) {
  266.     Error(log, 202, L"%s%s", L"parameter", L"message");
  267.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  268.   }
  270.   // Check whether the message was sent in "data" or "ref" format.
  271.   // If it is "ref", we need to retrieve it in the embedded map.
  272.   const VXIchar *messageStr = NULL;
  273.   switch (VXIValueGetType(val)) {
  274.   case VALUE_MAP: {
  275.     const VXIValue *val2 = VXIMapGetProperty((const VXIMap *)val, 
  276.                                              OBJECT_VALUE);
  277.     if (VXIValueGetType(val2) == VALUE_STRING)
  278.       messageStr = VXIStringCStr((VXIString *)val2);
  279.     } break;
  280.   case VALUE_STRING:
  281.     messageStr = VXIStringCStr((VXIString *)val);
  282.     break;
  283.   default:
  284.     Error(log, 203, L"%s%s%s%d", L"parameter", L"message", 
  285.     L"type", VXIValueGetType(val));
  286.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  287.   }
  289.   if ((! messageStr) || (! messageStr[0])) {
  290.     Error(log, 204, L"%s%s", L"parameter", L"message");
  291.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  292.   }
  293.   
  294.   if(execute) {
  295.     // Print a diagnostic message using the retrieved arguments.
  296.     // To see this message, you must enable client.log.diagTag.xxx
  297.     // in your VXIclient configuration file, where 'xxx' is the 
  298.     // value of client.object.diagLogBase defined in the same file.
  299.     VXIlogResult rc = Diag (log, tag, NULL, messageStr);
  301.     // Create the result object
  302.     VXIMap *resultObj = VXIMapCreate();
  303.     if(resultObj == NULL) {
  304.       Error(log, 100, NULL);
  305.       return VXIobj_RESULT_OUT_OF_MEMORY;
  306.     }
  307.     *result = reinterpret_cast<VXIValue *>(resultObj);
  309.     // Set the result object's status field to 'success' or 'failure'
  310.     if(rc == VXIlog_RESULT_SUCCESS)
  311.       VXIMapSetProperty(resultObj, L"status",
  312.                reinterpret_cast<VXIValue *>(VXIStringCreate(L"success")));
  313.     else
  314.       VXIMapSetProperty(resultObj, L"status", 
  315.                reinterpret_cast<VXIValue *>(VXIStringCreate(L"failure")));
  316.   }
  318.   return VXIobj_RESULT_SUCCESS;
  319. }
  321. /**
  322.  * Sample object echoing back all parameters
  323.  *
  324.  * @param properties    [IN]  See description in VXIobjectExecute() 
  325.  *                            or VXIobjectValidate()
  326.  * @param parameters    [IN]  See description in VXIobjectExecute() 
  327.  *                            or VXIobjectValidate()
  328.  * @param execute       [IN]  Specifies whether the object should be
  329.  *                            executed (true) or simply validated (false)
  330.  * @param result        [OUT] See description in VXIobjectExecute() 
  331.  *                            or VXIobjectValidate()
  332.  *
  333.  * @result VXIobj_RESULT_SUCCESS on success
  334.  */
  335. static VXIobjResult 
  336. ProcessComSpeechworksEchoObject (struct VXIobjectInterface *pThis,
  337.                                  const VXIMap              *properties,
  338.                                  const VXIMap              *parameters,
  339.                                  VXIbool                    execute,
  340.          VXIValue                 **result)
  341. {
  342.   static const wchar_t func[] = L"ProcessComSpeechworksEchoObject";
  343.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  345.   if((execute) && (result == NULL)) return VXIobj_RESULT_INVALID_ARGUMENT;
  346.   if((! properties) || (! parameters)) return VXIobj_RESULT_INVALID_ARGUMENT;
  348.   if(execute) {
  349.     // Create the result object
  350.     VXIMap *resultObj = VXIMapCreate();
  351.     if(resultObj == NULL) {
  352.       Error(log, 100, NULL);
  353.       return VXIobj_RESULT_OUT_OF_MEMORY;
  354.     }
  355.     *result = reinterpret_cast<VXIValue *>(resultObj);
  357.     // Simply add the input properties and parameters to the result object
  358.     VXIMapSetProperty(resultObj, L"attributes", 
  359.           VXIValueClone((VXIValue *)properties));
  360.     VXIMapSetProperty(resultObj, L"parameters", 
  361.           VXIValueClone((VXIValue *)parameters));
  363.   }
  365.   return VXIobj_RESULT_SUCCESS;
  366. }
  368. /**
  369.  * Sample object to save a recording to a file
  370.  *
  371.  * @param properties    [IN]  See description in VXIobjectExecute() 
  372.  *                            or VXIobjectValidate()
  373.  * @param parameters    [IN]  See description in VXIobjectExecute() 
  374.  *                            or VXIobjectValidate()
  375.  * @param execute       [IN]  Specifies whether the object should be
  376.  *                            executed (true) or simply validated (false)
  377.  * @param result        [OUT] See description in VXIobjectExecute() 
  378.  *                            or VXIobjectValidate()
  379.  *
  380.  * @result VXIobj_RESULT_SUCCESS on success
  381.  */
  382. static VXIobjResult 
  383. ProcessComSpeechworksSaveRecordingObject (struct VXIobjectInterface *pThis,
  384.             const VXIMap             *properties,
  385.             const VXIMap             *parameters,
  386.             VXIbool                    execute,
  387.             VXIValue                 **result)
  388. {
  389.   static const wchar_t func[] = L"ProcessComSpeechworksSaveRecordingObject";
  390.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  392.   if((execute) && (result == NULL)) return VXIobj_RESULT_INVALID_ARGUMENT;
  393.   if((! properties) || (! parameters)) return VXIobj_RESULT_INVALID_ARGUMENT;
  395.   // Get the recording, MIME type, size, and destination path
  396.   const VXIbyte *recording = NULL;
  397.   const VXIchar *type = NULL, *dest = NULL;
  398.   VXIulong size = 0;
  399.   const VXIValue *val = VXIMapGetProperty(parameters, L"recording");
  400.   if (! val) {
  401.     Error(log, 202, L"%s%s", L"parameter", L"recording");
  402.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  403.   } else if (VXIValueGetType(val) != VALUE_CONTENT) {
  404.     Error(log, 203, L"%s%s%s%d", L"parameter", L"recording", 
  405.     L"type", VXIValueGetType(val));
  406.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  407.   }
  408.   if (VXIContentValue(reinterpret_cast<const VXIContent *>(val),
  409.           &type, &recording, &size) != VXIvalue_RESULT_SUCCESS) {
  410.     Error(log, 204, L"%s%s", L"parameter", L"recording");
  411.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  412.   } else if (size < 1) {
  413.     Error(log, 204, L"%s%s%s%d", L"parameter", L"recording.size", 
  414.     L"value", L"size");
  415.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  416.   }
  417.   
  418.   val = VXIMapGetProperty(parameters, L"dest");
  419.   if (! val) {
  420.     Error(log, 202, L"%s%s", L"parameter", L"dest");
  421.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  422.   } else if (VXIValueGetType(val) != VALUE_STRING) {
  423.     Error(log, 203, L"%s%s%s%d", L"parameter", L"dest", 
  424.     L"type", VXIValueGetType(val));
  425.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  426.   }
  427.   dest = VXIStringCStr(reinterpret_cast<const VXIString *>(val));
  428.   if (! dest[0]) {
  429.     Error(log, 204, L"%s%s%s%s", L"parameter", L"dest", L"value", dest);
  430.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  431.   }
  433.   if(execute) {
  434.     // Convert the destination to narrow characters, use an upside
  435.     // down question mark for unsupported Unicode characters
  436.     size_t len = wcslen(dest);
  437.     char *ndest = new char [len + 1];
  438.     if (! ndest) {
  439.       Error(log, 100, NULL);
  440.       return VXIobj_RESULT_OUT_OF_MEMORY;
  441.     }
  442.     for (size_t i = 0; i <= len; i++)
  443.       ndest[i] = (dest[i] & 0xff00 ? '277' : static_cast<char>(dest[i]));
  444.     
  445.     // Open the destination and save the file
  446.     size_t totWritten = 0;
  447. #ifdef VXIOBJECT_PERMIT_FILE_WRITES
  448.     FILE *fp = fopen(ndest, "wb");
  449.     delete [] ndest;
  450.     if (fp) {
  451.       do {
  452.   size_t w = fwrite(&recording[totWritten], 1, 
  453.         ((size_t) size) - totWritten, fp);
  454.   totWritten += w;
  455.       } while ((totWritten < (size_t) size) && (! ferror(fp)));
  456.       
  457.       fclose(fp);
  458.     } else {
  459.       Error(log, 205, L"%s%s%s%d", L"file", dest, L"errno", errno);
  460.     }
  461. #else
  462.     Error(log, 206, L"%s%s", L"file", dest);
  463. #endif
  465.     // Create the result object
  466.     VXIMap *resultObj = VXIMapCreate();
  467.     if(resultObj == NULL) {
  468.       Error(log, 100, NULL);
  469.       return VXIobj_RESULT_OUT_OF_MEMORY;
  470.     }
  471.     *result = reinterpret_cast<VXIValue *>(resultObj);
  473.     // Set the result object's status field to 'success' or 'failure'
  474.     if (totWritten == (size_t) size)
  475.       VXIMapSetProperty(resultObj, L"status",
  476.                reinterpret_cast<VXIValue *>(VXIStringCreate(L"success")));
  477.     else
  478.       VXIMapSetProperty(resultObj, L"status", 
  479.                reinterpret_cast<VXIValue *>(VXIStringCreate(L"failure")));
  480.   }
  482.   return VXIobj_RESULT_SUCCESS;
  483. }
  485. /**
  486.  * Sample object setting the defaults document for subsequent calls
  487.  *
  488.  * @param properties    [IN]  See description in VXIobjectExecute() 
  489.  *                            or VXIobjectValidate()
  490.  * @param parameters    [IN]  See description in VXIobjectExecute() 
  491.  *                            or VXIobjectValidate()
  492.  * @param execute       [IN]  Specifies whether the object should be
  493.  *                            executed (true) or simply validated (false)
  494.  * @param result        [OUT] See description in VXIobjectExecute() 
  495.  *                            or VXIobjectValidate()
  496.  *
  497.  * @result VXIobj_RESULT_SUCCESS on success
  498.  */
  499. static VXIobjResult 
  500. ProcessComSpeechworksSetDefaultsObject (struct VXIobjectInterface *pThis,
  501. const VXIMap              *properties,
  502. const VXIMap              *parameters,
  503. VXIbool                    execute,
  504. VXIValue                 **result)
  505. {
  506.   static const wchar_t func[] = L"ProcessComSpeechworksSetDefaults";
  507.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  509.   if((execute) && (result == NULL)) return VXIobj_RESULT_INVALID_ARGUMENT;
  510.   if((! properties) || (! parameters)) return VXIobj_RESULT_INVALID_ARGUMENT;
  512.   if(execute) {
  514.     const VXIchar *defaults = NULL;
  516.     const VXIValue *val = VXIMapGetProperty(parameters, L"defaults");
  517.     if (! val) {
  518.       Error(log, 202, L"%s%s", L"parameter", L"defaults");
  519.       return VXIobj_RESULT_INVALID_PROP_VALUE;
  520.     } else if (VXIValueGetType(val) != VALUE_STRING) {
  521.       Error(log, 203, L"%s%s%s%d", L"parameter", L"defaults", 
  522.     L"type", VXIValueGetType(val));
  523.       return VXIobj_RESULT_INVALID_PROP_VALUE;
  524.     }
  525.     defaults = VXIStringCStr(reinterpret_cast<const VXIString *>(val));
  526.     if (! defaults[0]) {
  527.       Error(log, 204, L"%s%s%s%s", L"parameter", L"defaults", L"value", defaults);
  528.       return VXIobj_RESULT_INVALID_PROP_VALUE;
  529.     }
  531.     
  532.     // Hack to set the defaults document
  533.     VXIobjectAPI *objectAPI = (VXIobjectAPI *) pThis;
  534.     if ( ! objectAPI ) { rc = VXIobj_RESULT_INVALID_ARGUMENT; return rc; }
  535.     VXIplatform *plat = objectAPI->resources->platform;
  536.     VXIMap *vxiProperties = VXIMapCreate();
  537.     VXIString * valstr = VXIStringCreate(defaults);
  538.     VXIMapSetProperty(vxiProperties, VXI_PLATFORM_DEFAULTS, (VXIValue *) valstr);
  539.     plat->VXIinterpreter->SetProperties(plat->VXIinterpreter,
  540. vxiProperties);
  542.     // Create the result object
  543.     VXIMap *resultObj = VXIMapCreate();
  544.     if(resultObj == NULL) {
  545.       Error(log, 100, NULL);
  546.       return VXIobj_RESULT_OUT_OF_MEMORY;
  547.     }
  548.     *result = reinterpret_cast<VXIValue *>(resultObj);
  550.     // Set the result object's status field to 'success'
  551.     VXIMapSetProperty(resultObj, L"status",
  552.       reinterpret_cast<VXIValue *>(VXIStringCreate(L"success")));
  553.   }
  555.   return VXIobj_RESULT_SUCCESS;
  556. }
  558. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  560. /**
  561.  * @name GetVersion
  562.  * @memo Get the VXI interface version implemented
  563.  *
  564.  * @return  VXIint32 for the version number. The high high word is 
  565.  *          the major version number, the low word is the minor version 
  566.  *          number, using the native CPU/OS byte order. The current
  567.  *          version is VXI_CURRENT_VERSION as defined in VXItypes.h.
  568.  */ 
  569. static
  570. VXIint32 VXIobjectGetVersion(void)
  571. {
  572.   return VXI_CURRENT_VERSION;
  573. }
  576. /**
  577.  * @name GetImplementationName
  578.  * @memo Get the name of the implementation
  579.  *
  580.  * @return  Implementation defined string that must be different from
  581.  *          all other implementations. The recommended name is one
  582.  *          where the interface name is prefixed by the implementator's
  583.  *          Internet address in reverse order, such as com.xyz.rec for
  584.  *          VXIobject from xyz.com. This is similar to how VoiceXML 1.0
  585.  *          recommends defining application specific error types.
  586.  */
  587. static
  588. const VXIchar* VXIobjectGetImplementationName(void)
  589. {
  590.   return VXIOBJECT_IMPLEMENTATION_NAME;
  591. }
  594. /**
  595.  * Execute an object
  596.  *
  597.  * @param properties  [IN] Map containing properties and attributes for
  598.  *                      the <object> as specified above.
  599.  * @param parameters  [IN] Map containing parameters for the <object> as
  600.  *                      specified by the VoiceXML <param> tag. The keys
  601.  *                      of the map correspond to the parameter name ("name"
  602.  *                      attribute) while the value of each key corresponds
  603.  *                      to a VXIValue based type.
  604.  *
  605.  *                      For each parameter, any ECMAScript expressions are
  606.  *                      evaluated by the interpreter. Then if the "valuetype"
  607.  *                      attribute is set to "ref" the parameter value is
  608.  *                      packaged into a VXIMap with three properties:
  609.  *
  610.  *                      OBJECT_VALUE:       actual parameter value
  611.  *                      OBJECT_VALUETYPE:   "valuetype" attribute value
  612.  *                      OBJECT_TYPE:        "type" attribute value
  613.  *
  614.  *                      Otherwise a primitive VXIValue based type will
  615.  *                      be used to specify the value.
  616.  * @param result      [OUT] Return value for the <object> execution, this
  617.  *                      is allocated on success, the caller is responsible
  618.  *                      for destroying the returned value by calling 
  619.  *                      VXIValueDestroy( ). The object's field variable
  620.  *                      will be set to this value.
  621.  *
  622.  * @return        VXIobj_RESULT_SUCCESS on success,
  623.  *                VXIobj_RESULT_NON_FATAL_ERROR on error, 
  624.  *                VXIobj_RESULT_UNSUPPORTED for unsupported object types
  625.  *                 (this will cause interpreter to throw the correct event)
  626.  */
  627. static
  628. VXIobjResult VXIobjectExecute(struct VXIobjectInterface *pThis,
  629.                               const VXIMap              *properties,
  630.                               const VXIMap              *parameters,
  631.                               VXIValue                  **result)
  632. {
  633.   static const wchar_t func[] = L"VXIobjectExecute";
  634.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  635.   Diag (log, LOG_API, func, L"entering: 0x%p, 0x%p, 0x%p, 0x%p", 
  636.   pThis, properties, parameters, result);
  637.   
  638.   if(properties == NULL) {
  639.     Error (log, 200, NULL);
  640.     return VXIobj_RESULT_INVALID_ARGUMENT;
  641.   }
  643.   ShowPropertyValue(properties, log);
  645.   // Get the name of the object to execute
  646.   const VXIValue *val = VXIMapGetProperty(properties, OBJECT_CLASS_ID);
  647.   if(val == NULL) {
  648.     Error(log, 202, L"%s%s", L"parameter", OBJECT_CLASS_ID);
  649.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  650.   } else if (VXIValueGetType(val) != VALUE_STRING) {
  651.     Error(log, 203, L"%s%s%s%d", L"parameter", OBJECT_CLASS_ID,
  652.     L"type", VXIValueGetType(val));
  653.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  654.   }
  655.   const VXIchar *classID = VXIStringCStr((VXIString *)val);
  657.   // Handle the object
  658.   if (::wcscmp(classID, L"com.vocalocity.diag") == 0) {
  659.     //
  660.     // Sample diagnostic logging object.
  661.     // 
  662.     rc = ProcessComSpeechworksDiagObject(pThis, properties, parameters, true,
  663.            result);
  664.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  665.   } 
  666.   else if (::wcscmp(classID, L"com.vocalocity.echo") == 0) {
  667.     //
  668.     // Sample object echoing back all attributes and parameters
  669.     // 
  670.     rc = ProcessComSpeechworksEchoObject(pThis, properties, parameters, true,
  671.            result);
  672.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  673.   } 
  674.   else if (::wcscmp(classID, L"com.vocalocity.saveRecording") == 0) {
  675.     //
  676.     // Sample object that saves a recording to a file
  677.     // 
  678.     rc = ProcessComSpeechworksSaveRecordingObject(pThis, properties, 
  679.               parameters, true, result);
  680.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  681.   } 
  682.   else if (::wcscmp(classID, L"com.vocalocity.setDefaults") == 0) {
  683.     //
  684.     // Sample object that sets the defaults document for subsequent
  685.     // calls. This is really a hack and not recommended. This was
  686.     // done more for fun than any value.
  687.     // 
  688.     rc = ProcessComSpeechworksSetDefaultsObject(pThis, properties, 
  689.               parameters, true, result);
  690.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  691.   } 
  692.   else {
  693.     //
  694.     // Unsupported object
  695.     //
  696.     rc = VXIobj_RESULT_UNSUPPORTED;
  697.   }
  699.   Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  700.   return rc;
  701. }
  704. /**
  705.  * Validate an object, performing validity checks without execution
  706.  *
  707.  * @param properties  [IN] Map containing properties and attributes for
  708.  *                      the <object> as specified in the VoiceXML
  709.  *                      specification except that "expr" and "cond" are
  710.  *                      always omitted (are handled by the interpreter).
  711.  * @param parameters  [IN] Map containing parameters for the <object> as
  712.  *                      specified by the VoiceXML <param> tag. The keys
  713.  *                      of the map correspond to the parameter name ("name"
  714.  *                      attribute) while the value of each key corresponds
  715.  *                      to a VXIValue based type. See Execute( ) above 
  716.  *                      for details.
  717.  *
  718.  * @return        VXIobj_RESULT_SUCCESS on success,
  719.  *                VXIobj_RESULT_NON_FATAL_ERROR on error, 
  720.  *                VXIobj_RESULT_UNSUPPORTED for unsupported object types
  721.  *                 (this will cause interpreter to throw the correct event)
  722.  */
  723. static
  724. VXIobjResult VXIobjectValidate(struct VXIobjectInterface *pThis,
  725.                                const VXIMap              *properties,
  726.                                const VXIMap              *parameters)
  727. {
  728.   static const wchar_t func[] = L"VXIobjectValidate";
  729.   GET_VXIOBJECT (pThis, sbObject, log, rc);
  730.   Diag (log, LOG_API, func, L"entering: 0x%p, 0x%p, 0x%p", 
  731.   pThis, properties, parameters);
  733.   if(properties == NULL) {
  734.     Error (log, 201, NULL);
  735.     return VXIobj_RESULT_INVALID_ARGUMENT;
  736.   }
  738.   // Get the name of the object to execute
  739.   const VXIValue *val = VXIMapGetProperty(properties, OBJECT_CLASS_ID);
  740.   if(val == NULL) {
  741.     Error(log, 202, L"%s%s", L"parameter", OBJECT_CLASS_ID);
  742.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  743.   } else if (VXIValueGetType(val) != VALUE_STRING) {
  744.     Error(log, 203, L"%s%s%s%d", L"parameter", OBJECT_CLASS_ID,
  745.     L"type", VXIValueGetType(val));
  746.     return VXIobj_RESULT_INVALID_PROP_VALUE;
  747.   }
  748.   const VXIchar *classID = VXIStringCStr((VXIString *)val);
  750.   // Handle the object
  751.   if (::wcscmp(classID, L"com.vocalocity.diag") == 0) {
  752.     //
  753.     // Sample diagnostic logging object
  754.     // 
  755.     rc = ProcessComSpeechworksDiagObject(pThis, properties, parameters, false,
  756.            NULL);
  757.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  758.   }
  759.   else if (::wcscmp(classID, L"com.vocalocity.echo") == 0) {
  760.     //
  761.     // Sample object echoing back all attributes and parameters
  762.     // 
  763.     rc = ProcessComSpeechworksEchoObject(pThis, properties, parameters, false,
  764.            NULL);
  765.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  766.   } 
  767.   else if (::wcscmp(classID, L"com.vocalocity.saveRecording") == 0) {
  768.     //
  769.     // Sample object that saves a recording to a file
  770.     // 
  771.     rc = ProcessComSpeechworksSaveRecordingObject(pThis, properties, 
  772.               parameters, false, NULL);
  773.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  774.   } 
  775.   else if (::wcscmp(classID, L"com.vocalocity.setDefaults") == 0) {
  776.     //
  777.     // Sample object that sets the defaults document for subsequent
  778.     // calls. This is really a hack and not recommended. This was
  779.     // done more for fun than any value.
  780.     // 
  781.     rc = ProcessComSpeechworksSetDefaultsObject(pThis, properties, 
  782.               parameters, false, NULL);
  783.     if(rc != VXIobj_RESULT_SUCCESS) rc = VXIobj_RESULT_NON_FATAL_ERROR;
  784.   } 
  785.   else {
  786.     //
  787.     // Unsupported object
  788.     //
  789.     rc = VXIobj_RESULT_UNSUPPORTED;
  790.   }
  792.   Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  793.   return rc;
  794. }
  796. // -----1=0-------2=0-------3=0-------4=0-------5=0-------6=0-------7=0-------8
  798. /**
  799.  * Global platform initialization of VXIobject
  800.  *
  801.  * @param log            VXI Logging interface used for error/diagnostic 
  802.  *                       logging, only used for the duration of this 
  803.  *                       function call
  804.  * @param  diagLogBase   Base tag number for diagnostic logging purposes.
  805.  *                       All diagnostic tags for VXIobject will start at this
  806.  *                       ID and increase upwards.
  807.  *
  808.  * @result VXIobj_RESULT_SUCCESS on success
  809.  */
  810. VXIOBJECT_API_EX VXIobjResult 
  811. VXIobjectInit (VXIlogInterface  *log,
  812.                VXIunsigned       diagLogBase)
  813. {
  814.   static const wchar_t func[] = L"VXIobjectInit";
  815.   gblDiagLogBase = diagLogBase;
  816.   Diag (log, LOG_API, func, L"entering: 0x%p, %u", log, diagLogBase);
  818.   VXIobjResult rc = VXIobj_RESULT_SUCCESS;
  819.   if (gblInitialized == true) {
  820.     rc = VXIobj_RESULT_FATAL_ERROR;
  821.     Error (log, 101, NULL);
  822.     Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  823.     return rc;
  824.   }
  826.   if ( ! log )
  827.     return VXIobj_RESULT_INVALID_ARGUMENT;
  829.   // Return
  830.   gblInitialized = true;
  832.   Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  833.   return rc;
  834. }
  836. /**
  837.  * Global platform shutdown of VXIobject
  838.  *
  839.  * @param log    VXI Logging interface used for error/diagnostic logging,
  840.  *               only used for the duration of this function call
  841.  *
  842.  * @result VXIobj_RESULT_SUCCESS on success
  843.  */
  844. VXIOBJECT_API_EX VXIobjResult 
  845. VXIobjectShutDown (VXIlogInterface  *log)
  846. {
  847.   static const wchar_t func[] = L"VXIobjectShutDown";
  848.   Diag (log, LOG_API, func, L"entering: 0x%p",log);
  850.   VXIobjResult rc = VXIobj_RESULT_SUCCESS;
  851.   if (gblInitialized == false) {
  852.     rc = VXIobj_RESULT_FATAL_ERROR;
  853.     Error (log, 102, NULL);
  854.     Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  855.     return rc;
  856.   }
  858.   if ( ! log )
  859.     return VXIobj_RESULT_INVALID_ARGUMENT;
  861.   gblInitialized = false;
  863.   Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  864.   return rc;
  865. }
  867. /**
  868.  * Create a new object service handle
  869.  *
  870.  * @param resources  A pointer to a structure containing all the interfaces
  871.  *                   that may be required by the object resource
  872.  *
  873.  * @result VXIobj_RESULT_SUCCESS on success 
  874.  */
  875. VXIOBJECT_API_EX VXIobjResult 
  876. VXIobjectCreateResource(VXIobjectResources   *resources,
  877.                         VXIobjectInterface   **object)
  878. {
  879.   static const wchar_t func[] = L"VXIobjectCreateResource";
  880.   VXIlogInterface *log = NULL;
  881.   if (( resources ) && ( resources->log )) {
  882.     log = resources->log;
  883.     Diag (log, LOG_API, func, L"entering: 0x%p, 0x%p", resources, object);
  884.   }
  886.   VXIobjResult rc = VXIobj_RESULT_SUCCESS;
  887.   if (gblInitialized == false) {
  888.     rc = VXIobj_RESULT_FATAL_ERROR;
  889.     Error (log, 102, NULL);
  890.     Diag (log, LOG_API, func, L"exiting: returned %d, 0x%p",
  891.     rc, (object ? *object : NULL));
  892.     return rc;
  893.   }
  895.   if (( ! log ) || ( ! resources ) || ( ! object )) {
  896.     rc = VXIobj_RESULT_INVALID_ARGUMENT;
  897.     Error (log, 103, NULL);
  898.     Diag (log, LOG_API, func, L"exiting: returned %d, 0x%p",
  899.     rc, (object ? *object : NULL));
  900.     return rc;
  901.   }
  903.   *object = NULL;
  905.   // Get a new interface instance
  906.   VXIobjectAPI *newObject = new VXIobjectAPI;
  907.   if (newObject == false) {
  908.     rc = VXIobj_RESULT_OUT_OF_MEMORY;
  909.     Error (log, 100, NULL);
  910.     Diag (log, LOG_API, func, L"exiting: returned %d, 0x%p", rc, *object);
  911.     return rc;
  912.   }
  913.   memset (newObject, 0, sizeof (VXIobjectAPI));
  915.   // Initialize the function pointers
  916.   newObject->object.GetVersion            = VXIobjectGetVersion;
  917.   newObject->object.GetImplementationName = VXIobjectGetImplementationName;
  918.   newObject->object.Execute               = VXIobjectExecute;
  919.   newObject->object.Validate              = VXIobjectValidate;
  921.   // Initialize data members
  922.   newObject->resources = resources;
  924.   // Return the object
  925.   if ( rc != VXIobj_RESULT_SUCCESS ) {
  926.     if ( newObject )
  927.       delete newObject;
  928.   } else {
  929.     *object = &(newObject->object);
  930.   }
  932.   Diag (log, LOG_API, func, L"exiting: returned %d, 0x%p", rc, *object);
  933.   return rc;
  934. }
  936. /**
  937.  * Destroy the interface and free internal resources. Once this is
  938.  *  called, the resource interfaces passed to VXIobjectCreateResource( )
  939.  *  may be released as well.
  940.  *
  941.  * @result VXIobj_RESULT_SUCCESS on success 
  942.  */
  943. VXIOBJECT_API_EX VXIobjResult
  944. VXIobjectDestroyResource(VXIobjectInterface **object)
  945. {
  946.   VXIobjResult rc = VXIobj_RESULT_SUCCESS;
  947.   static const wchar_t func[] = L"VXIobjectDestroyResource";
  948.   // Can't log yet, don't have a log handle
  950.   if (gblInitialized == false)
  951.     return VXIobj_RESULT_FATAL_ERROR;
  953.   if ((object == NULL) || (*object == NULL))
  954.     return VXIobj_RESULT_INVALID_ARGUMENT;
  956.   // Get the real underlying interface
  957.   VXIobjectAPI *objectAPI = (VXIobjectAPI *) *object;
  959.   VXIlogInterface *log = objectAPI->resources->log;
  960.   Diag (log, LOG_API, func, L"entering: 0x%p (0x%p)", object, *object);
  962.   // Delete the object
  963.   delete objectAPI;
  964.   *object = NULL;
  966.   Diag (log, LOG_API, func, L"exiting: returned %d", rc);
  967.   return rc;
  968. }