VXIcache.h
上传用户:xqtpzdz
上传日期:2022-05-21
资源大小:1764k
文件大小:23k
源码类别:

xml/soap/webservice

开发平台:

Visual C++

  1. /****************License************************************************
  2.  * Vocalocity OpenVXI
  3.  * Copyright (C) 2004-2005 by Vocalocity, Inc. All Rights Reserved.
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *  
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  * Vocalocity, the Vocalocity logo, and VocalOS are trademarks or 
  18.  * registered trademarks of Vocalocity, Inc. 
  19.  * OpenVXI is a trademark of Scansoft, Inc. and used under license 
  20.  * by Vocalocity.
  21.  ***********************************************************************/
  22. #ifndef _VXICACHE_H
  23. #define _VXICACHE_H
  24. #include "VXIvalue.h"                  /* For VXIMap, VXIString, etc. */
  25. #include "VXIheaderPrefix.h"
  26. #ifdef VXICACHE_EXPORTS
  27. #define VXICACHE_API SYMBOL_EXPORT_DECL
  28. #else
  29. #define VXICACHE_API SYMBOL_IMPORT_DECL
  30. #endif
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif
  34. #ifdef __cplusplus
  35. struct VXIcacheStream;
  36. #else
  37. typedef struct VXIcacheStream { void * dummy; } VXIcacheStream;
  38. #endif
  39. /**
  40.  * defgroup VXIcache Cache Interface 
  41.  *
  42.  * Abstract interface for accessing caching functionality, which
  43.  * permits writing arbitrary data into the cache with a client
  44.  * supplied key name, then retrieving that data from the cache one or
  45.  * more times by reading against that key name. <p>
  46.  *
  47.  * Normally the cache implementation can choose to discard the data
  48.  * between the write and the read when necessary (due to running out
  49.  * of cache space, etc.), but it is also possible for clients to lock
  50.  * data in the cache to support built-in grammars and other data that
  51.  * is explicitly provisioned by system administrators and thus must
  52.  * not be removed unless by explicit system administrator command. <p>
  53.  * The interface is a synchronous interface based on the ANSI/ISO C
  54.  * standard file I/O interface. The client of the interface may use this in
  55.  * an asynchronous manner by using non-blocking I/O operations,
  56.  * creating threads, or by invoking this from a separate server
  57.  * process. <p>
  58.  * 
  59.  * Typically the key name specified by clients will be the URL to the
  60.  * source form of the data that is being written back, such as the URL
  61.  * to the grammar text being used as the key name for the compiled
  62.  * grammar. In the case where the VXIinet and VXIcache implementations
  63.  * share the same underlying cache storage, it is thus necessary to
  64.  * use prefixes or some other namespace mechanism to avoid collisions
  65.  * with the cache entry for the original URL. <p>
  66.  *
  67.  * However, the key names specified by clients may be very large in
  68.  * some cases. This is most common when writing back data generated
  69.  * from in-memory source text, such as when writing back the compiled
  70.  * grammar for a VoiceXML document in-line grammar.  One possible
  71.  * VXIcache implementation approach is to use the MD5 algorithm as
  72.  * used in HTTP message headers (specified in RFC 1321 with a full
  73.  * implementation provided) to convert long key names to a 16 byte MD5
  74.  * value for indexing purposes, using Base64 encoding to convert the
  75.  * binary MD5 value to ASCII text if desired (as done in HTTP message
  76.  * headers). <p>
  77.  *
  78.  * There is one cache interface per thread/line. <p> 
  79.  */
  80. /*@{*/
  81. /*
  82.  * Keys identifying properties in VXIMap for Open( ), see below for
  83.  * valid values for the enumerated type properties.
  84.  */
  85. #define CACHE_CREATION_COST      L"cache.creationCost"       /* VXIInteger */
  86. /**
  87.  * Provides a hint on how much CPU/time went into creating the
  88.  * object being written cache.  
  89.  * 
  90.  * Enumerated CACHE_CREATION_COST property values. The creation costs
  91.  * property permits prioritizing the cache so low cost objects are
  92.  * flushed before high cost objects (for example, try to keep compiled
  93.  * grammars which have a high creation cost over keeping audio
  94.  * recordings that were simply fetched). Note that implementations may
  95.  * ignore this hint.
  96.  */
  97. typedef enum VXIcacheCreationCost {
  98.   /** Extremely high */
  99.   CACHE_CREATION_COST_EXTREME         = 40,
  100.   /** High */
  101.   CACHE_CREATION_COST_HIGH            = 30,
  102.   /** Medium */
  103.   CACHE_CREATION_COST_MEDIUM          = 20,
  104.   /** Low */
  105.   CACHE_CREATION_COST_LOW             = 10,
  106.   /** Only the cost of a fetch */
  107.   CACHE_CREATION_COST_FETCH          =   0
  108. } VXIcacheCreationCost;
  109. /**
  110.  * Default cache creation cost
  111.  */
  112. #define CACHE_CREATION_COST_DEFAULT        CACHE_CREATION_COST_LOW
  113. /**
  114.  * Mode values for VXIcache::Open( )
  115.  * Open supports ANSI/ISO C standard I/O open modes
  116.  */
  117. typedef enum VXIcacheOpenMode { 
  118.   /** Open for reading */
  119.   CACHE_MODE_READ         = 0x0,
  120.   /** Open for writing */
  121.   CACHE_MODE_WRITE        = 0x1,
  122.   /** Atomic operation to open for reading if the entry exists
  123.       (VXIcache_RESULT_SUCCESS returned), otherwise open it for
  124.       writing (VXIcache_RESULT_ENTRY_CREATED returned). This is 
  125.       only available as of version 1.1 of the VXIcacheInterface,
  126.       use CACHE_MODE_READ_CREATE_SUPPORTED( ) to determine
  127.       availability. **/
  128.   CACHE_MODE_READ_CREATE  = 0x2
  129. } VXIcacheOpenMode;
  130. /** 
  131.  * @name Cache Flags
  132.  * Set of flags which control the caching behavior of the data
  133.  * put into the cache.<p>
  134.  * The Open() call takes  bitwise or of cache flags which control
  135.  * the caching behavior of data which is written or read from the
  136.  * cache.
  137.  */
  138. /*@{*/
  139. /** Null flag.  This causes the cache to use its default behavior on cache
  140.       locking and management */
  141. #define CACHE_FLAG_NULL            0x0
  142. /** Never flush from the cache.  This locks the file on disk for the
  143.       duration of the process.  This flag may be bitwise combined through OR 
  144.       with the other CACHE_FLAG defines in the call to Open(). */
  145. #define CACHE_FLAG_LOCK            0x2     
  146. /** Never flush from memory.  This locks the data in memory. This lock
  147.       option is only a hint, some implementations may ignore this and
  148.       interpret it as CACHE_FLAG_LOCK. */
  149. #define CACHE_FLAG_LOCK_MEMORY     0x4  
  150. /** Non-blocking reads/writes. Do all I/O using non-blocking operations. */
  151. #define CACHE_FLAG_NONBLOCKING_IO  0x8     
  152. /*@}*/
  153. /** 
  154.   @name Cache Open Properties
  155.   Set of properties that are returned on the Open() of an
  156.   existing cache entry.<p>
  157.   The Open() call returns a VXIMap which contains a set of
  158.   key/value properties.  This set of defines provides the definition
  159.   of the properties that must be supported by an implementation of Open().
  160.   */
  161. /*@{*/
  162. /** Final key name used for storing the cache entry. This may differ 
  163.     from the original key name specified for Open( ) in cases where that 
  164.     original key name was very large and the implementation used a MD5 
  165.     digest or other mechanism to compress it.  While the user may still
  166.     obtain access to the entry using the original key name, it may opt
  167.     to use this final key name instead in order to reduce its own memory
  168.     use.  This is returned as a VXIString.
  169.   */
  170. #define CACHE_INFO_FINAL_KEY      L"cache.info.finalKey"
  171. /** Last Modifed time.  This is a property in the VXIMap used to
  172.     return cache information on Open(). It returns the last modified date 
  173.     and time for the entry. This is returned as a VXIInteger. 
  174.   */
  175. #define CACHE_INFO_LAST_MODIFIED  L"cache.info.lastModified"
  176. /** Size in bytes.  This property of the VXIMap is used to return
  177.     cache information on the size of the cache entry in bytes as a 
  178.     VXIInteger.
  179.   */
  180. #define CACHE_INFO_SIZE_BYTES     L"cache.info.sizeBytes"
  181. /*@}*/
  182. /*
  183.  * Macros to determine the availability of new methods
  184.  */
  185. #define CACHE_OPENEX_SUPPORTED(cacheIntf) 
  186.   (cacheIntf->GetVersion( ) >= 0x00010001)
  187. #define CACHE_CLOSEEX_SUPPORTED(cacheIntf) 
  188.   (cacheIntf->GetVersion( ) >= 0x00010001)
  189. #define CACHE_UNLOCKEX_SUPPORTED(cacheIntf) 
  190.   (cacheIntf->GetVersion( ) >= 0x00010001)
  191. #define CACHE_MODE_READ_CREATE_SUPPORTED(cacheIntf) 
  192.   (cacheIntf->GetVersion( ) >= 0x00010001)
  193. /**
  194.  * VXIcache return codes.
  195.  *
  196.  * Result codes less then zero are severe errors (likely to be
  197.  * platform faults), those greater then zero are warnings (likely to
  198.  * be application issues) 
  199.  */
  200. typedef enum VXIcacheResult {
  201.   /** Fatal error, terminate call    */
  202.   VXIcache_RESULT_FATAL_ERROR       =  -100, 
  203.   /** I/O error                      */
  204.   VXIcache_RESULT_IO_ERROR           =   -8,
  205.   /** Out of memory                  */
  206.   VXIcache_RESULT_OUT_OF_MEMORY      =   -7, 
  207.   /** System error, out of service   */
  208.   VXIcache_RESULT_SYSTEM_ERROR       =   -6, 
  209.   /** Errors from platform services  */
  210.   VXIcache_RESULT_PLATFORM_ERROR     =   -5, 
  211.   /** Return buffer too small        */
  212.   VXIcache_RESULT_BUFFER_TOO_SMALL   =   -4, 
  213.   /** Property name is not valid    */
  214.   VXIcache_RESULT_INVALID_PROP_NAME  =   -3, 
  215.   /** Property value is not valid   */
  216.   VXIcache_RESULT_INVALID_PROP_VALUE =   -2, 
  217.   /** Invalid function argument      */
  218.   VXIcache_RESULT_INVALID_ARGUMENT   =   -1, 
  219.   /** Success                        */
  220.   VXIcache_RESULT_SUCCESS            =    0,
  221.   /** Normal failure, nothing logged */
  222.   VXIcache_RESULT_FAILURE            =    1,
  223.   /** Non-fatal non-specific error   */
  224.   VXIcache_RESULT_NON_FATAL_ERROR    =    2, 
  225.   /** Named data not found           */
  226.   VXIcache_RESULT_NOT_FOUND          =   50, 
  227.   /** I/O operation would block      */
  228.   VXIcache_RESULT_WOULD_BLOCK        =   53,
  229.   /** End of stream                  */
  230.   VXIcache_RESULT_END_OF_STREAM      =   54,
  231.   /** Buffer exceeds maximum size    */
  232.   VXIcache_RESULT_EXCEED_MAXSIZE     =   55,
  233.   /** Entry in the cache in currently in used and is locked   */
  234.   VXIcache_RESULT_ENTRY_LOCKED       =   56,
  235.   /** CACHE_MODE_READ_WRITE requested and the entry did not exist so a
  236.       write stream to the new entry is being returned */
  237.   VXIcache_RESULT_ENTRY_CREATED      =   57,
  238.   /** Operation is not supported     */
  239.   VXIcache_RESULT_UNSUPPORTED        =  100
  240. } VXIcacheResult;
  241. /**
  242.  * Abstract interface for accessing caching functionality.
  243.  *
  244.  * Permits writing arbitrary data into the cache with a client
  245.  * supplied key name, then retrieving that data from the cache one or
  246.  * more times by reading against that key name. <p>
  247.  */
  248. typedef struct VXIcacheInterface {
  249.   /**
  250.    * Get the VXI interface version implemented
  251.    *
  252.    * @return  VXIint32 for the version number. The high high word is 
  253.    *          the major version number, the low word is the minor version 
  254.    *          number, using the native CPU/OS byte order. The current
  255.    *          version is VXI_CURRENT_VERSION as defined in VXItypes.h.
  256.    */ 
  257.   VXIint32 (*GetVersion)(void);
  258.   
  259.   /**
  260.    * Get the name of the implementation
  261.    *
  262.    * @return  Implementation defined string that must be different from
  263.    *          all other implementations. The recommended name is one
  264.    *          where the interface name is prefixed by the implementator's
  265.    *          Internet address in reverse order, such as com.xyz.rec for
  266.    *          VXIrec from xyz.com. This is similar to how VoiceXML 1.0
  267.    *          recommends defining application specific error types.
  268.    */
  269.   const VXIchar* (*GetImplementationName)(void);
  270.   
  271.   /**
  272.    * Open a stream for reading or writing given a wide character key
  273.    *
  274.    * NOTE: OpenEx( ) is the same but supports binary keys
  275.    *
  276.    * If the cache entry is currently in use and a stream cannot be returned
  277.    * because this use locks the entry, Open should return 
  278.    * VXIcache_RESULT_ENTRY_LOCKED. <p>
  279.    *
  280.    * The behavior of opening a cache entry for reading during a write
  281.    * operation is implementation defined. <p>
  282.    *
  283.    * @param moduleName   [IN] Name of the software module that is 
  284.    *                       writing or reading the data. See the top of 
  285.    *                       VXIlog.h for moduleName allocation rules.
  286.    * @param key          [IN] Key name of the data to access, NULL
  287.    *                       terminated VXIchar based string that may be
  288.    *                       of an arbitrary length
  289.    * @param mode         [IN] Mode to open the data with, a CACHE_MODE
  290.    *                       value as defined above
  291.    * @param flags        [IN] Flags to control the open:
  292.    *                     CACHE_FLAG_LOCK, lock retrieved data in the
  293.    *                       cache so it is not flushed (although may be
  294.    *                       flushed from the memory cache to the disk cache)
  295.    *                     CACHE_FLAG_LOCK_MEMORY, lock retrieved data
  296.    *                       in the memory cache so it is not flushed
  297.    *                       (not even to the disk cache), note that some
  298.    *                       implementations may ignore this and simply
  299.    *                       treat this as CACHE_FLAG_LOCK.
  300.    *                     CACHE_FLAG_NONBLOCKING_IO, non-blocking reads and
  301.    *                       writes, although the open and close is still
  302.    *                       blocking
  303.    * @param properties   [IN] Properties to control the open, as listed
  304.    *                       above. May be NULL.
  305.    * @param streamInfo   [OUT] (Optional, pass NULL if not required.) Map
  306.    *                       that will be populated with information about 
  307.    *                       the stream, the CACHE_INFO_[...] keys listed
  308.    *                       above are mandatory with the implementation 
  309.    *                       possibly setting other keys.  This may not be 
  310.    *                       populated on an open for WRITE since that is 
  311.    *                       creating a new file.
  312.    * @param stream       [OUT] Handle to the opened stream
  313.    *
  314.    * @return VXIcache_RESULT_SUCCESS on success
  315.    * @return VXIcache_RESULT_ENTRY_LOCKED if the entry is in used and 
  316.    *           cannot be returned. Returned if a writer has the entry open.
  317.    * @return VXIcache_RESULT_NULL_STREAM if the stream that was passed in 
  318.    *           or the interface is NULL 
  319.    */
  320.   VXIcacheResult (*Open)(struct VXIcacheInterface  *pThis,
  321.  const VXIchar             *moduleName,
  322.  const VXIchar             *key,
  323.  VXIcacheOpenMode           mode,
  324.  VXIint32                   flags,
  325.  const VXIMap              *properties,
  326.  VXIMap                    *streamInfo,
  327.  VXIcacheStream           **stream);
  328.   /**
  329.    * Close a previously opened stream
  330.    *
  331.    * NOTE: CloseEx( ) is the same but supports invalidating the entry
  332.    *
  333.    * Close a previously opened stream.  If Close is called on 
  334.    * a NULL stream or a previously closed stream an error will be
  335.    * returned
  336.    *
  337.    * @param stream       [IN/OUT] Stream to close, set to NULL on
  338.    *                       success
  339.    *
  340.    * @return VXIcache_RESULT_SUCCESS on success
  341.    */
  342.   VXIcacheResult (*Close)(struct VXIcacheInterface  *pThis,
  343.   VXIcacheStream           **stream);
  344.   
  345.   /**
  346.    * Unlock an entry that was previously locked into the cache given
  347.    * a wide character key
  348.    *
  349.    * NOTE: UnlockEx( ) is the same but supports binary keys
  350.    *
  351.    * This releases a cache lock on the indicated data. Note that it
  352.    * is up to the implementation to decide when to flush the data
  353.    * from the cache, it may choose to do so immediately or may
  354.    * do so at a later time.
  355.    *
  356.    * @param key          [IN] Key name of the data to access, NULL
  357.    *                       terminated VXIchar based string that may be
  358.    *                       of an arbitrary length
  359.    *
  360.    * @return VXIcache_RESULT_SUCCESS on success
  361.    */
  362.   VXIcacheResult (*Unlock)(struct VXIcacheInterface *pThis,
  363.    const VXIchar            *key);
  364.   /**
  365.    * Read from a stream
  366.    *
  367.    * This may or not block, as determined by the flags used when
  368.    * opening the stream. When in non-blocking mode, partial buffers
  369.    * may be returned instead of blocking, or an
  370.    * VXIcache_RESULT_WOULD_BLOCK error is returned if no data is
  371.    * available at all.
  372.    *
  373.    * @param buffer   [OUT] Buffer that will receive data from the stream
  374.    * @param buflen   [IN] Length of buffer, in bytes
  375.    * @param nread    [OUT] Number of bytes actual read, may be less then
  376.    *                   buflen if the end of the stream was found, or if
  377.    *                   using non-blocking I/O and there is currently no
  378.    *                   more data available to read
  379.    * @param stream   [IN] Handle to the stream to read from
  380.    *
  381.    * @return VXIcache_RESULT_SUCCESS on success 
  382.    */
  383.   VXIcacheResult (*Read)(struct VXIcacheInterface *pThis,
  384.  VXIbyte                  *buffer,
  385.  VXIulong                  buflen,
  386.  VXIulong                 *nread,
  387.  VXIcacheStream           *stream);
  388.   
  389.   /**
  390.    * Write to a stream
  391.    *
  392.    * This may or not block, as determined by the flags used when
  393.    * opening the stream. When in non-blocking mode, partial writes may
  394.    * occur instead of blocking, or an VXIcache_RESULT_WOULD_BLOCK
  395.    * error is returned if no data could be written at all.
  396.    *
  397.    * @param buffer   [OUT] Buffer of data to write to the stream
  398.    * @param buflen   [IN] Number of bytes to write
  399.    * @param nread    [OUT] Number of bytes actual written, may be less then
  400.    *                   buflen if an error is returned, or if using 
  401.    *                   non-blocking I/O and the write operation would block
  402.    * @param stream   [IN] Handle to the stream to write to
  403.    *
  404.    * @return VXIcache_RESULT_SUCCESS on success 
  405.    */
  406.   VXIcacheResult (*Write)(struct VXIcacheInterface *pThis,
  407.   const VXIbyte            *buffer,
  408.   VXIulong                  buflen,
  409.   VXIulong                 *nwritten,
  410.   VXIcacheStream           *stream);
  411.   /**
  412.    * Open a stream for reading or writing given a binary key.
  413.    *
  414.    * NOTE: Same as Open( ) but supports binary keys. This is only 
  415.    *       available as of version 1.1 of the VXIcacheInterface, use
  416.    *       CACHE_OPENEX_SUPPORTED( ) to determine availability.<p>
  417.    *
  418.    * If the cache entry is currently in use and a stream cannot be returned
  419.    * because this use locks the entry, Open should return 
  420.    * VXIcache_RESULT_ENTRY_LOCKED. <p>
  421.    *
  422.    * The behavior of opening a cache entry for reading during a write
  423.    * operation is implementation defined. <p>
  424.    *
  425.    * @param moduleName   [IN] Name of the software module that is 
  426.    *                       writing or reading the data. See the top of 
  427.    *                       VXIlog.h for moduleName allocation rules.
  428.    * @param key          [IN] Key name of the data to access, binary
  429.    *                       data (raw bytes) of an arbitrary length
  430.    * @param keySizeBytes [IN] Size of the key name in bytes
  431.    * @param mode         [IN] Mode to open the data with, a CACHE_MODE
  432.    *                       value as defined above
  433.    * @param flags        [IN] Flags to control the open:
  434.    *                     CACHE_FLAG_LOCK, lock retrieved data in the
  435.    *                       cache so it is not flushed (although may be
  436.    *                       flushed from the memory cache to the disk cache)
  437.    *                     CACHE_FLAG_LOCK_MEMORY, lock retrieved data
  438.    *                       in the memory cache so it is not flushed
  439.    *                       (not even to the disk cache), note that some
  440.    *                       implementations may ignore this and simply
  441.    *                       treat this as CACHE_FLAG_LOCK.
  442.    *                     CACHE_FLAG_NONBLOCKING_IO, non-blocking reads and
  443.    *                       writes, although the open and close is still
  444.    *                       blocking
  445.    * @param properties   [IN] Properties to control the open, as listed
  446.    *                       above. May be NULL.
  447.    * @param streamInfo   [OUT] (Optional, pass NULL if not required.) Map
  448.    *                       that will be populated with information about 
  449.    *                       the stream, the CACHE_INFO_[...] keys listed
  450.    *                       above are mandatory with the implementation 
  451.    *                       possibly setting other keys.  This may not be 
  452.    *                       populated on an open for WRITE since that is 
  453.    *                       creating a new file.
  454.    * @param stream       [OUT] Handle to the opened stream
  455.    *
  456.    * @return VXIcache_RESULT_SUCCESS on success
  457.    * @return VXIcache_RESULT_ENTRY_LOCKED if the entry is in used and 
  458.    *           cannot be returned. Returned if a writer has the entry open.
  459.    * @return VXIcache_RESULT_NULL_STREAM if the stream that was passed in 
  460.    *           or the interface is NULL 
  461.    */
  462.   VXIcacheResult (*OpenEx)(struct VXIcacheInterface  *pThis,
  463.    const VXIchar             *moduleName,
  464.    const VXIbyte             *key,
  465.    VXIulong                   keySizeBytes,
  466.    VXIcacheOpenMode           mode,
  467.    VXIint32                   flags,
  468.    const VXIMap              *properties,
  469.    VXIMap                    *streamInfo,
  470.    VXIcacheStream           **stream);
  471.   /**
  472.    * Close a previously opened stream
  473.    *
  474.    * NOTE: Same as Close( ) but supports invalidating the entry. This
  475.    *       is only available as of version 1.1 of the VXIcacheInterface,
  476.    *       use CACHE_CLOSEEX_SUPPORTED( ) to determine availability.
  477.    *
  478.    * Close a previously opened stream.  If Close is called on 
  479.    * a NULL stream or a previously closed stream an error will be
  480.    * returned
  481.    *
  482.    * @param keepEntry    [IN] TRUE to indiate the write was a success
  483.    *                       and the cache entry should be retained,
  484.    *                       FALSE to indicate the write failed
  485.    *                       (typically due to a data source read
  486.    *                       unexpectedly failing)
  487.    * @param stream       [IN/OUT] Stream to close, set to NULL on
  488.    *                       success
  489.    *
  490.    * @return VXIcache_RESULT_SUCCESS on success
  491.    */
  492.   VXIcacheResult (*CloseEx)(struct VXIcacheInterface  *pThis,
  493.     VXIbool                    keepEntry,
  494.     VXIcacheStream           **stream);
  495.   
  496.   /**
  497.    * Unlock an entry that was previously locked into the cache
  498.    * given a binary key
  499.    *
  500.    * NOTE: Same as Unlock( ) but supports binary keys. This is only 
  501.    *       available as of version 1.1 of the VXIcacheInterface, use
  502.    *       CACHE_UNLOCKEX_SUPPORTED( ) to determine availability.
  503.    *
  504.    * This releases a cache lock on the indicated data. Note that it
  505.    * is up to the implementation to decide when to flush the data
  506.    * from the cache, it may choose to do so immediately or may
  507.    * do so at a later time.
  508.    *
  509.    * @param key          [IN] Key name of the data to access, binary
  510.    *                       data (raw bytes) of an arbitrary length
  511.    * @param keySizeBytes [IN] Size of the key name in bytes
  512.    *
  513.    * @return VXIcache_RESULT_SUCCESS on success
  514.    */
  515.   VXIcacheResult (*UnlockEx)(struct VXIcacheInterface  *pThis,
  516.      const VXIbyte             *key,
  517.      VXIulong                   keySizeBytes);
  518. } VXIcacheInterface;
  519. /*@}*/
  520. #ifdef __cplusplus
  521. }
  522. #endif
  523. #include "VXIheaderSuffix.h"
  524. #endif  /* include guard */