C++ TibrvMsg::updateString方法代码示例

// ////////////////////////////////////////////////////////////////////////////
//	Update char *
void UpdateRvField(TibrvMsg &msg, const char *field_name, const char *value,
	tibrv_u16 field_id)
{
	TibrvStatus rv_status;

	if ((rv_status = msg.updateString(field_name, value, field_id)) != TIBRV_OK)
		ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}

int main(int argc, char** argv)
{
    TibrvStatus status;
    int i, j;

    // open Tibrv
    status = Tibrv::open();
    if (status != TIBRV_OK)
    {
        fprintf(stderr,"Error: could not open TIB/RV, status=%d, text=%s\n",
            (int)status,status.getText());
        exit(-1);
    }

    // Get process transport
    TibrvTransport* transport = Tibrv::processTransport();

    // Create the queue
    TibrvQueue queue;
    queue.create();

    // Create trigger queue
    triggerQueue.create();

    // Create wait queue
    waitQueue.create();

    // Create listener
    TibrvListener listener;
    listener.create(&queue,new MsgCallback(),transport,subject,NULL);

    // Create message and set send subject in it.
    TibrvMsg msg;
    msg.setSendSubject(subject);

    // Create two dispatchers
    TibrvDispatcher dispatcher1, dispatcher2;
    dispatcher1.create(&queue);
    dispatcher2.create(&queue);

    // Get start time
    startTime = time(0);

    // We use this to track the message number
    int msgIndex = 0;

    // Report we are starting to publish messages
    printf("Started publishing messages at %d seconds\n\n",
                    (int)(time(0)-startTime));
    fflush(stdout);

    // Start publishing two messages at a time
    // every second, total of TOTAL_MESSAGES messages
    for (i=0; i<TOTAL_MESSAGES/2; i++)
    {
        // Publish 2 messages
        for (j=0; j<2; j++)
        {
            char str[32];
            msgIndex++;
            sprintf(str,"value-%d",msgIndex);
            msg.updateString("field",str);
            transport->send(msg);
        }

        /* Sleep for 1 second if we have not done publishing */
        if (i < TOTAL_MESSAGES/2-1)
        {
            waitQueue.timedDispatch((tibrv_f64)1.0);
        }
    }

    // Report we've published all messages
    printf("\nStopped publishing messages at %d seconds\n\n",
                    (int)(time(0)-startTime));
    fflush(stdout);

    // We should not quit main because that will
    // cause the program to quit before we
    // process all messages.
    // Wait until we process all messages and
    // post an event into the trigger queue which
    // will cause dispatch() to return.
    triggerQueue.dispatch();

    // Report we have processed all messages
    printf("\nProcessed all messages in %d seconds\n",(int)(time(0)-startTime));
    fflush(stdout);

    // Close Tibrv
    Tibrv::close();

    return 0;
}

int main(int argc, char** argv)
{
    TibrvStatus status;
    int i;

    // open Tibrv
    status = Tibrv::open();
    if (status != TIBRV_OK)
    {
        fprintf(stderr,"Error: could not open TIB/RV, status=%d, text=%s\n",
            (int)status,status.getText());
        exit(-1);
    }

    // get process transport
    TibrvTransport* transport = Tibrv::processTransport();

    // create two queues
    TibrvQueue queue1;
    TibrvQueue queue2;
    queue1.create();
    queue2.create();

    // Set priorities
    queue1.setPriority(1);
    queue2.setPriority(2);

    // Create queue group and add queues
    TibrvQueueGroup group;
    group.create();

    group.add(&queue1);
    group.add(&queue2);

    // Create callback object
    MsgCallback* callback = new MsgCallback();

    // Create listeners
    TibrvListener listener1, listener2;
    listener1.create(&queue1,callback,transport,subject1,NULL);
    listener2.create(&queue2,callback,transport,subject2,NULL);

    TibrvMsg msg;

    // Send 10 messages on subject1
    msg.setSendSubject(subject1);
    for (i=0; i<10; i++)
    {
        char valstr[32];
        sprintf(valstr,"value-1-%d",(i+1));
        msg.updateString("field",valstr);
        transport->send(msg);
    }

    // Send 10 messages on subject2
    msg.setSendSubject(subject2);
    for (i=0; i<10; i++)
    {
        char valstr[32];
        sprintf(valstr,"value-2-%d",(i+1));
        msg.updateString("field",valstr);
        transport->send(msg);
    }

    // Dispatch the group. When all events are
    // dispatched timedDispatch() will return
    // TIBRV_TIMEOUT so we'll break out the while() loop.
    while (group.timedDispatch(1) == TIBRV_OK);

    // Close Tibrv
    Tibrv::close();

    return 0;
}