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

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;
}

static PyObject*
typemethod_send(PyTibrvNetTransportObject *self, PyObject *args, PyObject *kwds)
{
    char *send_subject = NULL, *reply_subject = NULL;
	PyObject* message_dictionary;

    static char *kwlist[] = {"sendsubject", "message", "replysubject", NULL};

    if (! PyArg_ParseTupleAndKeywords(args, kwds, "sO|s", kwlist, &send_subject, &message_dictionary, &reply_subject))
        return NULL; 
	
	TibrvStatus status;

	TibrvMsg msg;
	status = msg.setSendSubject(send_subject);
	if (status != TIBRV_OK)
	{
		PyErr_Tibrv(status);
		return NULL;
	}

	if (reply_subject != 0)
		msg.setReplySubject(reply_subject);

	if (!PyDict_Check(message_dictionary))
	{
		PyErr_SetString(PyExc_TypeError, "expected message to be dictionary");
		return NULL;
	}

	PyObject *key, *value;
	int pos = 0;

	while (PyDict_Next(message_dictionary, &pos, &key, &value))
	{
		if (PyObject_Is<const char*>(key))
		{
			const char* mnemonic = PyObject_As<const char*>(key);

			if (PyObject_Is<tibrv_i32>(value))
				status = msg.addI32(mnemonic, PyObject_As<tibrv_i32>(value));
			else if (PyObject_Is<const char*>(value))
				status = msg.addString(mnemonic, PyObject_As<const char*>(value));
			else if (PyObject_Is<tibrv_f64>(value))
				status = msg.addF64(mnemonic, PyObject_As<tibrv_f64>(value));
			else if (PyObject_Is<tibrv_bool>(value))
				status = msg.addBool(mnemonic, PyObject_As<tibrv_bool>(value));
			else if (PyObject_Is<tibrvMsgDateTime>(value))
				status = msg.addDateTime(mnemonic, PyObject_As<tibrvMsgDateTime>(value));
			else
			{
				PyErr_SetString(PyExc_TypeError, "invalid type for tibco message");
				return NULL;
			}

			if (status != TIBRV_OK)
			{
				PyErr_Tibrv(status);
				return NULL;
			}
		}
	}

	status = self->transport->send(msg);
	if (status != TIBRV_OK)
	{
		PyErr_Tibrv(status);
		return NULL;
	}

	Py_INCREF(Py_None);
    return Py_None;
}

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;
}