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

D:/Perso/dev/ocilib/ocilib/src/msg.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: msg.c, v 3.8.1 2010-12-13 00:00 Vincent Rogier $
00033  * --------------------------------------------------------------------------------------------- */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ********************************************************************************************* *
00038  *                            PUBLIC FUNCTIONS
00039  * ********************************************************************************************* */
00040 
00041 /* --------------------------------------------------------------------------------------------- *
00042  * OCI_MsgCreate
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Msg * OCI_API OCI_MsgCreate
00046 (
00047     OCI_TypeInfo *typinf
00048 )
00049 {
00050     OCI_Msg *msg = NULL;
00051     boolean res  = TRUE;
00052 
00053     OCI_CHECK_INITIALIZED(NULL);
00054 
00055     OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00056 
00057     /* allocate message structure */
00058 
00059     msg = (OCI_Msg *) OCI_MemAlloc(OCI_IPC_MSG, sizeof(*msg), (size_t) 1, TRUE);
00060 
00061     if (msg != NULL)
00062     {
00063         msg->typinf = typinf;
00064         msg->ind    = OCI_IND_NULL;
00065 
00066         /* allocate message properties descriptor */
00067 
00068         res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid * ) OCILib.env,
00069                                                   (dvoid **) &msg->proph,
00070                                                   OCI_DTYPE_AQMSG_PROPERTIES,
00071                                                   (size_t) 0, (dvoid **) NULL));
00072 
00073         if (res == TRUE)
00074         {
00075             /* allocate internal OCI_Object handle if payload is not RAW */
00076 
00077             if (msg->typinf->tcode != OCI_UNKNOWN)
00078             {
00079                 msg->obj = OCI_ObjectCreate(typinf->con, typinf);
00080 
00081                 res = (msg->obj != NULL);
00082             }
00083         }
00084     }
00085     else
00086         res = FALSE;
00087 
00088     /* check for failure */
00089 
00090     if (res == FALSE)
00091     {
00092         OCI_MsgFree(msg);
00093         msg = NULL;
00094     }
00095 
00096     return msg;
00097 }
00098 
00099 /* --------------------------------------------------------------------------------------------- *
00100  * OCI_MsgFree
00101  * --------------------------------------------------------------------------------------------- */
00102 
00103 boolean OCI_API OCI_MsgFree
00104 (
00105     OCI_Msg *msg
00106 )
00107 {
00108     boolean res = TRUE;
00109 
00110     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00111 
00112     /* free local OCI_Agent object */
00113 
00114     if (msg->sender != NULL)
00115     {
00116         OCI_AgentFree(msg->sender);
00117     }
00118 
00119     /* free internal OCI_Object handle if payload is not RAW */
00120 
00121     if (msg->obj != NULL)
00122     {
00123         msg->obj->hstate =  OCI_OBJECT_ALLOCATED;
00124 
00125         OCI_ObjectFree(msg->obj);
00126 
00127         msg->obj = NULL;
00128     }
00129 
00130     /* free message RAW payload if necessary */
00131 
00132     if ((msg->typinf->tcode == OCI_UNKNOWN)&& ( msg->id != NULL))
00133     {
00134         OCI_CALL2
00135         (
00136             res, msg->typinf->con,
00137 
00138             OCIRawResize(OCILib.env, msg->typinf->con->err, 0, (OCIRaw **) &msg->payload)
00139         )
00140     }   
00141 
00142     /* free message ID */
00143 
00144     if (msg->id != NULL)
00145     {
00146         
00147         OCI_CALL2
00148         (
00149             res, msg->typinf->con,
00150 
00151             OCIRawResize(OCILib.env, msg->typinf->con->err, 0, (OCIRaw **) &msg->id)
00152         )
00153     }       
00154 
00155     msg->id = NULL;
00156 
00157     /* free OCI descriptor */
00158 
00159     OCI_DescriptorFree((dvoid *) msg->proph, OCI_DTYPE_AQMSG_PROPERTIES);
00160   
00161     OCI_FREE(msg);
00162 
00163     return res;
00164 }
00165 
00166 /* --------------------------------------------------------------------------------------------- *
00167  * OCI_MsgReset
00168  * --------------------------------------------------------------------------------------------- */
00169 
00170 boolean OCI_API OCI_MsgReset
00171 (
00172     OCI_Msg *msg
00173 )
00174 {
00175     boolean res = TRUE;
00176 
00177     unsigned int len = 0;
00178     void  *null_ptr  = NULL;
00179 
00180     res =   (
00181                 OCI_MsgSetExpiration(msg, -1)            &&
00182                 OCI_MsgSetEnqueueDelay(msg, 0)           &&
00183                 OCI_MsgSetPriority(msg,0)                &&
00184                 OCI_MsgSetOriginalID(msg, null_ptr, len) &&
00185                 OCI_MsgSetSender(msg, NULL)              &&
00186                 OCI_MsgSetConsumers(msg, null_ptr, len)  &&
00187                 OCI_MsgSetCorrelation(msg, NULL)         &&
00188                 OCI_MsgSetExceptionQueue(msg, NULL)
00189             );
00190 
00191     if (res == TRUE)
00192     {
00193         if (msg->typinf->tcode == OCI_UNKNOWN)
00194         {
00195             res = OCI_MsgSetRaw(msg, null_ptr, len);
00196         }
00197         else
00198         {
00199             res = OCI_MsgSetObject(msg, null_ptr);
00200         }
00201     }
00202 
00203     return res;
00204 }
00205 
00206 /* --------------------------------------------------------------------------------------------- *
00207  * OCI_MsgGetObject
00208  * --------------------------------------------------------------------------------------------- */
00209 
00210 OCI_Object * OCI_API OCI_MsgGetObject
00211 (
00212     OCI_Msg *msg
00213 )
00214 {
00215     OCI_Object *obj = NULL;
00216 
00217     OCI_CHECK_PTR(OCI_IPC_MSG, msg, NULL);
00218     OCI_CHECK_COMPAT(msg->typinf->con, msg->typinf->tcode != OCI_UNKNOWN, NULL);
00219 
00220     if (msg->ind != OCI_IND_NULL)
00221     {
00222         obj = (OCI_Object *) msg->obj;
00223     }
00224 
00225     OCI_RESULT(TRUE);
00226 
00227     return obj;
00228 }
00229 
00230 /* --------------------------------------------------------------------------------------------- *
00231  * OCI_MsgGetObject
00232  * --------------------------------------------------------------------------------------------- */
00233 
00234 boolean OCI_API OCI_MsgSetObject
00235 (
00236     OCI_Msg    *msg,
00237     OCI_Object *obj
00238 )
00239 {
00240     boolean res = TRUE;
00241 
00242     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00243 
00244     OCI_CHECK_COMPAT(msg->typinf->con, msg->typinf->tcode != OCI_UNKNOWN, FALSE);
00245 
00246     if (obj != NULL)
00247     {
00248         /* assign the given object to the message internal object */
00249 
00250         res = OCI_ObjectAssign((OCI_Object *) msg->obj, obj);
00251 
00252         if (res == TRUE)
00253         {
00254             msg->ind = OCI_IND_NOTNULL;
00255         }
00256     }
00257     else
00258     {
00259         msg->ind = OCI_IND_NULL;
00260     }
00261 
00262     OCI_RESULT(res);
00263 
00264     return res;
00265 }
00266 
00267 /* --------------------------------------------------------------------------------------------- *
00268  * OCI_MsgGetRaw
00269  * --------------------------------------------------------------------------------------------- */
00270 
00271 boolean OCI_API OCI_MsgGetRaw
00272 (
00273     OCI_Msg      *msg,
00274     void         *raw,
00275     unsigned int *size
00276 )
00277 {
00278     unsigned int raw_size = 0;
00279 
00280     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00281     OCI_CHECK_PTR(OCI_IPC_VOID, raw, FALSE);
00282     OCI_CHECK_PTR(OCI_IPC_VOID, size, FALSE);
00283 
00284     OCI_CHECK_COMPAT(msg->typinf->con, msg->typinf->tcode == OCI_UNKNOWN, FALSE);
00285 
00286     if ((msg->payload != NULL) && (msg->ind != OCI_IND_NULL))
00287     {
00288         raw_size = OCIRawSize(OCILib.env, (OCIRaw *) msg->payload);
00289 
00290         if (*size > raw_size)
00291             *size = raw_size;
00292 
00293         memcpy(raw, OCIRawPtr(OCILib.env, msg->payload), (size_t) (*size));
00294     }
00295     else
00296     {
00297         *size = 0;
00298     }
00299 
00300     OCI_RESULT(TRUE);
00301 
00302     return TRUE;
00303 }
00304 
00305 /* --------------------------------------------------------------------------------------------- *
00306  * OCI_MsgSetRaw
00307  * --------------------------------------------------------------------------------------------- */
00308 
00309 boolean OCI_API OCI_MsgSetRaw
00310 (
00311     OCI_Msg      *msg,
00312     const void   *raw,
00313     unsigned int  size
00314 )
00315 {
00316     boolean res = TRUE;
00317 
00318     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00319  
00320     OCI_CHECK_COMPAT(msg->typinf->con, msg->typinf->tcode == OCI_UNKNOWN, FALSE);
00321 
00322     OCI_CALL2
00323     (
00324         res, msg->typinf->con,
00325 
00326         OCIRawAssignBytes(OCILib.env, msg->typinf->con->err, (ub1*) raw,
00327                             (ub4) size, (OCIRaw **) &msg->payload)
00328     )
00329  
00330     if ((res == TRUE) && (msg->payload != NULL) && (size > 0))
00331     {
00332         msg->ind = OCI_IND_NOTNULL;
00333     }
00334     else
00335     {
00336         msg->ind = OCI_IND_NULL;
00337     }
00338 
00339     OCI_RESULT(res);
00340 
00341     return res;
00342 }
00343 
00344 /* --------------------------------------------------------------------------------------------- *
00345  * OCI_MsgGetAttemptCount
00346  * --------------------------------------------------------------------------------------------- */
00347 
00348 int OCI_API OCI_MsgGetAttemptCount
00349 (
00350     OCI_Msg *msg
00351 )
00352 {
00353     boolean res = TRUE;
00354     sb4 ret     = 0;
00355 
00356     OCI_CHECK_PTR(OCI_IPC_MSG, msg, 0);
00357 
00358     OCI_CALL2
00359     (
00360         res, msg->typinf->con,
00361 
00362         OCIAttrGet((dvoid *) msg->proph,
00363                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00364                    (dvoid *) &ret,
00365                    (ub4   *) NULL,
00366                    (ub4    ) OCI_ATTR_ATTEMPTS,
00367                    msg->typinf->con->err)
00368     )
00369 
00370     OCI_RESULT(res);
00371 
00372     return (int) ret;
00373 }
00374 
00375 /* --------------------------------------------------------------------------------------------- *
00376  * OCI_MsgGetEnqueueDelay
00377  * --------------------------------------------------------------------------------------------- */
00378 
00379 int OCI_API OCI_MsgGetEnqueueDelay
00380 (
00381     OCI_Msg *msg
00382 )
00383 {
00384     boolean res = TRUE;
00385     sb4 ret     = 0;
00386 
00387     OCI_CHECK_PTR(OCI_IPC_MSG, msg, 0);
00388 
00389     OCI_CALL2
00390     (
00391         res, msg->typinf->con,
00392 
00393         OCIAttrGet((dvoid *) msg->proph,
00394                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00395                    (dvoid *) &ret,
00396                    (ub4   *) NULL,
00397                    (ub4    ) OCI_ATTR_DELAY,
00398                    msg->typinf->con->err)
00399     )
00400 
00401     OCI_RESULT(res);
00402 
00403     return (int) ret;
00404 }
00405 
00406 /* --------------------------------------------------------------------------------------------- *
00407  * OCI_MsgSetEnqueueDelay
00408  * --------------------------------------------------------------------------------------------- */
00409 
00410 boolean OCI_API OCI_MsgSetEnqueueDelay
00411 (
00412     OCI_Msg *msg,
00413     int      value
00414 )
00415 {
00416     boolean res = TRUE;
00417     sb4 sval    = (sb4) value;
00418 
00419     OCI_CHECK_PTR(OCI_IPC_MSG, msg, 0);
00420 
00421     OCI_CALL2
00422     (
00423         res, msg->typinf->con,
00424 
00425         OCIAttrSet((dvoid *) msg->proph,
00426                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00427                    (dvoid *) &sval,
00428                    (ub4    ) sizeof(sval),
00429                    (ub4    ) OCI_ATTR_DELAY,
00430                    msg->typinf->con->err)
00431     )
00432 
00433     OCI_RESULT(res);
00434 
00435     return res;
00436 }
00437 
00438 /* --------------------------------------------------------------------------------------------- *
00439  * OCI_MsgGetEnqueueTime
00440  * --------------------------------------------------------------------------------------------- */
00441 
00442 OCI_Date * OCI_API OCI_MsgGetEnqueueTime
00443 (
00444     OCI_Msg *msg
00445 )
00446 {
00447     boolean res    = TRUE;
00448     OCI_Date *date = NULL;
00449     OCIDate oci_date;
00450 
00451     OCI_CHECK_PTR(OCI_IPC_MSG, msg, NULL);
00452 
00453     OCI_CALL2
00454     (
00455         res, msg->typinf->con,
00456 
00457         OCIAttrGet((dvoid *) msg->proph,
00458                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00459                    (dvoid *) &oci_date,
00460                    (ub4   *) NULL,
00461                    (ub4    ) OCI_ATTR_ENQ_TIME,
00462                    msg->typinf->con->err)
00463     )
00464 
00465     if (res == TRUE)
00466     {
00467         date = OCI_DateInit(msg->typinf->con, &msg->date, &oci_date,
00468                             FALSE, FALSE);
00469 
00470         res = (date != NULL);
00471     }
00472 
00473     OCI_RESULT(res);
00474 
00475     return date;
00476 }
00477 
00478 /* --------------------------------------------------------------------------------------------- *
00479  * OCI_MsgGetExpiration
00480  * --------------------------------------------------------------------------------------------- */
00481 
00482 int OCI_API OCI_MsgGetExpiration
00483 (
00484     OCI_Msg *msg
00485 )
00486 {
00487     boolean res = TRUE;
00488     sb4 ret     = 0;
00489 
00490     OCI_CHECK_PTR(OCI_IPC_MSG, msg, 0);
00491 
00492     OCI_CALL2
00493     (
00494         res, msg->typinf->con,
00495 
00496         OCIAttrGet((dvoid *) msg->proph,
00497                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00498                    (dvoid *) &ret,
00499                    (ub4   *) NULL,
00500                    (ub4    ) OCI_ATTR_EXPIRATION,
00501                    msg->typinf->con->err)
00502     )
00503 
00504     OCI_RESULT(res);
00505 
00506     return (int) ret;
00507 }
00508 
00509 /* --------------------------------------------------------------------------------------------- *
00510  * OCI_MsgSetExpiration
00511  * --------------------------------------------------------------------------------------------- */
00512 
00513 boolean OCI_API OCI_MsgSetExpiration
00514 (
00515     OCI_Msg *msg,
00516     int      value
00517 )
00518 {
00519     boolean res = TRUE;
00520     sb4 sval    = (sb4) value;
00521 
00522     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00523 
00524     OCI_CALL2
00525     (
00526         res, msg->typinf->con,
00527 
00528         OCIAttrSet((dvoid *) msg->proph,
00529                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00530                    (dvoid *) &sval,
00531                    (ub4    ) sizeof(sval),
00532                    (ub4    ) OCI_ATTR_EXPIRATION,
00533                    msg->typinf->con->err)
00534     )
00535 
00536     OCI_RESULT(res);
00537 
00538     return res;
00539 }
00540 
00541 /* --------------------------------------------------------------------------------------------- *
00542  * OCI_MsgGetState
00543  * --------------------------------------------------------------------------------------------- */
00544 
00545 unsigned int OCI_API OCI_MsgGetState
00546 (
00547     OCI_Msg *msg
00548 )
00549 {
00550     boolean res = TRUE;
00551     sb4 ret     = 0;
00552 
00553     OCI_CHECK_PTR(OCI_IPC_MSG, msg, OCI_UNKNOWN);
00554 
00555     OCI_CALL2
00556     (
00557         res, msg->typinf->con,
00558 
00559         OCIAttrGet((dvoid *) msg->proph,
00560                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00561                    (dvoid *) &ret,
00562                    (ub4   *) NULL,
00563                    (ub4    ) OCI_ATTR_MSG_STATE,
00564                    msg->typinf->con->err)
00565     )
00566 
00567     /* increment value to handle return code OCI_UNKNOWN on failure */
00568 
00569     if (res == TRUE)
00570     {
00571         ret++;
00572     }
00573     else
00574     {
00575         ret = OCI_UNKNOWN;
00576     }
00577     
00578     OCI_RESULT(res);
00579     
00580     return (int) ret;
00581 }
00582 
00583 /* --------------------------------------------------------------------------------------------- *
00584  * OCI_MsgGetPriority
00585  * --------------------------------------------------------------------------------------------- */
00586 
00587 int OCI_API OCI_MsgGetPriority
00588 (
00589     OCI_Msg *msg
00590 )
00591 {
00592     boolean res = TRUE;
00593     sb4 ret     = 0;
00594 
00595     OCI_CHECK_PTR(OCI_IPC_MSG, msg, 0);
00596 
00597     OCI_CALL2
00598     (
00599         res, msg->typinf->con,
00600 
00601         OCIAttrGet((dvoid *) msg->proph,
00602                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00603                    (dvoid *) &ret,
00604                    (ub4   *) NULL,
00605                    (ub4    ) OCI_ATTR_PRIORITY,
00606                    msg->typinf->con->err)
00607     )
00608 
00609     OCI_RESULT(res);
00610 
00611     return (int) ret;
00612 }
00613 
00614 /* --------------------------------------------------------------------------------------------- *
00615  * OCI_MsgSetPriority
00616  * --------------------------------------------------------------------------------------------- */
00617 
00618 boolean OCI_API OCI_MsgSetPriority
00619 (
00620     OCI_Msg *msg,
00621     int      value
00622 )
00623 {
00624     boolean res = TRUE;
00625     sb4 sval    = (sb4) value;
00626 
00627     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00628 
00629     OCI_CALL2
00630     (
00631         res, msg->typinf->con,
00632 
00633         OCIAttrSet((dvoid *) msg->proph,
00634                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00635                    (dvoid *) &sval,
00636                    (ub4    ) sizeof(sval),
00637                    (ub4    ) OCI_ATTR_PRIORITY,
00638                    msg->typinf->con->err)
00639     )
00640 
00641     OCI_RESULT(res);
00642 
00643     return res;
00644 }
00645 
00646 
00647 /* --------------------------------------------------------------------------------------------- *
00648  * OCI_MsgGetID
00649  * --------------------------------------------------------------------------------------------- */
00650 
00651 boolean OCI_API OCI_MsgGetID
00652 (
00653     OCI_Msg      *msg,
00654     void         *id,
00655     unsigned int *len
00656 )
00657 {
00658     boolean res   = TRUE;
00659 
00660     OCI_CHECK_PTR(OCI_IPC_MSG,  msg, FALSE);
00661     OCI_CHECK_PTR(OCI_IPC_VOID, id,  FALSE);
00662     OCI_CHECK_PTR(OCI_IPC_VOID, len, FALSE);
00663 
00664     if (msg->id != NULL)
00665     {
00666         ub4 raw_len = 0;
00667 
00668         raw_len = OCIRawSize(OCILib.env, msg->id);
00669 
00670         if (*len > raw_len)
00671             *len = raw_len;
00672 
00673         memcpy(id, OCIRawPtr(OCILib.env, msg->id), (size_t) (*len));
00674     }
00675     else
00676     {
00677         *len = 0;
00678     }
00679 
00680     OCI_RESULT(res);
00681 
00682     return res;
00683 }
00684 
00685 /* --------------------------------------------------------------------------------------------- *
00686  * OCI_MsgGetOriginalID
00687  * --------------------------------------------------------------------------------------------- */
00688 
00689 boolean OCI_API OCI_MsgGetOriginalID
00690 (
00691     OCI_Msg      *msg,
00692     void         *id,
00693     unsigned int *len
00694 )
00695 {
00696     boolean res   = TRUE;
00697     OCIRaw *value = NULL;
00698 
00699     OCI_CHECK_PTR(OCI_IPC_MSG,  msg, FALSE);
00700     OCI_CHECK_PTR(OCI_IPC_VOID, id,  FALSE);
00701     OCI_CHECK_PTR(OCI_IPC_VOID, len, FALSE);
00702 
00703     OCI_CALL2
00704     (
00705         res, msg->typinf->con,
00706 
00707         OCIAttrGet((dvoid *) msg->proph,
00708                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00709                    (dvoid *) &value,
00710                    (ub4   *) NULL,
00711                    (ub4    ) OCI_ATTR_ORIGINAL_MSGID,
00712                    msg->typinf->con->err)
00713     )
00714 
00715     if (value != NULL)
00716     {
00717         ub4 raw_len = 0;
00718 
00719         raw_len = OCIRawSize(OCILib.env, value);
00720 
00721         if (*len > raw_len)
00722             *len = raw_len;
00723 
00724         memcpy(id, OCIRawPtr(OCILib.env, value), (size_t) (*len));
00725     }
00726     else
00727     {
00728         *len = 0;
00729     }
00730 
00731     OCI_RESULT(res);
00732 
00733     return res;
00734 }
00735 
00736 /* --------------------------------------------------------------------------------------------- *
00737  * OCI_MsgSetOriginalID
00738  * --------------------------------------------------------------------------------------------- */
00739 
00740 boolean OCI_API OCI_MsgSetOriginalID
00741 (
00742     OCI_Msg      *msg,
00743     const void   *id,
00744     unsigned int len
00745 )
00746 {
00747     boolean res   = TRUE;
00748     OCIRaw *value = NULL;
00749 
00750     OCI_CHECK_PTR(OCI_IPC_MSG,  msg, FALSE);
00751 
00752     OCI_CALL2
00753     (
00754         res, msg->typinf->con,
00755 
00756         OCIRawAssignBytes(OCILib.env, msg->typinf->con->err,
00757                           (ub1*) id, (ub4) len, (OCIRaw **) &value)
00758     )
00759 
00760     OCI_CALL2
00761     (
00762         res, msg->typinf->con,
00763 
00764         OCIAttrSet((dvoid *) msg->proph,
00765                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00766                    (dvoid *) &value,
00767                    (ub4    ) 0,
00768                    (ub4    ) OCI_ATTR_ORIGINAL_MSGID,
00769                    msg->typinf->con->err)
00770     )
00771 
00772     OCI_RESULT(res);
00773 
00774     return res;
00775 }
00776 
00777 /* --------------------------------------------------------------------------------------------- *
00778  * OCI_MsgGetCorrelation
00779  * --------------------------------------------------------------------------------------------- */
00780 
00781 const mtext * OCI_API OCI_MsgGetCorrelation
00782 (
00783     OCI_Msg *msg
00784 )
00785 {
00786     boolean res = TRUE;
00787 
00788     OCI_CHECK_PTR(OCI_IPC_MSG, msg, NULL);
00789 
00790     if (msg->correlation == NULL)
00791     {
00792         res = OCI_StringGetFromAttrHandle(msg->typinf->con,
00793                                           msg->proph,
00794                                           OCI_DTYPE_AQMSG_PROPERTIES,
00795                                           OCI_ATTR_CORRELATION,
00796                                           &msg->correlation);
00797     }
00798 
00799     OCI_RESULT(res);
00800 
00801     return msg->correlation;
00802 }
00803 
00804 /* --------------------------------------------------------------------------------------------- *
00805  * OCI_MsgSetCorrelation
00806  * --------------------------------------------------------------------------------------------- */
00807 
00808 boolean OCI_API OCI_MsgSetCorrelation
00809 (
00810     OCI_Msg     *msg,
00811     const mtext *correlation
00812 )
00813 {
00814     boolean res = TRUE;
00815 
00816     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00817 
00818     res =  OCI_StringSetToAttrHandle(msg->typinf->con,
00819                                      msg->proph,
00820                                      OCI_DTYPE_AQMSG_PROPERTIES,
00821                                      OCI_ATTR_CORRELATION,
00822                                      &msg->correlation,
00823                                      correlation);
00824 
00825     OCI_RESULT(res);
00826 
00827     return res;
00828 }
00829 
00830 /* --------------------------------------------------------------------------------------------- *
00831  * OCI_MsgGetExceptionQueue
00832  * --------------------------------------------------------------------------------------------- */
00833 
00834 const mtext * OCI_API OCI_MsgGetExceptionQueue
00835 (
00836     OCI_Msg *msg
00837 )
00838 {
00839     boolean res = TRUE;
00840 
00841     OCI_CHECK_PTR(OCI_IPC_MSG, msg, NULL);
00842 
00843     if (msg->except_queue == NULL)
00844     {
00845         res = OCI_StringGetFromAttrHandle(msg->typinf->con,
00846                                           msg->proph,
00847                                           OCI_DTYPE_AQMSG_PROPERTIES,
00848                                           OCI_ATTR_EXCEPTION_QUEUE,
00849                                           &msg->except_queue);
00850     }
00851 
00852     OCI_RESULT(res);
00853 
00854     return msg->except_queue;
00855 }
00856 
00857 /* --------------------------------------------------------------------------------------------- *
00858  * OCI_MsgSetExceptionQueue
00859  * --------------------------------------------------------------------------------------------- */
00860 
00861 boolean OCI_API OCI_MsgSetExceptionQueue
00862 (
00863     OCI_Msg     *msg,
00864     const mtext *queue
00865 )
00866 {
00867     boolean res = TRUE;
00868 
00869     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00870 
00871     res =  OCI_StringSetToAttrHandle(msg->typinf->con,
00872                                      msg->proph,
00873                                      OCI_DTYPE_AQMSG_PROPERTIES,
00874                                      OCI_ATTR_EXCEPTION_QUEUE,
00875                                      &msg->except_queue,
00876                                      queue);
00877 
00878     OCI_RESULT(res);
00879 
00880     return res;
00881 }
00882 
00883 /* --------------------------------------------------------------------------------------------- *
00884  * OCI_MsgGetSender
00885  * --------------------------------------------------------------------------------------------- */
00886 
00887 OCI_Agent * OCI_API OCI_MsgGetSender
00888 (
00889     OCI_Msg   *msg
00890 )
00891 {
00892     boolean res = TRUE;
00893     OCIAQAgent *handle = NULL;
00894     OCI_Agent  *sender = NULL;
00895 
00896     OCI_CHECK_PTR(OCI_IPC_MSG, msg, NULL);
00897 
00898     OCI_CALL2
00899     (
00900         res, msg->typinf->con,
00901 
00902         OCIAttrGet((dvoid *) msg->proph,
00903                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00904                    (dvoid *) &handle,
00905                    (ub4    ) 0,
00906                    (ub4    ) OCI_ATTR_SENDER_ID,
00907                    msg->typinf->con->err)
00908     )
00909 
00910     if ((res == TRUE) && (handle != NULL))
00911     {
00912         sender = OCI_AgentInit(msg->typinf->con, &msg->sender, handle, NULL, NULL);
00913     }
00914 
00915     OCI_RESULT(res);
00916 
00917     return sender;
00918 }
00919 
00920 /* --------------------------------------------------------------------------------------------- *
00921  * OCI_MsgSetSender
00922  * --------------------------------------------------------------------------------------------- */
00923 
00924 boolean OCI_API OCI_MsgSetSender
00925 (
00926     OCI_Msg   *msg,
00927     OCI_Agent *sender
00928 )
00929 {
00930     boolean res = TRUE;
00931 
00932     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00933 
00934     OCI_CALL2
00935     (
00936         res, msg->typinf->con,
00937 
00938         OCIAttrSet((dvoid *) msg->proph,
00939                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00940                    (dvoid *) (sender ? sender->handle : NULL),
00941                    (ub4    ) 0,
00942                    (ub4    ) OCI_ATTR_SENDER_ID,
00943                    msg->typinf->con->err)
00944     )
00945 
00946     OCI_RESULT(res);
00947 
00948     return res;
00949 }
00950 
00951 /* --------------------------------------------------------------------------------------------- *
00952  * OCI_MsgSetConsumers
00953  * --------------------------------------------------------------------------------------------- */
00954 
00955 boolean OCI_API OCI_MsgSetConsumers
00956 (
00957     OCI_Msg     *msg,
00958     OCI_Agent  **consumers,
00959     unsigned int count
00960 )
00961 {
00962     boolean res          = TRUE;
00963     OCIAQAgent **handles = NULL;
00964 
00965     OCI_CHECK_PTR(OCI_IPC_MSG, msg, FALSE);
00966 
00967     /* allocate local array of OCIAQAgent handles if needed */
00968 
00969     if ((consumers != NULL) && (count > 0))
00970     {
00971         handles = (OCIAQAgent **) OCI_MemAlloc(OCI_IPC_ARRAY,sizeof(OCIAQAgent *),
00972                                                count, FALSE);
00973 
00974         if (handles != NULL)
00975         {
00976             unsigned int i;
00977 
00978             for(i = 0; i < count; i++)
00979             {
00980                 handles[i] = consumers[i]->handle;
00981             }
00982         }
00983     }
00984     else
00985     {
00986         count = 0;
00987     }
00988 
00989     OCI_CALL2
00990     (
00991         res, msg->typinf->con,
00992 
00993         OCIAttrSet((dvoid *) msg->proph,
00994                    (ub4    ) OCI_DTYPE_AQMSG_PROPERTIES,
00995                    (dvoid *) handles,
00996                    (ub4    ) count,
00997                    (ub4    ) OCI_ATTR_RECIPIENT_LIST,
00998                    msg->typinf->con->err)
00999     )
01000 
01001 
01002     /* free local array of OCIAQAgent handles if needed */
01003 
01004     if (handles != NULL)
01005     {
01006         OCI_FREE(handles);
01007     }
01008 
01009     OCI_RESULT(res);
01010 
01011     return res;
01012 }

Generated on Mon Dec 13 2010 22:32:01 for OCILIB (C Driver for Oracle) by  doxygen 1.7.2