TibrvMsg*
TibrvMsg::detach()
{
    if ((_detached == TIBRV_TRUE) || (_status != TIBRV_OK))
        return NULL;

    // allocate new object
    TibrvMsg * newmsg = new TibrvMsg();
    if (newmsg == NULL) return NULL;

    // detach if not yet detached
    if (_detached == TIBRV_FALSE) // this is redundand but may be needed
    {
        TibrvStatus status;
        if (_msg != NULL)
        {
            if ((status = tibrvMsg_Detach(_msg)) != TIBRV_OK)
            {
                delete newmsg;
                return NULL;
            }
        }
        _detached = TIBRV_TRUE;
    }

    newmsg->attach(_msg,TIBRV_TRUE);

    //  invalidate this handle so we won't try to delete it
    _msg=NULL;
    _status = TIBRV_NOT_INITIALIZED;
    _detached = TIBRV_TRUE;

    return newmsg;
}

    void onMsg(TibrvListener* listener, TibrvMsg& msg)
    {
        const char* sendSubject  = NULL;
        const char* msgString    = NULL;

        // Get the subject name to which this message was sent
        msg.getSendSubject(sendSubject);

        // Convert the incoming message to a string
        msg.convertToString(msgString);

        printf("Received message on subject %s: %s\n",
                   sendSubject, msgString);

        fflush(stdout);
    }

    void onMsg(TibrvListener* listener, TibrvMsg& msg)
    {
        const char* msgString = NULL;

        // Convert the incoming message to a string
        msg.convertToString(msgString);

        // Report we are processing the message
        printf("Processing message %s\n",msgString);
        fflush(stdout);

        // Imitate delay of one second
        waitQueue.timedDispatch((tibrv_f64)1.0);

        /* Increase count of processed messages. In real world
         * access to this variable should be guarded
         * because we may be changing it from multiple
         * dispatcher threads at the same time.
         */
        processedMessageCount++;

        /* If we have processed all messages then report it
         * and create a timer on the trigger queue so the
         * dispatch call on that queue returns.
         */
        if (processedMessageCount == TOTAL_MESSAGES)
        {
            /* we don't need to keep the timer here */
            TibrvTimer* timer = new TibrvTimer();
            timer->create(&triggerQueue,
                          new TimerCallback(),
                          (tibrv_f64)0, /* no delay */
                          NULL);
        }
    }

TibrvStatus
TibrvMsg::updateMsg(const char* fieldName,const TibrvMsg& msg, tibrv_u16 fieldId)
{
    _create();
    if (_status != TIBRV_OK) return TibrvStatus(_status);
    return tibrvMsg_UpdateMsgEx(_msg,fieldName,msg.getHandle(),fieldId);
}

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

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

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

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

// ////////////////////////////////////////////////////////////////////////////
//	Update XML byte string
void UpdateRvFieldXml(TibrvMsg &msg, const char *field_name,
	const std::string &value, tibrv_u16 field_id)
{
	TibrvStatus rv_status;

	if ((rv_status = msg.updateXml(field_name, value.c_str(),
		static_cast<unsigned int>(value.size()), field_id)) != TIBRV_OK)
		ThrowIfUpdateRvFieldError(rv_status, field_name, field_id);
}

TibrvStatus
TibrvMsg::createCopy(TibrvMsg& copy)
{
    _create();
    if (_status != TIBRV_OK) return _status;
    tibrvMsg newmsg;
    tibrv_status status = tibrvMsg_CreateCopy(_msg,&newmsg);
    if (status == TIBRV_OK)
        copy.attach(newmsg,TIBRV_TRUE);
    return status;
}

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

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