• Main Page
  • Modules
  • Data Structures
  • Files
  • File List

D:/Perso/dev/ocilib/ocilib/src/dequeue.c

00001 /*
00002     +-----------------------------------------------------------------------------------------+
00003     |                                                                                         |
00004     |                               OCILIB - C Driver for Oracle                              |
00005     |                                                                                         |
00006     |                                (C Wrapper for Oracle OCI)                               |
00007     |                                                                                         |
00008     |                              Website : http://www.ocilib.net                            |
00009     |                                                                                         |
00010     |             Copyright (c) 2007-2010 Vincent ROGIER <vince.rogier@ocilib.net>            |
00011     |                                                                                         |
00012     +-----------------------------------------------------------------------------------------+
00013     |                                                                                         |
00014     |             This library is free software; you can redistribute it and/or               |
00015     |             modify it under the terms of the GNU Lesser General Public                  |
00016     |             License as published by the Free Software Foundation; either                |
00017     |             version 2 of the License, or (at your option) any later version.            |
00018     |                                                                                         |
00019     |             This library is distributed in the hope that it will be useful,             |
00020     |             but WITHOUT ANY WARRANTY; without even the implied warranty of              |
00021     |             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           |
00022     |             Lesser General Public License for more details.                             |
00023     |                                                                                         |
00024     |             You should have received a copy of the GNU Lesser General Public            |
00025     |             License along with this library; if not, write to the Free                  |
00026     |             Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.          |
00027     |                                                                                         |
00028     +-----------------------------------------------------------------------------------------+
00029 */
00030 
00031 /* --------------------------------------------------------------------------------------------- *
00032  * $Id: dequeue.c, v 3.8.0 2010-10-24 21:53 Vincent Rogier $
00033  * --------------------------------------------------------------------------------------------- */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ********************************************************************************************* *
00038  *                            PUBLIC FUNCTIONS
00039  * ********************************************************************************************* */
00040 
00041 /* --------------------------------------------------------------------------------------------- *
00042  * OCI_DequeueCreate
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Dequeue * OCI_API OCI_DequeueCreate
00046 (
00047     OCI_TypeInfo *typinf,
00048     const mtext  *name
00049 )
00050 {
00051     OCI_Dequeue *dequeue = NULL;
00052     boolean res          = TRUE;
00053 
00054     OCI_CHECK_INITIALIZED(NULL);
00055 
00056     OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00057     OCI_CHECK_PTR(OCI_IPC_STRING, name, NULL);
00058 
00059     /* allocate dequeue structure */
00060 
00061     dequeue = (OCI_Dequeue *) OCI_MemAlloc(OCI_IPC_ENQUEUE, sizeof(*dequeue), (size_t) 1, TRUE);
00062 
00063     if (dequeue != NULL)
00064     {
00065         dequeue->typinf = typinf;
00066         dequeue->name   = mtsdup(name);
00067 
00068         /* get payload type */
00069 
00070         if (mtscmp(dequeue->typinf->name, OCI_RAW_OBJECT_TYPE) == 0)
00071         {
00072             dequeue->payload_type = OCI_CDT_RAW;
00073         }
00074         else
00075         {
00076             dequeue->payload_type = OCI_CDT_OBJECT;
00077         }
00078 
00079         /* allocate dequeue options descriptor */
00080 
00081         res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid * ) OCILib.env,
00082                                                   (dvoid **) &dequeue->opth,
00083                                                   OCI_DTYPE_AQDEQ_OPTIONS,
00084                                                   (size_t) 0, (dvoid **) NULL));
00085 
00086         /* create local message for OCI_DequeueGet() */
00087 
00088         dequeue->msg = OCI_MsgCreate(dequeue->typinf);
00089 
00090         res = (dequeue->msg != NULL);
00091     }
00092     else
00093         res = FALSE;
00094 
00095     /* check for failure */
00096 
00097     if (res == FALSE)
00098     {
00099         OCI_DequeueFree(dequeue);
00100         dequeue = NULL;
00101     }
00102 
00103     return dequeue;
00104 }
00105 
00106 /* --------------------------------------------------------------------------------------------- *
00107  * OCI_DequeueFree
00108  * --------------------------------------------------------------------------------------------- */
00109 
00110 boolean OCI_API OCI_DequeueFree
00111 (
00112     OCI_Dequeue *dequeue
00113 )
00114 {
00115     OCI_CHECK_PTR(OCI_IPC_ENQUEUE, dequeue, FALSE);
00116 
00117     /* free OCI descriptor */
00118 
00119     OCI_DescriptorFree((dvoid *) dequeue->opth, OCI_DTYPE_AQDEQ_OPTIONS);
00120 
00121     /* free local message  */
00122 
00123     if (dequeue->msg != NULL)
00124     {
00125         OCI_MsgFree(dequeue->msg);
00126     }
00127 
00128     /* free local agent  */
00129 
00130     if (dequeue->agent != NULL)
00131     {
00132         OCI_AgentFree(dequeue->agent);
00133     }
00134 
00135     /* free strings  */
00136 
00137     OCI_FREE(dequeue->name);
00138     OCI_FREE(dequeue->pattern);
00139 
00140     /* free misc. */
00141 
00142     OCI_FREE(dequeue->agent_list);
00143 
00144     OCI_FREE(dequeue);
00145 
00146     return TRUE;
00147 }
00148 
00149 /* --------------------------------------------------------------------------------------------- *
00150  * OCI_DequeueListen
00151  * --------------------------------------------------------------------------------------------- */
00152 
00153 OCI_Agent * OCI_API OCI_DequeueListen
00154 (
00155     OCI_Dequeue *dequeue,
00156     int          timeout
00157 )
00158 {
00159     boolean res        = TRUE;
00160     OCI_Agent *agent   = NULL;
00161     OCIAQAgent *handle = NULL;
00162 
00163     OCI_CHECK_PTR(OCI_IPC_ENQUEUE, dequeue, NULL);
00164 
00165     /* listen only if OCI_DequeueSetAgentList has been called */
00166 
00167     if (dequeue->agent_list != NULL)
00168     {
00169         sword ret;
00170         sb4 code;
00171 
00172         ret =  OCIAQListen(dequeue->typinf->con->cxt, dequeue->typinf->con->err,
00173                            dequeue->agent_list, (ub4) dequeue->agent_count,
00174                            (sb4) timeout, &handle, OCI_DEFAULT);
00175 
00176         /* check returned error code */
00177 
00178         if (ret == OCI_ERROR)
00179         {
00180             OCIErrorGet((dvoid *) dequeue->typinf->con->err, (ub4) 1,
00181                         (OraText *) NULL, &code, (OraText *) NULL, (ub4) 0,
00182                         (ub4) OCI_HTYPE_ERROR);
00183 
00184             /* raise error only if the call has not been timed out */
00185 
00186             if (code != OCI_ERR_AQ_LISTEN_TIMEOUT)
00187             {
00188                 OCI_ExceptionOCI(dequeue->typinf->con->err, dequeue->typinf->con, NULL, FALSE);
00189 
00190                 res = FALSE;
00191             }
00192         }
00193 
00194         /* init local agent object */
00195 
00196         if ((res == TRUE) && (ret == OCI_SUCCESS) && (handle != NULL))
00197         {
00198             agent = OCI_AgentInit(dequeue->typinf->con, &dequeue->agent, handle, NULL, NULL);
00199         }
00200     }
00201 
00202     OCI_RESULT(res);
00203 
00204     return agent;
00205 }
00206 
00207 /* --------------------------------------------------------------------------------------------- *
00208  * OCI_DequeueGet
00209  * --------------------------------------------------------------------------------------------- */
00210 
00211 OCI_Msg * OCI_API OCI_DequeueGet
00212 (
00213     OCI_Dequeue *dequeue
00214 )
00215 {
00216     boolean res     = TRUE;
00217     void *ostr      = NULL;
00218     int osize       = -1;
00219 
00220     sword ret;
00221     sb4 code;
00222 
00223     OCI_Msg *msg    = NULL;
00224 
00225     OCI_CHECK_PTR(OCI_IPC_ENQUEUE, dequeue, NULL);
00226 
00227     ostr = OCI_GetInputMetaString(dequeue->name, &osize);
00228 
00229     /* dequeue message */
00230 
00231     ret = OCIAQDeq(dequeue->typinf->con->cxt, dequeue->typinf->con->err,
00232                    ostr, dequeue->opth, dequeue->msg->proph, dequeue->typinf->tdo,
00233                    &dequeue->payload, &dequeue->payload_ind, &dequeue->msg->id, OCI_DEFAULT);
00234 
00235     /* check returned error code */
00236 
00237     if (ret == OCI_ERROR)
00238     {
00239         OCIErrorGet((dvoid *) dequeue->typinf->con->err, (ub4) 1,
00240                     (OraText *) NULL, &code, (OraText *) NULL, (ub4) 0,
00241                     (ub4) OCI_HTYPE_ERROR);
00242 
00243         /* raise error only if the call has not been timed out */
00244 
00245         if (code != OCI_ERR_AQ_DEQUEUE_TIMEOUT)
00246         {
00247             OCI_ExceptionOCI(dequeue->typinf->con->err, dequeue->typinf->con, NULL, FALSE);
00248 
00249             res = FALSE;
00250         }
00251     }
00252 
00253     /* reset message */
00254 
00255     if ((res == TRUE) && (ret == OCI_SUCCESS))
00256     {
00257         res = OCI_MsgReset(dequeue->msg);
00258 
00259         /* get payload */
00260 
00261         if (dequeue->payload_type == OCI_CDT_OBJECT)
00262         {
00263             if ((dequeue->payload_ind != NULL) && (*(OCIInd *) dequeue->payload_ind != OCI_IND_NULL))
00264             {
00265                 dequeue->msg->payload = OCI_ObjectInit(dequeue->typinf->con, 
00266                                                        (OCI_Object **) &dequeue->msg->payload,
00267                                                        dequeue->payload, dequeue->typinf,
00268                                                        NULL, -1, TRUE); 
00269 
00270                 res = dequeue->msg->payload != NULL;
00271 
00272                 dequeue->msg->ind     = OCI_IND_NOTNULL;
00273             }
00274             else
00275                 dequeue->msg->ind     = OCI_IND_NULL;
00276         }
00277         else
00278         {
00279             dequeue->msg->payload     = dequeue->payload;
00280 
00281             if (dequeue->payload_ind != NULL)
00282                 dequeue->msg->ind     = *(OCIInd *) dequeue->payload_ind;
00283             else
00284                 dequeue->msg->ind     = OCI_IND_NULL;
00285         }
00286     }
00287 
00288     /* on success return internla message handle */
00289 
00290     if ((res == TRUE) && (ret == OCI_SUCCESS))
00291     {
00292         msg = dequeue->msg;
00293     }
00294 
00295     OCI_RESULT(res);
00296 
00297     return msg;
00298 }
00299 
00300 /* --------------------------------------------------------------------------------------------- *
00301  * OCI_DequeueGetConsumerName
00302  * --------------------------------------------------------------------------------------------- */
00303 
00304 const mtext * OCI_API OCI_DequeueGetConsumer
00305 (
00306     OCI_Dequeue *dequeue
00307 )
00308 {
00309     boolean res = TRUE;
00310 
00311     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00312 
00313     if (dequeue->consumer == NULL)
00314     {
00315         res = OCI_StringGetFromAttrHandle(dequeue->typinf->con,
00316                                           dequeue->opth,
00317                                           OCI_DTYPE_AQDEQ_OPTIONS,
00318                                           OCI_ATTR_CONSUMER_NAME,
00319                                           &dequeue->consumer);
00320     }
00321 
00322     OCI_RESULT(res);
00323 
00324     return dequeue->consumer;
00325 }
00326 
00327 /* --------------------------------------------------------------------------------------------- *
00328  * OCI_DequeueSetConsumerName
00329  * --------------------------------------------------------------------------------------------- */
00330 
00331 boolean OCI_API OCI_DequeueSetConsumer
00332 (
00333     OCI_Dequeue *dequeue,
00334     const mtext *consumer
00335 )
00336 {
00337     boolean res = TRUE;
00338 
00339     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00340 
00341     res =  OCI_StringSetToAttrHandle(dequeue->typinf->con,
00342                                      dequeue->opth,
00343                                      OCI_DTYPE_AQDEQ_OPTIONS,
00344                                      OCI_ATTR_CONSUMER_NAME,
00345                                      &dequeue->consumer,
00346                                      consumer);
00347 
00348     OCI_RESULT(res);
00349 
00350     return res;
00351 }
00352 
00353 /* --------------------------------------------------------------------------------------------- *
00354  * OCI_DequeueGetCorrelation
00355  * --------------------------------------------------------------------------------------------- */
00356 
00357 const mtext * OCI_API OCI_DequeueGetCorrelation
00358 (
00359     OCI_Dequeue *dequeue
00360 )
00361 {
00362     boolean res = TRUE;
00363 
00364     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00365 
00366     if (dequeue->pattern == NULL)
00367     {
00368         res = OCI_StringGetFromAttrHandle(dequeue->typinf->con,
00369                                           dequeue->opth,
00370                                           OCI_DTYPE_AQDEQ_OPTIONS,
00371                                           OCI_ATTR_CORRELATION,
00372                                           &dequeue->pattern);
00373     }
00374 
00375     OCI_RESULT(res);
00376 
00377     return dequeue->pattern;
00378 }
00379 
00380 /* --------------------------------------------------------------------------------------------- *
00381  * OCI_DequeueSetCorrelation
00382  * --------------------------------------------------------------------------------------------- */
00383 
00384 boolean OCI_API OCI_DequeueSetCorrelation
00385 (
00386     OCI_Dequeue *dequeue,
00387     const mtext *pattern
00388 )
00389 {
00390     boolean res = TRUE;
00391 
00392     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00393 
00394     res =  OCI_StringSetToAttrHandle(dequeue->typinf->con,
00395                                      dequeue->opth,
00396                                      OCI_DTYPE_AQDEQ_OPTIONS,
00397                                      OCI_ATTR_CORRELATION,
00398                                      &dequeue->pattern,
00399                                      pattern);
00400 
00401     OCI_RESULT(res);
00402 
00403     return res;
00404 }
00405 
00406 /* --------------------------------------------------------------------------------------------- *
00407  * OCI_DequeueGetRelativeMsgID
00408  * --------------------------------------------------------------------------------------------- */
00409 
00410 boolean OCI_API OCI_DequeueGetRelativeMsgID
00411 (
00412     OCI_Dequeue  *dequeue,
00413     void         *id,
00414     unsigned int *len
00415 )
00416 {
00417     boolean res   = TRUE;
00418     OCIRaw *value = NULL;
00419 
00420     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00421     OCI_CHECK_PTR(OCI_IPC_VOID,    id,      FALSE);
00422     OCI_CHECK_PTR(OCI_IPC_VOID,    len,     FALSE);
00423 
00424     OCI_CALL2
00425     (
00426         res, dequeue->typinf->con,
00427 
00428         OCIAttrGet((dvoid *) dequeue->opth,
00429                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00430                    (dvoid *) &value,
00431                    (ub4   *) NULL,
00432                    (ub4    ) OCI_ATTR_DEQ_MSGID,
00433                    dequeue->typinf->con->err)
00434     )
00435 
00436     if (value != NULL)
00437     {
00438         ub4 raw_len = 0;
00439 
00440         raw_len = OCIRawSize(OCILib.env, value);
00441 
00442         if (*len > raw_len)
00443             *len = raw_len;
00444 
00445         memcpy(id, OCIRawPtr(OCILib.env, value), (size_t) (*len));
00446     }
00447     else
00448     {
00449         *len = 0;
00450     }
00451 
00452     OCI_RESULT(res);
00453 
00454     return res;
00455 }
00456 
00457 /* --------------------------------------------------------------------------------------------- *
00458  * OCI_DequeueSetRelativeMsgID
00459  * --------------------------------------------------------------------------------------------- */
00460 
00461 boolean OCI_API OCI_DequeueSetRelativeMsgID
00462 (
00463     OCI_Dequeue  *dequeue,
00464     const void   *id,
00465     unsigned int  len
00466 )
00467 {
00468     boolean res   = TRUE;
00469     OCIRaw *value = NULL;
00470 
00471     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00472 
00473     OCI_CALL2
00474     (
00475         res, dequeue->typinf->con,
00476 
00477         OCIRawAssignBytes(OCILib.env, dequeue->typinf->con->err,
00478                           (ub1*) id, (ub4) len, (OCIRaw **) &value)
00479     )
00480 
00481     OCI_CALL2
00482     (
00483         res, dequeue->typinf->con,
00484 
00485         OCIAttrSet((dvoid *) dequeue->opth,
00486                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00487                    (dvoid *) &value,
00488                    (ub4    ) 0,
00489                    (ub4    ) OCI_ATTR_DEQ_MSGID,
00490                    dequeue->typinf->con->err)
00491     )
00492 
00493     OCI_RESULT(res);
00494 
00495     return res;
00496 }
00497 
00498 /* --------------------------------------------------------------------------------------------- *
00499  * OCI_DequeueGetVisibility
00500  * --------------------------------------------------------------------------------------------- */
00501 
00502 unsigned int OCI_API OCI_DequeueGetVisibility
00503 (
00504     OCI_Dequeue *dequeue
00505 )
00506 {
00507     boolean res = TRUE;
00508     ub4 ret     = 0;
00509 
00510     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00511 
00512     OCI_CALL2
00513     (
00514         res, dequeue->typinf->con,
00515 
00516         OCIAttrGet((dvoid *) dequeue->opth,
00517                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00518                    (dvoid *) &ret,
00519                    (ub4   *) NULL,
00520                    (ub4    ) OCI_ATTR_VISIBILITY,
00521                    dequeue->typinf->con->err)
00522     )
00523 
00524     OCI_RESULT(res);
00525 
00526     return (int) ret;
00527 }
00528 
00529 /* --------------------------------------------------------------------------------------------- *
00530  * OCI_DequeueSetVisibility
00531  * --------------------------------------------------------------------------------------------- */
00532 
00533 boolean OCI_API OCI_DequeueSetVisibility
00534 (
00535     OCI_Dequeue *dequeue,
00536     unsigned int visibility
00537 )
00538 {
00539     boolean res = TRUE;
00540     ub4 value   = (ub4) visibility;
00541 
00542     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00543 
00544     OCI_CALL2
00545     (
00546         res, dequeue->typinf->con,
00547 
00548         OCIAttrSet((dvoid *) dequeue->opth,
00549                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00550                    (dvoid *) &value,
00551                    (ub4    ) 0,
00552                    (ub4    ) OCI_ATTR_VISIBILITY,
00553                    dequeue->typinf->con->err)
00554     )
00555 
00556     OCI_RESULT(res);
00557 
00558     return res;
00559 }
00560 
00561 /* --------------------------------------------------------------------------------------------- *
00562  * OCI_DequeueGetMode
00563  * --------------------------------------------------------------------------------------------- */
00564 
00565 unsigned int OCI_API OCI_DequeueGetMode
00566 (
00567     OCI_Dequeue *dequeue
00568 )
00569 {
00570     boolean res = TRUE;
00571     ub4 ret     = 0;
00572 
00573     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00574 
00575     OCI_CALL2
00576     (
00577         res, dequeue->typinf->con,
00578 
00579         OCIAttrGet((dvoid *) dequeue->opth,
00580                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00581                    (dvoid *) &ret,
00582                    (ub4   *) NULL,
00583                    (ub4    ) OCI_ATTR_DEQ_MODE,
00584                    dequeue->typinf->con->err)
00585     )
00586 
00587     OCI_RESULT(res);
00588 
00589     return (int) ret;
00590 }
00591 
00592 /* --------------------------------------------------------------------------------------------- *
00593  * OCI_DequeueSetMode
00594  * --------------------------------------------------------------------------------------------- */
00595 
00596 boolean OCI_API OCI_DequeueSetMode
00597 (
00598     OCI_Dequeue *dequeue,
00599     unsigned int mode
00600 )
00601 {
00602     boolean res = TRUE;
00603     ub4 value   = (ub4) mode;
00604 
00605     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00606 
00607     OCI_CALL2
00608     (
00609         res, dequeue->typinf->con,
00610 
00611         OCIAttrSet((dvoid *) dequeue->opth,
00612                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00613                    (dvoid *) &value,
00614                    (ub4    ) 0,
00615                    (ub4    ) OCI_ATTR_DEQ_MODE,
00616                    dequeue->typinf->con->err)
00617     )
00618 
00619     OCI_RESULT(res);
00620 
00621     return res;
00622 }
00623 
00624 /* --------------------------------------------------------------------------------------------- *
00625  * OCI_DequeueGetNavigation
00626  * --------------------------------------------------------------------------------------------- */
00627 
00628 unsigned int OCI_API OCI_DequeueGetNavigation
00629 (
00630     OCI_Dequeue *dequeue
00631 )
00632 {
00633     boolean res = TRUE;
00634     ub4 ret     = 0;
00635 
00636     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00637 
00638     OCI_CALL2
00639     (
00640         res, dequeue->typinf->con,
00641 
00642         OCIAttrGet((dvoid *) dequeue->opth,
00643                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00644                    (dvoid *) &ret,
00645                    (ub4   *) NULL,
00646                    (ub4    ) OCI_ATTR_NAVIGATION,
00647                    dequeue->typinf->con->err)
00648     )
00649 
00650     OCI_RESULT(res);
00651 
00652     return (int) ret;
00653 }
00654 
00655 /* --------------------------------------------------------------------------------------------- *
00656  * OCI_DequeueSetNavigation
00657  * --------------------------------------------------------------------------------------------- */
00658 
00659 boolean OCI_API OCI_DequeueSetNavigation
00660 (
00661     OCI_Dequeue *dequeue,
00662     unsigned int position
00663 )
00664 {
00665     boolean res = TRUE;
00666     ub4 value   = (ub4) position;
00667 
00668     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00669 
00670     OCI_CALL2
00671     (
00672         res, dequeue->typinf->con,
00673 
00674         OCIAttrSet((dvoid *) dequeue->opth,
00675                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00676                    (dvoid *) &value,
00677                    (ub4    ) 0,
00678                    (ub4    ) OCI_ATTR_NAVIGATION,
00679                    dequeue->typinf->con->err)
00680     )
00681 
00682     OCI_RESULT(res);
00683 
00684     return res;
00685 }
00686 
00687 /* --------------------------------------------------------------------------------------------- *
00688  * OCI_DequeueGetWaitTime
00689  * --------------------------------------------------------------------------------------------- */
00690 
00691 int OCI_API OCI_DequeueGetWaitTime
00692 (
00693     OCI_Dequeue *dequeue
00694 )
00695 {
00696     boolean res = TRUE;
00697     sb4 ret     = 0;
00698 
00699     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00700 
00701     OCI_CALL2
00702     (
00703         res, dequeue->typinf->con,
00704 
00705         OCIAttrGet((dvoid *) dequeue->opth,
00706                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00707                    (dvoid *) &ret,
00708                    (ub4   *) NULL,
00709                    (ub4    )  OCI_ATTR_WAIT,
00710                    dequeue->typinf->con->err)
00711     )
00712 
00713     OCI_RESULT(res);
00714 
00715     return (int) ret;
00716 }
00717 
00718 /* --------------------------------------------------------------------------------------------- *
00719  * OCI_DequeueSetWaitTime
00720  * --------------------------------------------------------------------------------------------- */
00721 
00722 boolean OCI_API OCI_DequeueSetWaitTime
00723 (
00724     OCI_Dequeue *dequeue,
00725     int          timeout
00726 )
00727 {
00728     boolean res = TRUE;
00729     sb4 value   = (ub4) timeout;
00730 
00731     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00732 
00733     OCI_CALL2
00734     (
00735         res, dequeue->typinf->con,
00736 
00737         OCIAttrSet((dvoid *) dequeue->opth,
00738                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00739                    (dvoid *) &value,
00740                    (ub4    ) 0,
00741                    (ub4    )  OCI_ATTR_WAIT,
00742                    dequeue->typinf->con->err)
00743     )
00744 
00745     OCI_RESULT(res);
00746 
00747     return res;
00748 }
00749 
00750 /* --------------------------------------------------------------------------------------------- *
00751  * OCI_DequeueSetAgentList
00752  * --------------------------------------------------------------------------------------------- */
00753 
00754 boolean OCI_API OCI_DequeueSetAgentList
00755 (
00756     OCI_Dequeue *dequeue,
00757     OCI_Agent  **consumers,
00758     unsigned int count
00759 )
00760 {
00761     boolean res = TRUE;
00762 
00763     OCI_CHECK_PTR(OCI_IPC_ENQUEUE, dequeue, FALSE);
00764 
00765     OCI_FREE(dequeue->agent_list);
00766 
00767     if ((consumers != NULL) && (count > 0))
00768     {
00769         dequeue->agent_list = (OCIAQAgent **) OCI_MemAlloc(OCI_IPC_ARRAY,
00770                                                            sizeof(OCIAQAgent *),
00771                                                            count, FALSE);
00772 
00773         if (dequeue->agent_list != NULL)
00774         {
00775             unsigned int i;
00776 
00777             for(i = 0; i < count; i++)
00778             {
00779                 dequeue->agent_list[i] = consumers[i]->handle;
00780             }
00781 
00782             dequeue->agent_count = (ub4) count;
00783         }
00784         else
00785         {
00786             res = FALSE;
00787         }
00788     }
00789 
00790     OCI_RESULT(res);
00791 
00792     return res;
00793 }

Generated on Sun Oct 24 2010 22:02:54 for OCILIB (C Driver for Oracle) by  doxygen 1.7.1